opencode-skills-collection 4.0.45 → 4.0.47

package/bundled-skills/claude-delegate/references/writing-the-brief.md

@@ -0,0 +1,158 @@
+# Writing the brief
+
+A brief carries the task-specific context from the orchestrator to the separate Claude Code session.
+The implementer has **no orchestrator chat history or other shared context**. It receives the brief on
+stdin, can inspect the target working tree, and loads Claude Code's usual local context as described
+below. A resumed session also retains its own Claude conversation.
+
+If a fact is not in the brief, discoverable in that tree, or present in the loaded Claude context, do
+not assume the implementer knows it.
+
+## Know what Claude loads
+
+The relay deliberately does not use `--bare`, so Claude Code discovers the project's `CLAUDE.md`,
+normal local Claude settings, and session state in its usual way. The relay overrides a small,
+inspectable subset for the child: MCP servers are not discovered, skills and commands are disabled,
+and the built-in tool surface is restricted. Local hooks still load; account for any repository
+effects they are configured to perform.
+
+Claude Code does **not** generically auto-load `AGENTS.md`. Before writing the brief:
+
+1. Read the applicable `AGENTS.md` files yourself.
+2. Copy every load-bearing rule into the brief: scope boundaries, forbidden patterns, required
+   commands, generated-file policy, and commit policy.
+3. Name the real gates rather than telling Claude to "run the tests."
+
+The implementer can read an `AGENTS.md` when the brief points to it, but that is explicit task context,
+not automatic Claude Code behavior.
+
+## A compact structure
+
+Use a bounded, block-structured brief:
+
+```xml
+<task>
+State the concrete job, current behavior, desired behavior, and where it lives. Name what must remain
+untouched. Include any facts from the orchestrator conversation that the implementer cannot discover
+from the tree.
+</task>
+
+<repo_constraints>
+Copy the applicable load-bearing constraints from AGENTS.md and other project instructions here.
+Claude also loads CLAUDE.md, but restate rules whose violation would invalidate the work.
+</repo_constraints>
+
+<verification_loop>
+Run these exact project gates, fix failures caused by the change, and report the final outcomes:
+  <actual test command>
+  <actual lint/format command>
+  <actual build/typecheck command>
+Confirm the working tree contains only intended changes.
+</verification_loop>
+
+<action_safety>
+Keep changes within the task. Do not perform unrelated cleanup. Do not run git add, git commit, or git
+push. Do not invoke another Claude session or delegation skill. Leave all work uncommitted for the
+orchestrator to review and land.
+</action_safety>
+
+<structured_output_contract>
+End with:
+  1. What changed and why
+  2. Files touched
+  3. Gate outcomes, including useful counts
+  4. Deviations, open questions, and decisions the orchestrator should review
+</structured_output_contract>
+```
+
+Remove empty blocks rather than adding ceremony. Add focused blocks when needed:
+
+- **Debugging:** `<completeness_contract>` to require a full root-cause fix, and
+  `<missing_context_gating>` to prohibit guesses about missing repository facts.
+- **Read-only diagnosis:** `<grounding_rules>` to require file/line or command evidence and clearly
+  label inference. Dispatch with `--read-only`.
+- **Migration or removal:** an explicit repository-wide search and round-trip requirement.
+
+## Discover the real gates
+
+Read the repository's `CLAUDE.md`, `AGENTS.md`, `Makefile`, package scripts, and language tooling before
+dispatch. Copy exact commands into `<verification_loop>`. Include required setup and the narrowest
+useful test slice, but do not replace a required full gate with a guessed shortcut.
+
+`acceptEdits` alone does not approve ordinary gate commands in non-interactive mode. On supported
+platforms the normal relay profile auto-approves commands that stay inside Claude's shell sandbox and
+requests failure when that sandbox is unavailable. A gate that needs network access, host services,
+or writes outside the working tree may fail under that profile; state the need in the brief and decide
+whether a different isolated environment is appropriate instead of silently weakening the boundary.
+Merged local or managed settings can affect the effective sandbox. Native Windows pre-approves
+PowerShell without that sandbox; see [dispatch-and-poll.md](dispatch-and-poll.md).
+
+## One task per brief
+
+One brief → one separate Claude session → one reviewed commit keeps scope and rollback clear. Split a
+mixed request such as "fix the bug, redesign the API, update unrelated docs, and propose a roadmap"
+into separate dispatches.
+
+Use a resumed session only for rework on the same task. Start unrelated queue items in fresh sessions.
+
+## Premises freeze at dispatch
+
+There is no steering channel while the relay is running. Audit ownership, scope, branch, constraints,
+and expected behavior before dispatch. If a premise changes during the run, stop it and inspect the
+working tree before sending a corrected brief. Do not discard partial edits before reviewing them.
+
+## Delta briefs for resumed sessions
+
+`--resume-last` maps to Claude's `--continue`; `--session <id>` maps to `--resume <id>`. Both retain the
+conversation, so send only what changed:
+
+```xml
+<review_delta>
+The implementation behavior is correct. Replace the test's mocked database session with the existing
+migrated fixture, remove the unused import, run the same gates, and leave the tree uncommitted.
+</review_delta>
+```
+
+The relay re-passes the selected permission profile on resume. A resumed run receives the same review
+as a fresh run.
+
+## Brief delivery
+
+The relay reads `--brief <file>` or stdin, saves the exact text as `brief.txt`, and sends it to
+`claude -p` through stdin — never as an argv value. It therefore stays out of the process list and
+needs no shell quoting. Claude Code caps piped stdin at 10 MB; the relay rejects a larger brief before
+dispatch. Put large context in workspace files and reference those paths instead.
+
+## Worked example
+
+```xml
+<task>
+In services/billing/, refund retries can create a second refund because the idempotency key is checked
+after submission. Check for an existing refund before creating one. Touch only refund handling and
+its behavior-level tests. Leave charge creation, routes, and data models unchanged.
+</task>
+
+<repo_constraints>
+Follow the repository's Python style and test conventions copied from AGENTS.md. Do not add ticket
+identifiers to source comments. Do not add dependencies.
+</repo_constraints>
+
+<verification_loop>
+Run and make green:
+  pytest tests/billing/ -q
+  ruff check services/billing/ tests/billing/
+Confirm git status contains only the intended refund implementation and tests.
+</verification_loop>
+
+<action_safety>
+No unrelated refactors. Do not git add, commit, or push; leave the work uncommitted.
+</action_safety>
+
+<structured_output_contract>
+Report the root cause and fix, files touched, pytest and ruff outcomes with counts, and anything left
+open or needing a decision.
+</structured_output_contract>
+```
+
+Dispatch with [dispatch-and-poll.md](dispatch-and-poll.md), then review and land with
+[review-and-land.md](review-and-land.md).

