Implement via grok (Grok Build)

A paid-pool write leg, tier peer of codex-implement and agy-implement. Its output is Grok-family work: the review gate for anything it writes must come from a different model family — that is the suite's headline cross-family rule, and it is the main reason to spend this pool on implementation at all (it frees the GPT/Gemini/Claude legs to review).

Before the first run of a session

Read references/grok-runtime.md. The items that bite the write role hardest: the machine's config.toml may carry a global always-approve default (state the posture explicitly, never inherit it), the sandbox is kernel-gated and silently unenforced on old kernels, and this adapter has zero calibration-journal rows of its own (the Grok-family rows in cursor-runtime.md were served through cursor) — first dispatches are calibration runs, verified accordingly.

Worktree, snapshot, then dispatch

Every write leg gets its own worktree, without exception — same rule, same helpers, same reasons as the other families:

RUN_DIR=$(mktemp -d "${TMPDIR:-/tmp}/grok-implement.XXXXXX")   # FIRST — the snapshot lands here
BASE=$(git rev-parse HEAD)   # from a clean checkout, recorded before anything
WORKTREE=../<repo>-grok-<short-task-slug>
git worktree add -b grok/<short-task-slug> "$WORKTREE" "$BASE"
# The helper lives in the SUITE's tree, cwd is the TARGET repo — a bare
# `scripts/…` resolves against the target and exits 127.
DEV_LEAD=${DEV_LEAD_ROOT:-$(ls -d "$HOME"/.claude/plugins/cache/dev-lead/dev-lead/* 2>/dev/null | sort -V | tail -1)}
[ -x "$DEV_LEAD/scripts/snapshot-refs.sh" ] || { echo "dev-lead root unresolved — set DEV_LEAD_ROOT to your checkout"; exit 1; }
"$DEV_LEAD/scripts/snapshot-refs.sh" save "$WORKTREE" "$RUN_DIR/remote-refs.before"   # push-detection baseline

The snapshot matters MORE here than on agy: grok's shell tool is unrestricted inside its permission mode, so the no-push rule is instruction level on this adapter (state it in the task prompt), and the fail-closed ref check at handoff is what turns "surely it didn't push" into evidence, either way.

Launch

# Write the task prompt to "$RUN_DIR/task.md" in its own FOREGROUND step.
cd "$WORKTREE" && \
  grok --prompt-file "$RUN_DIR/task.md" \
    -m grok-4.6 \
    --effort medium \
    --permission-mode bypassPermissions \
    --sandbox workspace \
    --disallowed-tools "Agent" \
    --no-memory --verbatim \
    --max-turns 80 \
    --output-format plain > "$RUN_DIR/impl.out" 2>&1

• --permission-mode bypassPermissions is stated, not inherited — the config default may already say the same thing, and that is exactly why the flag is on the command line: a run log must show its posture (runtime file, config trap).
• --sandbox workspace confines writes to the worktree + temp dirs on kernels that enforce it (documented); on older kernels it is a warned no-op and the worktree boundary + refs snapshot are the real containment.
• --disallowed-tools "Agent" — one delegate, one worktree; subagents inherit always-approve and answer to nobody's plan (runtime file).
• Effort: medium for routine implementation; spend high on review legs first when the weekly pool is tight — review leverage is higher.

Handoff

Check the refs snapshot, verify the worktree, then the lead reviews and commits:

"$DEV_LEAD/scripts/snapshot-refs.sh" check "$WORKTREE" "$RUN_DIR/remote-refs.before" || exit 1
git -C "$WORKTREE" status --porcelain=v1
git -C "$WORKTREE" diff "$BASE" --stat

The helper exits nonzero on a remote-ref delta, and || exit 1 makes that failure terminal for this handoff. Do not replace it with a second snapshot and a raw diff, which can be noticed but accidentally continued past.

Whether grok leaves work committed or uncommitted in the worktree is UNVERIFIED (runtime file) — expect either, and treat the lead's own verification pass as the merge gate regardless: build/tests run by the lead, in the worktree, before anything is called done. The change then goes to a reviewer from a different model family — never a Grok reviewer for a Grok implementation.