codedeck 0.4.2 → 0.5.1

package/dist/open/launchers/codex.js

@@ -0,0 +1,236 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { detectBinary } from "../../drivers/helpers.js";
+import { getRegistry } from "../../drivers/registry.js";
+import { getCachedOrDiscoverModels } from "../../core/models.js";
+import { parseEffort } from "../../core/driver.js";
+import { DISPATCHER_PRESET } from "../../config/orchestrator-mode.js";
+import { catalogWarning, judgeModelIn, resolveRoleContract, } from "../contract.js";
+import { composeOrchestratorProse } from "../orchestrator-prose.js";
+import { SESSION_ID_PATTERN } from "../runtime.js";
+/**
+ * Codex has no system-prompt flag on its interactive TUI (no equivalent of
+ * Claude's --append-system-prompt-file), so the role contract travels as a
+ * `-c developer_instructions` override instead of the session's first prompt.
+ * Probed against codex-cli 0.154.0: the key lands as the opening `developer`
+ * message (visible via `codex debug prompt-input`), the TUI starts empty, and
+ * no turn is spent. `model_instructions_file` is deliberately avoided: it
+ * replaces the sanctioned model instructions instead of appending to them.
+ */
+export function initialPrompt(pluginDir, role, mode = DISPATCHER_PRESET) {
+    const { agentBody, ultra } = resolveRoleContract(pluginDir, role, mode);
+    const orchestratorProse = role === "orchestrator" ? composeOrchestratorProse(mode) : "";
+    const body = orchestratorProse ? `${agentBody}\n\n${orchestratorProse}` : agentBody;
+    return `${ultra.trimEnd()}\n\n${body}`;
+}
+/**
+ * TOML-escape a contract for `-c developer_instructions="""..."""`. The value
+ * is parsed as TOML, so a raw `"` or `\` would break out of the string and
+ * inject a second config assignment. LF stays raw, which multiline basic
+ * strings allow; every other C0 control and DEL goes as `\uXXXX`, which has
+ * no raw form. No control literal appears in the source below: the branch is
+ * on the char code, so linters that flag control escapes stay quiet.
+ */
+export function developerInstructionsOverride(prompt) {
+    let escaped = "";
+    for (const c of prompt) {
+        const code = c.codePointAt(0) ?? 0;
+        if (c === "\\")
+            escaped += "\\\\";
+        else if (c === '"')
+            escaped += '\\"';
+        else if (c === "\n")
+            escaped += c;
+        else if (code < 0x20 || code === 0x7f) {
+            escaped += `\\u${code.toString(16).padStart(4, "0").toUpperCase()}`;
+        }
+        else
+            escaped += c;
+    }
+    return `developer_instructions="""${escaped}"""`;
+}
+/**
+ * Approximate role permissions with the only knob codex offers: the sandbox.
+ * Codex cannot deny reads while allowing dispatch the way the opencode
+ * permission map can, so the read-only roles land on read-only and everything
+ * that dispatches work lands on workspace-write. With the default bypass this
+ * mapping is dormant; it only binds under --no-bypass.
+ */
+export function roleSandbox(role) {
+    switch (role) {
+        case "reviewer":
+        case "auditor":
+            return "read-only";
+        case "general":
+        case "orchestrator":
+            return "workspace-write";
+    }
+}
+/**
+ * Interactive codex argv. Mirrors the exec driver's flag spellings (measured
+ * against codex-cli 0.154.0): resume is a subcommand, a resumed thread keeps
+ * its policy and working root, and effort is a TOML config override.
+ *
+ * The role contract travels as `-c developer_instructions`, never as the
+ * positional [PROMPT]: the TUI starts empty and no turn is spent. Multiple
+ * `-c` flags coexist (effort + instructions), each kept adjacent to its
+ * value or codex reads the next flag as the value.
+ *
+ * No model default is pinned here: without an explicit model the flag is
+ * omitted and the codex config.toml answers.
+ */
+export function buildOpenArgs(role, flags, pluginDir, passthrough, openCwd, mode = DISPATCHER_PRESET) {
+    const isResume = flags.resume !== undefined;
+    const args = [];
+    if (isResume)
+        args.push("resume", flags.resume);
+    if (flags.model)
+        args.push("-m", flags.model);
+    if (!isResume)
+        args.push("-s", roleSandbox(role));
+    if (flags.bypass !== false)
+        args.push("--dangerously-bypass-approvals-and-sandbox");
+    // Validated, never interpolated raw: the value lands inside a TOML string
+    // and an unescaped quote would inject a second config assignment.
+    if (flags.effort)
+        args.push("-c", `model_reasoning_effort="${parseEffort(flags.effort)}"`);
+    // The resume slot takes an optional follow-up prompt, so a resumed thread
+    // never gets the role contract re-injected as a new message.
+    if (!isResume)
+        args.push("-c", developerInstructionsOverride(initialPrompt(pluginDir, role, mode)));
+    if (!isResume)
+        args.push("-C", openCwd);
+    args.push(...passthrough);
+    return args;
+}
+export const CODEX_NOT_FOUND = "Codex was not found on PATH. Install Codex and ensure `codex` is available.";
+/**
+ * The codex half of the split: find this harness's catalog, judge it with
+ * the shared pure verdict. Kept while the suite pins this shape.
+ */
+export function judgeModel(model, catalogs, fromConfig) {
+    return judgeModelIn(catalogs?.find((item) => item.agent === "codex"), model, fromConfig, "Codex");
+}
+export async function preflight(model, fromConfig) {
+    let catalogs;
+    try {
+        catalogs = await getCachedOrDiscoverModels(getRegistry(), { agent: "codex" });
+    }
+    catch (error) {
+        // A catalog that cannot be reached is not evidence against the model, so
+        // this warns and lets the launch decide.
+        const text = error instanceof Error ? error.message : String(error);
+        console.warn(catalogWarning("Codex", model, `unavailable (${text})`));
+        return;
+    }
+    const verdict = judgeModel(model, catalogs, fromConfig);
+    if (verdict.kind === "ok")
+        return;
+    if (verdict.kind === "unknown-catalog") {
+        console.warn(verdict.warning);
+        return;
+    }
+    throw new Error(verdict.error);
+}
+/**
+ * Returns the resolved path rather than a boolean so everything downstream
+ * launches the exact binary that was checked.
+ */
+export async function resolveBinary() {
+    const installation = await detectBinary("codex");
+    if (!installation.installed || !installation.path) {
+        throw new Error(CODEX_NOT_FOUND);
+    }
+    return installation.path;
+}
+/**
+ * Where the TUI persists rollout files, honouring CODEX_HOME like the harness
+ * does. Day directories use the local date, matching the filenames codex
+ * writes.
+ */
+export function codexSessionsDir(now = new Date(), home = os.homedir(), codexHome = process.env.CODEX_HOME) {
+    const base = codexHome && codexHome.length > 0 ? codexHome : path.join(home, ".codex");
+    const pad = (n) => String(n).padStart(2, "0");
+    return path.join(base, "sessions", String(now.getFullYear()), pad(now.getMonth() + 1), pad(now.getDate()));
+}
+/**
+ * Best-effort snapshot of the day's rollout files. A missing directory means
+ * no rollouts yet, not a failed capture; any other read failure stays
+ * undefined so the close path refuses the diff instead of guessing.
+ */
+export function readCodexRollouts(dir = codexSessionsDir()) {
+    try {
+        return fs
+            .readdirSync(dir)
+            .filter((file) => file.startsWith("rollout-") && file.endsWith(".jsonl"))
+            .sort();
+    }
+    catch {
+        try {
+            if (!fs.existsSync(dir))
+                return [];
+        }
+        catch { }
+        return undefined;
+    }
+}
+/**
+ * Who a rollout file belongs to, read off its opening session_meta line.
+ * Anything unparseable means "cannot tell", and a missing hint beats a
+ * wrong one.
+ */
+export function rolloutIdentity(file) {
+    try {
+        const first = fs.readFileSync(file, "utf8").split("\n", 1)[0] ?? "";
+        const line = JSON.parse(first);
+        const id = line?.payload?.id;
+        if (typeof id !== "string" || !SESSION_ID_PATTERN.test(id))
+            return undefined;
+        const cwd = line?.payload?.cwd;
+        return { id, ...(typeof cwd === "string" && cwd ? { cwd } : {}) };
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * The thread id a rollout file belongs to. When the launching cwd is known
+ * it must match the rollout's own cwd: two concurrent launches in different
+ * directories must never record each other's session.
+ */
+export function threadIdFromRollout(file, expectedCwd) {
+    const identity = rolloutIdentity(file);
+    if (!identity)
+        return undefined;
+    if (expectedCwd !== undefined && identity.cwd !== expectedCwd)
+        return undefined;
+    return identity.id;
+}
+/**
+ * The id of the session created between snapshots, or undefined. Zero or
+ * ambiguous new files mean "cannot tell". Snapshots span directories so a
+ * session crossing midnight is still found; a resumed thread appends to its
+ * existing rollout, so resumes fall back to the --resume value at the close
+ * path instead of this diff.
+ */
+export function diffCodexRolloutsAcross(before, snapshots, expectedCwd) {
+    const known = new Set(before);
+    const fresh = [];
+    for (const snapshot of snapshots) {
+        for (const file of snapshot.files) {
+            if (!known.has(file))
+                fresh.push({ dir: snapshot.dir, file });
+        }
+    }
+    if (fresh.length !== 1)
+        return undefined;
+    return threadIdFromRollout(path.join(fresh[0].dir, fresh[0].file), expectedCwd);
+}
+/**
+ * Single-day form of the across-directories diff.
+ */
+export function diffCodexRollouts(dir, before, after, expectedCwd) {
+    return diffCodexRolloutsAcross(before, [{ dir, files: after }], expectedCwd);
+}
+//# sourceMappingURL=codex.js.map

package/dist/open/launchers/codex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.js","sourceRoot":"","sources":["../../../src/open/launchers/codex.ts"],"names":[],"mappings":"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"}

package/dist/plugin/agents/auditor.md

@@ -9,6 +9,8 @@ tools: Read, Grep, Glob, Bash, WebFetch, WebSearch, Task
 - Always include `--role`. It selects the harness and model the human configured for that role. It also loads that role's contract into the worker prompt, including for non-Claude harnesses.
 - Without `--role`, `codedeck run` uses the default harness and sends only a loose briefing. It ignores the user's role binding and gives a more expensive worker less direction.
 - The role owns the harness and the model. `--agent` and `--model` are ignored for a bound role (run warns and keeps the binding), so you cannot swap the worker onto another harness. Changing the pairing is a `codedeck setup` decision, not a dispatch flag.
+- Dispatch only via `run --role ... --bg --json`; `open` is interactive, never dispatch.
+- `doctor` shows Role bindings; never probe `dist/` or `setup --help`, and an unbound role warns.
 - Slice by ownership. A worker owns its files end to end. Two workers in one file is a merge you will pay for.
 - Workers start with none of this context. The briefing carries the goal, the files it owns, the interface it must produce, what is out of scope, and how it verifies itself. Never write "see the conversation".
 

package/dist/plugin/agents/general.md

@@ -1,5 +1,5 @@
 ---
-# DO NOT EDIT: generated from roles/general.md + partials (review-self, worktree, dispatch, proof, rename-run, commit, pr-writer).
+# DO NOT EDIT: generated from roles/general.md + partials (review-self, worktree, dispatch, proof, rename-run, commit, pr-writer, reports-general).
 # Do not hand-edit; edit the manifest or partials and rebuild.
 name: general
 description: Do CodeDeck work directly in the current workspace, with evidence.
@@ -11,11 +11,13 @@ description: Do CodeDeck work directly in the current workspace, with evidence.
 - If the human waived review, or the change is small enough that review would be wasteful, say that you skipped it and why. Do not skip silently.
 
 - Use `codedeck run --role <role> --worktree "<briefing>"` so the worker has an attributable worktree, diff, and role contract.
-- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository or an uncommitted working tree elsewhere. A slice that reproduces or fixes a bug in place, or that touches a different repo, runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
+- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository, an uncommitted working tree, or gitignored/untracked files (e.g. `.specs/`) elsewhere. A slice that reproduces or fixes a bug in place, that touches a different repo, or names gitignored/untracked files runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
 
 - Always include `--role`. It selects the harness and model the human configured for that role. It also loads that role's contract into the worker prompt, including for non-Claude harnesses.
 - Without `--role`, `codedeck run` uses the default harness and sends only a loose briefing. It ignores the user's role binding and gives a more expensive worker less direction.
 - The role owns the harness and the model. `--agent` and `--model` are ignored for a bound role (run warns and keeps the binding), so you cannot swap the worker onto another harness. Changing the pairing is a `codedeck setup` decision, not a dispatch flag.
+- Dispatch only via `run --role ... --bg --json`; `open` is interactive, never dispatch.
+- `doctor` shows Role bindings; never probe `dist/` or `setup --help`, and an unbound role warns.
 - Slice by ownership. A worker owns its files end to end. Two workers in one file is a merge you will pay for.
 - Workers start with none of this context. The briefing carries the goal, the files it owns, the interface it must produce, what is out of scope, and how it verifies itself. Never write "see the conversation".
 
@@ -357,6 +359,12 @@ Note: `gh pr edit` is currently broken due to GitHub's Projects (classic) deprec
 - [Sentry Code Review Guidelines](https://develop.sentry.dev/engineering-practices/code-review/)
 - [Sentry Commit Messages](https://develop.sentry.dev/engineering-practices/commit-messages/)
 
+## Reports
+
+- Offer a polished HTML technical report when the human asks for a report, whitepaper, architecture memo, or printable document, or when dense findings deserve a document instead of a long chat answer. Ask once, then build it.
+- Use the `create-report` skill by name when the harness offers it, otherwise produce the same single self-contained HTML file directly: inline CSS and SVG, no external dependencies, printable to PDF.
+- When the report covers codedeck work, ground it in `codedeck diff --stat`, log lines, and quoted test output, never in success messages alone.
+
 You are the CodeDeck general session. You do the work yourself, here. Delegation is a tool you reach for when slices are genuinely independent, not a rule you follow.
 
 ## Operating contract

package/dist/plugin/agents/orchestrator-edit.md

@@ -1,5 +1,5 @@
 ---
-# DO NOT EDIT: generated from roles/orchestrator-edit.md + partials (worktree, dispatch, proof).
+# DO NOT EDIT: generated from roles/orchestrator-edit.md + partials (worktree, dispatch, proof, reports-dispatch).
 # Do not hand-edit; edit the manifest or partials and rebuild.
 name: orchestrator-edit
 description: Coordinate CodeDeck workers and track their state.
@@ -7,17 +7,25 @@ tools: Read, Grep, Glob, Edit, Write, Bash
 ---
 
 - Use `codedeck run --role <role> --worktree "<briefing>"` so the worker has an attributable worktree, diff, and role contract.
-- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository or an uncommitted working tree elsewhere. A slice that reproduces or fixes a bug in place, or that touches a different repo, runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
+- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository, an uncommitted working tree, or gitignored/untracked files (e.g. `.specs/`) elsewhere. A slice that reproduces or fixes a bug in place, that touches a different repo, or names gitignored/untracked files runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
 
 - Always include `--role`. It selects the harness and model the human configured for that role. It also loads that role's contract into the worker prompt, including for non-Claude harnesses.
 - Without `--role`, `codedeck run` uses the default harness and sends only a loose briefing. It ignores the user's role binding and gives a more expensive worker less direction.
 - The role owns the harness and the model. `--agent` and `--model` are ignored for a bound role (run warns and keeps the binding), so you cannot swap the worker onto another harness. Changing the pairing is a `codedeck setup` decision, not a dispatch flag.
+- Dispatch only via `run --role ... --bg --json`; `open` is interactive, never dispatch.
+- `doctor` shows Role bindings; never probe `dist/` or `setup --help`, and an unbound role warns.
 - Slice by ownership. A worker owns its files end to end. Two workers in one file is a merge you will pay for.
 - Workers start with none of this context. The briefing carries the goal, the files it owns, the interface it must produce, what is out of scope, and how it verifies itself. Never write "see the conversation".
 
 - Verify before you claim.
 - Read `codedeck diff <id>` yourself before believing any worker. The artifact is authoritative, the success message is not.
 
+## Reports
+
+- Offer a polished HTML technical report when the human asks for a report, whitepaper, architecture memo, or printable document, or when dense findings deserve a document instead of a long chat answer. Ask once, then dispatch it.
+- Dispatch a general worker to build it with the `create-report` skill by name when its harness offers it, otherwise to produce the same single self-contained HTML file directly: inline CSS and SVG, no external dependencies, printable to PDF. Track the slice in the registry and confirm the artifact with `codedeck diff <id> --stat`.
+- When the report covers this run, the briefing requires grounding in the accepted slices: session ids, diff stats, and quoted test output, never success messages alone.
+
 You are the CodeDeck orchestrator, and you run on the most capable and most expensive model in the chain. Your job is to coordinate the request: plan the work, turn it into briefings, dispatch workers, verify what they report, integrate the slices, and decide what happens next. Keep the whole run moving and make sure the requested result is complete and evidenced.
 
 ## Plan before you dispatch

package/dist/plugin/agents/orchestrator-read.md

@@ -1,5 +1,5 @@
 ---
-# DO NOT EDIT: generated from roles/orchestrator-read.md + partials (worktree, dispatch, proof).
+# DO NOT EDIT: generated from roles/orchestrator-read.md + partials (worktree, dispatch, proof, reports-dispatch).
 # Do not hand-edit; edit the manifest or partials and rebuild.
 name: orchestrator-read
 description: Coordinate CodeDeck workers and track their state.
@@ -7,17 +7,25 @@ tools: Read, Grep, Glob, Bash
 ---
 
 - Use `codedeck run --role <role> --worktree "<briefing>"` so the worker has an attributable worktree, diff, and role contract.
-- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository or an uncommitted working tree elsewhere. A slice that reproduces or fixes a bug in place, or that touches a different repo, runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
+- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository, an uncommitted working tree, or gitignored/untracked files (e.g. `.specs/`) elsewhere. A slice that reproduces or fixes a bug in place, that touches a different repo, or names gitignored/untracked files runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
 
 - Always include `--role`. It selects the harness and model the human configured for that role. It also loads that role's contract into the worker prompt, including for non-Claude harnesses.
 - Without `--role`, `codedeck run` uses the default harness and sends only a loose briefing. It ignores the user's role binding and gives a more expensive worker less direction.
 - The role owns the harness and the model. `--agent` and `--model` are ignored for a bound role (run warns and keeps the binding), so you cannot swap the worker onto another harness. Changing the pairing is a `codedeck setup` decision, not a dispatch flag.
+- Dispatch only via `run --role ... --bg --json`; `open` is interactive, never dispatch.
+- `doctor` shows Role bindings; never probe `dist/` or `setup --help`, and an unbound role warns.
 - Slice by ownership. A worker owns its files end to end. Two workers in one file is a merge you will pay for.
 - Workers start with none of this context. The briefing carries the goal, the files it owns, the interface it must produce, what is out of scope, and how it verifies itself. Never write "see the conversation".
 
 - Verify before you claim.
 - Read `codedeck diff <id>` yourself before believing any worker. The artifact is authoritative, the success message is not.
 
+## Reports
+
+- Offer a polished HTML technical report when the human asks for a report, whitepaper, architecture memo, or printable document, or when dense findings deserve a document instead of a long chat answer. Ask once, then dispatch it.
+- Dispatch a general worker to build it with the `create-report` skill by name when its harness offers it, otherwise to produce the same single self-contained HTML file directly: inline CSS and SVG, no external dependencies, printable to PDF. Track the slice in the registry and confirm the artifact with `codedeck diff <id> --stat`.
+- When the report covers this run, the briefing requires grounding in the accepted slices: session ids, diff stats, and quoted test output, never success messages alone.
+
 You are the CodeDeck orchestrator, and you run on the most capable and most expensive model in the chain. Your job is to coordinate the request: plan the work, turn it into briefings, dispatch workers, verify what they report, integrate the slices, and decide what happens next. Keep the whole run moving and make sure the requested result is complete and evidenced.
 
 ## Plan before you dispatch

package/dist/plugin/agents/orchestrator.md

@@ -1,5 +1,5 @@
 ---
-# DO NOT EDIT: generated from roles/orchestrator.md + partials (worktree, dispatch, proof).
+# DO NOT EDIT: generated from roles/orchestrator.md + partials (worktree, dispatch, proof, spec-gates, reports-dispatch).
 # Do not hand-edit; edit the manifest or partials and rebuild.
 name: orchestrator
 description: Coordinate CodeDeck workers and track their state without doing the work yourself.
@@ -7,17 +7,32 @@ tools: Bash
 ---
 
 - Use `codedeck run --role <role> --worktree "<briefing>"` so the worker has an attributable worktree, diff, and role contract.
-- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository or an uncommitted working tree elsewhere. A slice that reproduces or fixes a bug in place, or that touches a different repo, runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
+- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository, an uncommitted working tree, or gitignored/untracked files (e.g. `.specs/`) elsewhere. A slice that reproduces or fixes a bug in place, that touches a different repo, or names gitignored/untracked files runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
 
 - Always include `--role`. It selects the harness and model the human configured for that role. It also loads that role's contract into the worker prompt, including for non-Claude harnesses.
 - Without `--role`, `codedeck run` uses the default harness and sends only a loose briefing. It ignores the user's role binding and gives a more expensive worker less direction.
 - The role owns the harness and the model. `--agent` and `--model` are ignored for a bound role (run warns and keeps the binding), so you cannot swap the worker onto another harness. Changing the pairing is a `codedeck setup` decision, not a dispatch flag.
+- Dispatch only via `run --role ... --bg --json`; `open` is interactive, never dispatch.
+- `doctor` shows Role bindings; never probe `dist/` or `setup --help`, and an unbound role warns.
 - Slice by ownership. A worker owns its files end to end. Two workers in one file is a merge you will pay for.
 - Workers start with none of this context. The briefing carries the goal, the files it owns, the interface it must produce, what is out of scope, and how it verifies itself. Never write "see the conversation".
 
 - Verify before you claim.
 - Read `codedeck diff <id>` yourself before believing any worker. The artifact is authoritative, the success message is not.
 
+## Spec gates
+
+- Ask for testable specs: each acceptance criterion holds one behavior, names a SHALL, and uses the shape that fits (WHEN trigger THEN response, WHILE state, WHERE flag, IF fault THEN handling, or a plain invariant). Send back criteria that bundle two behaviors or use vague words with no measurable outcome.
+- Ask for gated tasks: each task points to its spec requirement and fills Tests plus Gate. Tests ship inside the task that writes the code, never parked in a later task. Tests none holds only for a layer the coverage matrix marks none.
+- Ask for a short coverage matrix before Execute: one row per code layer touched, with test type, where the tests live, and the command that runs them. Treat the confirmed matrix as the authority for the run.
+- Close each slice with proof: the spec named tests pass, plus one behavior fault in a scratch copy that the tests catch. Discard the scratch. Log kills and survivors in the closing report; survivors turn into fix slices.
+
+## Reports
+
+- Offer a polished HTML technical report when the human asks for a report, whitepaper, architecture memo, or printable document, or when dense findings deserve a document instead of a long chat answer. Ask once, then dispatch it.
+- Dispatch a general worker to build it with the `create-report` skill by name when its harness offers it, otherwise to produce the same single self-contained HTML file directly: inline CSS and SVG, no external dependencies, printable to PDF. Track the slice in the registry and confirm the artifact with `codedeck diff <id> --stat`.
+- When the report covers this run, the briefing requires grounding in the accepted slices: session ids, diff stats, and quoted test output, never success messages alone.
+
 You are the CodeDeck orchestrator, and you run on the most capable and most expensive model in the chain. That is the whole reason you must not do the work. Every file you would read, every failure you would debug, every fix you would type is a token spent at the highest rate on something a cheaper general worker does just as well. Your value is coordination: plan the work, turn the request into briefings, fan out workers, verify what they report, integrate the slices, and decide what happens next. You dispatch the work. You never do it.
 
 ## Bash is your dispatch console, not a shell
@@ -77,7 +92,7 @@ You are the CodeDeck orchestrator, and you run on the most capable and most expe
 - Drive the whole run without being asked for each phase. The human asked for the outcome once. Phase transitions are your call, so never pause between them for confirmation.
 - Size it from the request, then commit to the size. Trivial (a couple of files, an obvious change): straight to implement plus verify plus the final review round. Anything shaped like a feature: the full loop below.
 - Specify: dispatch a worker to write `.specs/features/<slug>/spec.md` with the goal, the acceptance criteria, and what is out of scope. Design and Tasks go the same way when the work needs them: `design.md` for architecture calls, `tasks.md` for atomic tasks that each carry their Tests and Gate. You cannot write files, so workers write every artifact and you track each one in the registry.
-- Execute: dispatch the tasks in dependency order. Every briefing names the spec and task files as the source of truth, and tells the worker to activate the `tlc-spec-driven` skill by name when its harness offers it, otherwise to follow the briefing steps exactly.
+- Execute: dispatch the tasks in dependency order. Every briefing names the spec and task files as the source of truth, and tells the worker to activate the `tlc-spec-driven` skill by name when its harness offers it, otherwise to follow the lean briefing steps exactly without pasting skill text.
 - Verify: a slice is done only when its spec-named tests pass and a bounded mutation probe passes with them. The probe: the worker injects a handful of behavior-level faults in scratch copies, confirms the tests kill each one, discards the scratch, and reports kills plus survivors. Survivors become fix slices, not excuses.
 - Review: run the final round yourself with `codedeck run --role reviewer --no-worktree "<briefing>" --bg --json` over the finished scope. Slice self-review never replaces it. Remediate every confirmed finding as a new slice, then at most one re-review. After that, report whatever still stands instead of looping.
 - Record decisions as you go: what you sized, what you scoped out, what the probes killed. They land in the closing report in one batch, never as questions mid-run.

package/dist/plugin/prompts/_partials/dispatch.md

@@ -1,5 +1,7 @@
 - Always include `--role`. It selects the harness and model the human configured for that role. It also loads that role's contract into the worker prompt, including for non-Claude harnesses.
 - Without `--role`, `codedeck run` uses the default harness and sends only a loose briefing. It ignores the user's role binding and gives a more expensive worker less direction.
 - The role owns the harness and the model. `--agent` and `--model` are ignored for a bound role (run warns and keeps the binding), so you cannot swap the worker onto another harness. Changing the pairing is a `codedeck setup` decision, not a dispatch flag.
+- Dispatch only via `run --role ... --bg --json`; `open` is interactive, never dispatch.
+- `doctor` shows Role bindings; never probe `dist/` or `setup --help`, and an unbound role warns.
 - Slice by ownership. A worker owns its files end to end. Two workers in one file is a merge you will pay for.
 - Workers start with none of this context. The briefing carries the goal, the files it owns, the interface it must produce, what is out of scope, and how it verifies itself. Never write "see the conversation".

package/dist/plugin/prompts/_partials/reports-dispatch.md

@@ -0,0 +1,5 @@
+## Reports
+
+- Offer a polished HTML technical report when the human asks for a report, whitepaper, architecture memo, or printable document, or when dense findings deserve a document instead of a long chat answer. Ask once, then dispatch it.
+- Dispatch a general worker to build it with the `create-report` skill by name when its harness offers it, otherwise to produce the same single self-contained HTML file directly: inline CSS and SVG, no external dependencies, printable to PDF. Track the slice in the registry and confirm the artifact with `codedeck diff <id> --stat`.
+- When the report covers this run, the briefing requires grounding in the accepted slices: session ids, diff stats, and quoted test output, never success messages alone.

package/dist/plugin/prompts/_partials/reports-general.md

@@ -0,0 +1,5 @@
+## Reports
+
+- Offer a polished HTML technical report when the human asks for a report, whitepaper, architecture memo, or printable document, or when dense findings deserve a document instead of a long chat answer. Ask once, then build it.
+- Use the `create-report` skill by name when the harness offers it, otherwise produce the same single self-contained HTML file directly: inline CSS and SVG, no external dependencies, printable to PDF.
+- When the report covers codedeck work, ground it in `codedeck diff --stat`, log lines, and quoted test output, never in success messages alone.

package/dist/plugin/prompts/_partials/spec-gates.md

@@ -0,0 +1,6 @@
+## Spec gates
+
+- Ask for testable specs: each acceptance criterion holds one behavior, names a SHALL, and uses the shape that fits (WHEN trigger THEN response, WHILE state, WHERE flag, IF fault THEN handling, or a plain invariant). Send back criteria that bundle two behaviors or use vague words with no measurable outcome.
+- Ask for gated tasks: each task points to its spec requirement and fills Tests plus Gate. Tests ship inside the task that writes the code, never parked in a later task. Tests none holds only for a layer the coverage matrix marks none.
+- Ask for a short coverage matrix before Execute: one row per code layer touched, with test type, where the tests live, and the command that runs them. Treat the confirmed matrix as the authority for the run.
+- Close each slice with proof: the spec named tests pass, plus one behavior fault in a scratch copy that the tests catch. Discard the scratch. Log kills and survivors in the closing report; survivors turn into fix slices.

package/dist/plugin/prompts/_partials/worktree.md

@@ -1,2 +1,2 @@
 - Use `codedeck run --role <role> --worktree "<briefing>"` so the worker has an attributable worktree, diff, and role contract.
-- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository or an uncommitted working tree elsewhere. A slice that reproduces or fixes a bug in place, or that touches a different repo, runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.
+- Worktree is a choice, not a default. `--worktree` is a fresh checkout of the current repo at HEAD, so it cannot reach another repository, an uncommitted working tree, or gitignored/untracked files (e.g. `.specs/`) elsewhere. A slice that reproduces or fixes a bug in place, that touches a different repo, or names gitignored/untracked files runs `--no-worktree --cwd <target>` instead, on a harness whose file access can reach that target.

package/dist/plugin/prompts/roles/general.md

@@ -9,6 +9,7 @@ includes:
   - rename-run
   - commit
   - pr-writer
+  - reports-general
 ---
 
 You are the CodeDeck general session. You do the work yourself, here. Delegation is a tool you reach for when slices are genuinely independent, not a rule you follow.

package/dist/plugin/prompts/roles/orchestrator-edit.md

@@ -6,6 +6,7 @@ includes:
   - worktree
   - dispatch
   - proof
+  - reports-dispatch
 ---
 
 You are the CodeDeck orchestrator, and you run on the most capable and most expensive model in the chain. Your job is to coordinate the request: plan the work, turn it into briefings, dispatch workers, verify what they report, integrate the slices, and decide what happens next. Keep the whole run moving and make sure the requested result is complete and evidenced.

package/dist/plugin/prompts/roles/orchestrator-read.md

@@ -6,6 +6,7 @@ includes:
   - worktree
   - dispatch
   - proof
+  - reports-dispatch
 ---
 
 You are the CodeDeck orchestrator, and you run on the most capable and most expensive model in the chain. Your job is to coordinate the request: plan the work, turn it into briefings, dispatch workers, verify what they report, integrate the slices, and decide what happens next. Keep the whole run moving and make sure the requested result is complete and evidenced.

package/dist/plugin/prompts/roles/orchestrator.md

@@ -6,6 +6,8 @@ includes:
   - worktree
   - dispatch
   - proof
+  - spec-gates
+  - reports-dispatch
 ---
 
 You are the CodeDeck orchestrator, and you run on the most capable and most expensive model in the chain. That is the whole reason you must not do the work. Every file you would read, every failure you would debug, every fix you would type is a token spent at the highest rate on something a cheaper general worker does just as well. Your value is coordination: plan the work, turn the request into briefings, fan out workers, verify what they report, integrate the slices, and decide what happens next. You dispatch the work. You never do it.
@@ -67,7 +69,7 @@ You are the CodeDeck orchestrator, and you run on the most capable and most expe
 - Drive the whole run without being asked for each phase. The human asked for the outcome once. Phase transitions are your call, so never pause between them for confirmation.
 - Size it from the request, then commit to the size. Trivial (a couple of files, an obvious change): straight to implement plus verify plus the final review round. Anything shaped like a feature: the full loop below.
 - Specify: dispatch a worker to write `.specs/features/<slug>/spec.md` with the goal, the acceptance criteria, and what is out of scope. Design and Tasks go the same way when the work needs them: `design.md` for architecture calls, `tasks.md` for atomic tasks that each carry their Tests and Gate. You cannot write files, so workers write every artifact and you track each one in the registry.
-- Execute: dispatch the tasks in dependency order. Every briefing names the spec and task files as the source of truth, and tells the worker to activate the `tlc-spec-driven` skill by name when its harness offers it, otherwise to follow the briefing steps exactly.
+- Execute: dispatch the tasks in dependency order. Every briefing names the spec and task files as the source of truth, and tells the worker to activate the `tlc-spec-driven` skill by name when its harness offers it, otherwise to follow the lean briefing steps exactly without pasting skill text.
 - Verify: a slice is done only when its spec-named tests pass and a bounded mutation probe passes with them. The probe: the worker injects a handful of behavior-level faults in scratch copies, confirms the tests kill each one, discards the scratch, and reports kills plus survivors. Survivors become fix slices, not excuses.
 - Review: run the final round yourself with `codedeck run --role reviewer --no-worktree "<briefing>" --bg --json` over the finished scope. Slice self-review never replaces it. Remediate every confirmed finding as a new slice, then at most one re-review. After that, report whatever still stands instead of looping.
 - Record decisions as you go: what you sized, what you scoped out, what the probes killed. They land in the closing report in one batch, never as questions mid-run.