package/bundled-skills/cline-delegate/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: cline-delegate
+description: Delegate coding tasks to the Cline CLI (`cline`) only when the user explicitly
+  requests it, while the orchestrator retains review and landing responsibility.
+risk: safe
+category: agent-orchestration
+source: https://github.com/amElnagdy/delegate-skills
+source_repo: amElnagdy/delegate-skills
+source_type: community
+date_added: '2026-08-26'
+license: MIT
+license_source: https://github.com/amElnagdy/delegate-skills/blob/master/LICENSE
+compatibility: Requires the `cline` CLI installed and authenticated with `cline auth`,
+  Node 18+, and git. The orchestrator must be able to run shell commands and read
+  files.
+metadata:
+  version: 0.5.0
+---
+# Cline Delegate
+
+## When to Use
+
+- You want to delegate a bounded coding task to a separate `cline` implementer (`Cline`) and then review its diff yourself.
+- The user explicitly asked for delegation to this implementer.
+
+You are the **orchestrator**. Delegate a bounded coding task to a separate **implementer** - the Cline
+coding agent CLI - then review what it produced and land it yourself. You write the brief and own
+the judgment; the implementer makes changes in its own session in a clean working tree; you verify
+and commit.
+
+The loop needs only a shell command and file access, so any comparable orchestrator can drive it.
+
+## When NOT to use this
+
+- The task is small enough to do inline; delegation overhead is not worth it.
+- The `cline` CLI is not installed or authenticated.
+- You require the relay to configure a sandbox. Cline exposes sandbox controls, but this relay
+  leaves them to the CLI environment; use `--plan` when the run must be read-only.
+
+## Prerequisites (check once)
+
+1. Install `cline` (npm or bundled binary; the relay probes `cline --version`).
+2. Authenticate: run `cline auth` (interactive sign-in), or configure
+   `ANTHROPIC_API_KEY` / an OpenAI-compatible base URL.
+3. Confirm `cline --version` succeeds.
+4. Work in, or point `--cd` at, the target git repository.
+
+## Choose the model (optional)
+
+Cline picks a default model. To choose another, pass the separate `--model <id>` or `--provider <name>`
+(e.g. `anthropic`, `openai-native`, `openrouter`). The relay accepts letters, digits,
+and `. _ : / -` only (the value reaches a shell on Windows).
+
+## The loop
+
+Run these five steps per task. Steps 1, 4, and 5 require judgment; 2 and 3 are mechanical.
+
+### 1. Write a brief
+
+Cline sees only the text you send. It cannot read your conversation: the brief must stand alone
+with the goal, current state, what to change, what to leave untouched, the project's **real**
+gates, and a report contract. Keep each brief to a single task. Write it to a file and pass it as
+the relay's `--brief`. See [references/writing-the-brief.md](references/writing-the-brief.md).
+
+### 2. Dispatch
+
+Use the bundled relay. It runs `cline --json -v`, streams the brief on stdin behind a fixed
+positional instruction, captures the JSON event stream, and writes `result.json`.
+
+```bash
+node "<skill-dir>/scripts/relay.mjs" --brief brief.txt --cd /path/to/repo
+# choose a model / provider:        add --model <id>  --provider <name>
+# read-only planning pass:          add --plan   (forces --auto-approve false)
+# deny approval-required tools:     add --auto-approve false
+# hard time limit (watchdog):        add --timeout 2h   (the 30m default suits brief runs; most implementation briefs should be 1-2h)
+# see all options:                   node .../relay.mjs --help
+```
+
+The child's cwd pins the workspace. The relay writes artifacts under the system temp dir by
+default and never commits. See [references/dispatch-and-poll.md](references/dispatch-and-poll.md).
+
+### 3. Wait for completion
+
+The relay blocks until cline finishes. Run it with the orchestrator's background-command
+facility, or background it in the shell and poll for `result.json`. A pre-run usage error exits 2
+and writes no result; a missing `cline` exits 127 and writes `status: "cline_unavailable"`.
+
+Completion means the process exited and `result.json` exists - trust process state and the
+working tree, not the progress display. Cline's final message is the `finalMessage` field of
+`result.json`.
+
+### 4. Review - do not trust the self-report
+
+- Re-run the project's gates yourself.
+- Read the diff against the brief, starting with `touchedFiles`.
+- Run relevant guard skills if installed.
+
+See [references/review-and-land.md](references/review-and-land.md).
+
+### 5. Land it
+
+If the work is good, commit it. The relay never commits - the diff and `result.json` are the
+record; run `git status` and `git diff` first to confirm exactly what changed. If the group has a
+PR flow, make the commit and push a branch; let human review happen. If the diff is wrong or
+incomplete, re-dispatch a corrected brief in a fresh run and review again.
+
+## Autonomy and permissions
+
+The relay explicitly passes Cline's `--auto-approve`, defaulting to `true` in act mode. Cline
+plan mode can request a switch to act mode, so `--plan` forces `--auto-approve false`; the relay
+rejects `--plan --auto-approve true`. That pair is the read-only gate. Cline also exposes sandbox
+through `--data-dir` / `CLINE_SANDBOX`, but the relay does not configure or override it. Plan-first
+for anything risky, then review the plan before a separate act-mode dispatch. Malformed or malicious
+briefs remain dangerous in act mode because commands run as the current user.
+
+## Authorization model
+
+Delegation is something the human opts into. Once briefed, cline works as a tool you approved use
+of. The boundary is: **do not accept conclusions from the self-report**; verify everything on
+disk. For anything touching credentials, production data, or irreversible operations, stop and ask
+the human first instead of encoding it in a brief.
+
+## References
+
+- [references/writing-the-brief.md](references/writing-the-brief.md) - structure, scope, gates,
+  brief delivery.
+- [references/dispatch-and-poll.md](references/dispatch-and-poll.md) - flags, artifacts,
+  `result.json`, and failure recovery.
+- [references/review-and-land.md](references/review-and-land.md) - what to verify before calling
+  the diff done, at the end of a run.
+- [references/multi-task-queues.md](references/multi-task-queues.md) - sequential queues,
+  constraint carry-forward, progress tracking, and the final coherence pass.
+
+
+## Limitations
+
+- Docs-only import — executable `scripts/relay.mjs` not included; see upstream for full runtime. Requires `cline` CLI, Node 18+, git.
+- Relay never commits — it only returns structured result JSON; you review and land the commit.
+
+> Adapted from [amElnagdy/delegate-skills](https://github.com/amElnagdy/delegate-skills) (MIT) — docs-only, runtime not bundled.

package/bundled-skills/cline-delegate/references/dispatch-and-poll.md

@@ -0,0 +1,142 @@
+# Dispatch and poll
+
+`scripts/relay.mjs` wraps cline's headless JSON mode, captures its NDJSON event stream, and writes
+a `result.json`. Run one command, then read one file.
+
+## Before the first run
+
+```bash
+command -v cline
+cline --version
+```
+
+Install `cline`; on macOS/Linux it ships as a native binary, on Windows as an npm package (the
+relay launches the `.cmd` shim with `shell:true`). Authenticate with `cline auth`. A headless run
+that is not authenticated fails with `status: "failed"` (exit 1).
+
+## Dispatching
+
+```bash
+node "<skill-dir>/scripts/relay.mjs" --brief brief.txt --cd /path/to/repo
+```
+
+`<skill-dir>` is the installed folder containing this skill's `SKILL.md`.
+
+| Flag | Effect |
+| --- | --- |
+| `--brief <file>` | Brief path. Omit it to read the brief from stdin. |
+| `--cd <dir>` | Working root and child process cwd (default: current directory). |
+| `--lane <name>` | Fleet lane from `delegate-setup` config. Applies that lane's dials; fails if the lane's `implementer` is not this relay. Explicit dial flags win. |
+| `--provider <name>` | Cline provider name (default: cline's own default). Token-validated. |
+| `--model <id>` | Cline model id (default: cline's own default). Provider-local and qualified ids are accepted. Token-validated: letters, digits, `. _ : / -`. |
+| `--plan` | Plan mode with `--auto-approve false`; explicit `--auto-approve true` is rejected so Cline cannot auto-approve a switch to act mode. |
+| `--auto-approve <bool>` | Cline tool auto-approval. Defaults to `true` in act mode and `false` with `--plan`. |
+| `--timeout <dur>` | Relay watchdog (default: `30m`; h/m/s strings). The relay never passes it as Cline's own `-t` / `--timeout`. |
+| `--out-dir <dir>` | Artifact directory (default: a fresh directory under the system temp dir). |
+| `-h`, `--help` | Print the relay's header help. |
+
+The child cwd pins the workspace; the relay does not pass Cline's `--cwd`. `-v` (verbose) exposes
+provider and model in `run_start`. Fresh JSON runs may omit `sessionId`, and the verified headless
+JSON path does not support resume, so the relay has no resume flag.
+
+## Artifacts and result fields
+
+Artifacts live outside the repo by default, so they do not appear in `touchedFiles`; an
+`--out-dir` inside the worktree can make the artifacts appear there:
+
+- `brief.txt` - the exact brief.
+- `events.jsonl` - raw cline stdout events (every event cline emitted).
+- `final.txt` - cline's final text (`run_result.text`); absent if none was emitted.
+- `stderr.txt` - complete stderr.
+- `result.json` - the stable `delegate-relay.result.v1` contract.
+
+`result.json` fields:
+
+- `schema`, `tool` (`"cline"`), `status` (`completed` | `failed` | `timeout` | `aborted` | `cline_unavailable`), `exitCode`, and `signal` (`null` unless the child died on a signal).
+- `workdir`, requested `provider`/`model`, `planMode`, `autoApprove`, `clineVersion`, `sessionId`,
+  `startedAt`, and `finishedAt`.
+- `actualProvider` and the initial `actualModel` from `run_start`; `run_result` can update the model
+  and supplies `finishReason`, `usage`, and `durationMs`.
+- `briefPath`, nullable `finalPath`, `eventsPath`, and `stderrPath`. `finalPath` is `null` when
+  Cline emitted no final text and `final.txt` was not created.
+- `sessionId` - parsed from `run_start` when Cline emits one; otherwise `null`. It is observational,
+  not a resume promise.
+- `finalMessage` - cline's final text (`run_result.text`).
+- `touchedFiles` - `git status --porcelain` lines for the **final working tree under `--cd` only**,
+  not an attribution of cline's edits: anything already dirty before dispatch shows up too.
+  Dispatch from a clean tree when you want the list to read as "what cline changed". `null` means
+  git could not report; `[]` means git ran and the tree is clean.
+- `stderrTail` - the last 20 non-empty stderr lines on any run that did not complete (`failed`,
+  `timeout`, `aborted`), except a launch failure, which reports `failed` with no `stderrTail`.
+- `error` - present for launch failures, preflight failures, when the relay watchdog fires
+  (`timeout`), and on an `aborted` run.
+
+## Waiting for completion
+
+The relay blocks. Use the orchestrator's background-command facility, or background it in a shell
+and poll for `result.json`. The run is done only when the process exits and the file contains a
+`status`. The result file is written atomically, so a partial read is impossible.
+
+A pre-run usage error exits 2 and writes no result. A missing `cline` exits 127 and writes
+`status: "cline_unavailable"`.
+
+## When a run misbehaves
+
+- **`status: "cline_unavailable"` (exit 127):** cline is not on PATH. Install it, authenticate,
+  and re-dispatch.
+- **`status: "failed"`:** read `stderrTail`, `stderrPath`, and the tail of `events.jsonl`. Common
+  causes: an unknown `--model`, expired credentials, or a provider error. A `run_result` with a
+  `finishReason` other than `completed` is failed even if cline exits zero.
+- **`status: "failed"` with an `error` mentioning `version preflight`:** the bounded `cline --version`
+  probe failed or hung, so cline was never dispatched. Check the install (`cline --version` yourself).
+- **`status: "aborted"`:** the relay itself was killed (its parent's timeout, a stopped task, a
+  closed terminal) and forwarded the kill to cline. The result is written before the relay exits;
+  inspect the working tree before re-dispatching. On native Windows a hard kill of the relay is
+  uncatchable (Node supports no `SIGTERM` handler there), so this status may never get written -
+  a relay process that is gone without a `result.json` is an aborted run; inspect the working
+  tree and `events.jsonl` directly.
+- **`status: "failed"` with `signal: "SIGKILL"`:** the host killed the process, commonly through
+  the OOM killer or a supervisor timeout. This is not a cline error; check host memory and
+  re-dispatch, or split the task into smaller briefs.
+- **`status: "timeout"`:** the `--timeout` watchdog killed the run; `error` reads
+  `cline did not finish within --timeout <dur>; killed by the relay watchdog`. Increase
+  `--timeout` or split the task. On POSIX the relay sends SIGTERM to the process group, waits 10
+  seconds, then sends SIGKILL if needed; on Windows there is no escalation phase - the whole
+  process tree is felled immediately with `taskkill /pid <pid> /t /f`.
+- **Empty `finalMessage`:** inspect `touchedFiles` and the diff. Add a
+  `<structured_output_contract>` to the next brief to require a closing report.
+
+## Recovering lost work
+
+`events.jsonl` in the run directory records every event the implementer streamed. If finished
+work is lost - the run killed late, or the working tree damaged afterward - read the event log
+before re-dispatching: it identifies which files and tool commands were involved, which scopes
+what needs redoing. Tool execution events carry the write/edit arguments, but treat any
+reconstruction as unverified until it matches a working-tree diff - when the tree still holds the
+work, preserve the tree rather than replaying the log.
+
+## What the relay runs
+
+The launch is equivalent to:
+
+```bash
+cline --json -v [--provider <name>] [--model <id>] \
+  --auto-approve <true|false> [--plan] \
+  "Follow the task instructions provided on stdin." < brief.txt
+```
+
+Current Cline JSON mode checks for a positional prompt before reading piped input, so the relay
+passes the fixed instruction and streams the real brief on stdin. The child process cwd pins the
+workspace. Only token-validated provider/model values and fixed text reach the `shell:true` launch
+on native Windows; the brief and cwd do not. `-v` (verbose) exposes the requested provider/model.
+Before dispatch the relay runs a
+bounded `cline --version` preflight (10s cap) so a hung or crashing CLI fails fast and explicitly
+instead of hanging the run. In act mode, auto-approval defaults true. With `--plan`, the relay
+forces it false because Cline can otherwise auto-approve a switch to act mode. Cline also exposes
+sandbox through `--data-dir` / `CLINE_SANDBOX`; the relay leaves that control to the inherited CLI
+environment.
+
+## The commit boundary
+
+The relay never commits. Cline edits the working tree; the orchestrator reviews, re-runs the
+gates, and commits. See [review-and-land.md](review-and-land.md).

package/bundled-skills/cline-delegate/references/multi-task-queues.md

@@ -0,0 +1,58 @@
+# Multi-task queues
+
+The single-task loop scales to a queue: a removal across layers, a migration across files, or a
+refactor sweep. Sequencing and bookkeeping make it trustworthy.
+
+## Run sequentially, one commit per task
+
+Run tasks **one at a time, in dependency order**, landing each after review and gates before
+dispatching the next:
+
+```bash
+node "<skill-dir>/scripts/relay.mjs" --brief task-01.txt --cd /path/to/repo
+```
+
+- Later briefs can rely on earlier work only after it lands.
+- One commit per task keeps history reviewable and each step revertible.
+- A clean tree before each dispatch keeps `touchedFiles` honest.
+
+Use parallel runs only for genuinely independent tasks in separate working trees. Sequential is
+the default because it preserves clean task boundaries.
+
+## Carry decided constraints forward
+
+Fresh cline sessions do not remember earlier tasks. If task 2 chooses a helper name, fixture
+location, or interface that task 5 needs, write that fact into task 5's brief.
+
+Cline's verified headless JSON path does not support session resume. Rework and unrelated queue
+items both use fresh runs, so every brief must carry the context it needs.
+
+## Keep a progress file
+
+For more than two or three tasks, maintain one progress file beside the work:
+
+- **Status table** - queued / at-implementer / reviewed+committed, with the commit hash.
+- **Per-task review notes** - what landed, what you verified, and gate outcomes.
+- **Needs your eyes** - design decisions, non-blocking nitpicks, and questions for the human.
+- **End-of-run checklist** - the final cross-task verification.
+
+Update it when each task lands, not in one batch at the end.
+
+## Close with a coherence check
+
+After the last task:
+
+- Run the full test/build once more.
+- Search repo-wide for the thing the queue changed.
+- Replay migrations from a clean state and check drift when applicable.
+- Push and open or update the PR only after the final tree is coherent.
+
+## When to stop and ask
+
+Proceed on work that follows from the agreed plan. Stop and surface when:
+
+- A task cannot be completed correctly within its brief.
+- Review calls the plan itself into question.
+- Gates reveal a problem affecting already-landed tasks.
+
+Report the landed state, commit hashes, and open question, then wait.

package/bundled-skills/cline-delegate/references/review-and-land.md

@@ -0,0 +1,80 @@
+# Review and land
+
+The implementer made the changes; you own the judgment. Verify against reality, never the
+self-report, and read the diff as generated code because a green gate cannot catch every failure
+mode.
+
+## Check tests before trusting gates
+
+If the diff touches existing tests, review those edits first:
+
+- Treat unbriefed test edits as a contract change, not part of the fix.
+- Treat newly skipped, disabled, or commented-out tests as failing until proven otherwise.
+- Treat loosened assertions the same way: contains/truthy replacing exact matches, broadened
+  error types, and widened tolerances all weaken the gate.
+
+## Re-run the gates yourself
+
+`result.json` carries cline's claims, not evidence. Re-run the project's actual test, lint, and
+build commands in the working tree and read their output. Passing is necessary, not sufficient.
+
+## Read the diff against the brief
+
+Start with `touchedFiles`, open the diff, and compare it to the brief:
+
+- **Scope creep** - changes the brief excluded.
+- **Scope shortfall** - missed behavior, edges, or cleanup.
+- **Quiet judgment calls** - defensible but unasked decisions that need review.
+
+## The implementer sweep
+
+Check every diff for patterns gates often miss:
+
+- Hardcoded success or fixture data on a real-work path.
+- Catch-all error handling that returns a default instead of propagating or recovering.
+- Imports, dependencies, methods, and signatures not present in the installed version.
+- Unused imports, uncalled helpers, unreachable branches, and scaffolding comments.
+- A second client, error idiom, or logging style beside the repo's existing one.
+- Tests that assert internals instead of behavior, or near-duplicate test bodies.
+- Optional parameters, config flags, and abstractions with no caller.
+- Guards for impossible cases that hide trust-boundary validation.
+
+Send anything blocking back to cline as a delta brief, or fix it in the tree, and report either
+choice to the human. Run relevant guard skills if installed.
+
+## The commit boundary
+
+When the gates pass and the diff holds, **the orchestrator commits**, never the implementer.
+Write a clear message describing what landed.
+
+From dispatch until that commit, the uncommitted working tree is the authoritative copy of the
+implementer's work - the only one you can commit from, and often the only copy at all. Never run
+`git checkout`, `reset`, `clean`, or a branch switch in the workspace between those two points -
+however messy an interrupted run looks, inspect it first: `git status`, `git diff`,
+`git diff --cached` for anything the implementer staged (plain `git diff` is blind to the index),
+and commit the intended files explicitly.
+
+## Rework: re-dispatch a corrected brief
+
+Re-dispatch the correction with the needed context:
+
+```bash
+echo "The fix is right, but the tests mock the DB session: use the real migrated fixture and
+remove the unused import." | node "<skill-dir>/scripts/relay.mjs" --cd /path/to/repo
+```
+
+Cline's verified headless JSON path does not support session resume, so each correction is a fresh
+run and its brief must restate the required context. Rework gets the same test review, diff review,
+and implementer sweep.
+
+## Surface, do not absorb
+
+The human opted into delegation, so committing verified, gate-passing work is the contract. Keep
+them in the loop when the work changes shape:
+
+- Report design decisions and defensible-but-unrequested turns.
+- Note non-blocking nitpicks you did not block on.
+- Stop and ask if correct completion requires going beyond the brief.
+
+For a queue, keep these notes in the progress file described in
+[multi-task-queues.md](multi-task-queues.md).