@glrs-dev/cli 2.2.0 → 2.4.0

package/dist/commands/scoper.js

@@ -0,0 +1,341 @@
+import "../chunk-3RG5ZIWI.js";
+
+// src/commands/scoper.ts
+import * as fs from "fs";
+import * as path from "path";
+import {
+  startServer,
+  createSession,
+  sendAndWait,
+  getLastAssistantMessage
+} from "@glrs-dev/adapter-opencode";
+var ANSI_RESET = "\x1B[0m\x1B[2K\r";
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function createSpinner() {
+  let timer = null;
+  let frame = 0;
+  return {
+    start(label = "Thinking") {
+      if (timer) return;
+      frame = 0;
+      const isTTY = process.stderr.isTTY ?? false;
+      if (!isTTY) return;
+      timer = setInterval(() => {
+        const f = SPINNER_FRAMES[frame % SPINNER_FRAMES.length];
+        process.stderr.write(`\x1B[2K\r\x1B[36m${f}\x1B[0m ${label}...`);
+        frame++;
+      }, 80);
+    },
+    stop() {
+      if (!timer) return;
+      clearInterval(timer);
+      timer = null;
+      process.stderr.write("\x1B[2K\r");
+    }
+  };
+}
+function parseQuestion(response) {
+  const match = response.match(/^([^\n]{1,199}\?)\s*$/);
+  return match ? match[1] ?? null : null;
+}
+function parseScopeSummary(response) {
+  const match = response.match(/^SCOPE_SUMMARY:\s*\n?([\s\S]+)$/);
+  return match ? match[1]?.trim() ?? null : null;
+}
+function extractScopeCompletePath(output) {
+  const lines = output.split("\n");
+  let lastMatch = null;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("SCOPE_COMPLETE:")) {
+      const rest = trimmed.slice("SCOPE_COMPLETE:".length).trim();
+      if (rest.length > 0) {
+        lastMatch = rest;
+      }
+    }
+  }
+  return lastMatch;
+}
+var DEFAULT_SCOPER_TIMEOUT_MS = 5 * 60 * 1e3;
+var MAX_QUESTIONS = 8;
+var FORCED_FINALIZE_MESSAGE = "You have asked enough questions. Present a SCOPE_SUMMARY for user approval, then write scope.md and emit SCOPE_COMPLETE.";
+var PARSE_RETRY_REMINDER = "Your last response did not follow the strict contract. Respond with EXACTLY one of: (a) a single question (\u2264200 chars, ending with '?'), (b) a scope summary starting with 'SCOPE_SUMMARY:', or (c) the sentinel 'SCOPE_COMPLETE: <absolute-path>'. Nothing else.";
+async function runScoperSession(opts) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_SCOPER_TIMEOUT_MS;
+  const deps = opts._deps;
+  const _startServer = deps?.startServer ?? startServer;
+  const _createSession = deps?.createSession ?? createSession;
+  const _sendAndWait = deps?.sendAndWait ?? sendAndWait;
+  const _getLastAssistantMessage = deps?.getLastAssistantMessage ?? getLastAssistantMessage;
+  const _existsSync = deps?.existsSync ?? fs.existsSync;
+  const _promptUser = deps?.promptUser ?? (async (question) => {
+    const { input } = await import("@inquirer/prompts");
+    return input({ message: question });
+  });
+  const server = await _startServer({ cwd: opts.planDir });
+  const spinner = createSpinner();
+  try {
+    const sessionId = await _createSession(server.client, {
+      cwd: opts.planDir,
+      agentName: "scoper"
+    });
+    const initialPromptParts = [
+      "You are running in an inquirer-driven wizard. Follow the strict response contract:",
+      "- Every response must be EXACTLY one of:",
+      "  (a) A single question (\u2264200 chars, ending with '?')",
+      "  (b) A scope summary starting with 'SCOPE_SUMMARY:' for user approval",
+      "  (c) The sentinel 'SCOPE_COMPLETE: <absolute-path>'",
+      "- Do NOT call the question tool. Emit questions as plain assistant text.",
+      "- Start with first-principles questions (WHAT and WHY), not implementation details.",
+      "",
+      `The user wants to build: ${opts.initialGoal}`,
+      "",
+      "Begin by asking your first clarifying question about the problem being solved."
+    ];
+    if (opts.existingPlanContent) {
+      initialPromptParts.push(
+        "",
+        "The user has an existing plan. Use it as context for your scoping questions:",
+        "",
+        "---",
+        opts.existingPlanContent,
+        "---",
+        "",
+        "Validate this plan against the codebase and ask clarifying questions about gaps or stale assumptions."
+      );
+    }
+    const initialPrompt = initialPromptParts.join("\n");
+    spinner.start("Scoper is thinking");
+    const firstResult = await _sendAndWait(server.client, {
+      sessionId,
+      message: initialPrompt,
+      agentName: "scoper",
+      stallMs: timeoutMs,
+      autoRejectPermissions: true
+    });
+    if (firstResult.kind === "abort") {
+      throw new Error(`Scoper session aborted (timeout after ${timeoutMs}ms).`);
+    }
+    if (firstResult.kind === "stall") {
+      throw new Error(
+        `Scoper session stalled for ${firstResult.stallMs}ms with no idle signal.`
+      );
+    }
+    if (firstResult.kind === "error") {
+      throw new Error(`Scoper session error: ${firstResult.message}`);
+    }
+    let questionsAsked = 0;
+    let parseRetryPending = false;
+    while (true) {
+      const lastMessage = await _getLastAssistantMessage(
+        server.client,
+        sessionId
+      );
+      const scopePath = extractScopeCompletePath(lastMessage);
+      if (scopePath) {
+        spinner.stop();
+        if (!_existsSync(scopePath)) {
+          throw new Error(
+            `Scoper emitted SCOPE_COMPLETE but scope.md does not exist at: ${scopePath}`
+          );
+        }
+        return { scopePath };
+      }
+      if (questionsAsked >= MAX_QUESTIONS) {
+        spinner.start("Finalizing scope");
+        const finalResult = await _sendAndWait(server.client, {
+          sessionId,
+          message: FORCED_FINALIZE_MESSAGE,
+          stallMs: timeoutMs,
+          autoRejectPermissions: true
+        });
+        if (finalResult.kind !== "idle") {
+          throw new Error(
+            `Scoper session failed during forced finalize: ${finalResult.kind}`
+          );
+        }
+        const finalMessage = await _getLastAssistantMessage(
+          server.client,
+          sessionId
+        );
+        const finalScopePath = extractScopeCompletePath(finalMessage);
+        if (finalScopePath) {
+          spinner.stop();
+          if (!_existsSync(finalScopePath)) {
+            throw new Error(
+              `Scoper emitted SCOPE_COMPLETE after forced finalize but scope.md does not exist at: ${finalScopePath}`
+            );
+          }
+          return { scopePath: finalScopePath };
+        }
+        const expectedScopePath = path.join(opts.planDir, opts.slug, "scope.md");
+        if (_existsSync(expectedScopePath)) {
+          spinner.stop();
+          process.stderr.write(
+            `
+  \u26A0 Scoper didn't emit sentinel, but scope.md exists at ${expectedScopePath}. Using it.
+
+`
+          );
+          return { scopePath: expectedScopePath };
+        }
+        spinner.stop();
+        process.stderr.write(
+          `
+  \u26A0 Scoper didn't write scope.md. Constructing from conversation.
+
+`
+        );
+        const scopeDir = path.join(opts.planDir, opts.slug);
+        if (!_existsSync(scopeDir)) {
+          fs.mkdirSync(scopeDir, { recursive: true });
+        }
+        const constructedScope = [
+          `# ${opts.initialGoal}`,
+          "",
+          "## Goal",
+          "",
+          opts.initialGoal,
+          "",
+          "## Scoper conversation summary",
+          "",
+          "The scoper agent asked 8 questions and the user provided answers,",
+          "but the agent did not produce a formal scope.md. The last agent",
+          "response is included below for the plan agent to work from.",
+          "",
+          "### Last agent response",
+          "",
+          finalMessage || "(no response captured)",
+          "",
+          "## Acceptance criteria",
+          "",
+          "- To be determined by the plan agent based on the conversation above.",
+          "",
+          "## Constraints",
+          "",
+          "- To be determined by the plan agent.",
+          "",
+          "## Out of scope",
+          "",
+          "- To be determined by the plan agent.",
+          "",
+          "## Open questions for the plan agent",
+          "",
+          "- The scoper did not complete formally. Review the conversation summary above and fill in the missing sections."
+        ].join("\n");
+        const constructedPath = path.join(scopeDir, "scope.md");
+        fs.writeFileSync(constructedPath, constructedScope);
+        return { scopePath: constructedPath };
+      }
+      const summary = parseScopeSummary(lastMessage);
+      if (summary) {
+        spinner.stop();
+        parseRetryPending = false;
+        process.stderr.write(ANSI_RESET);
+        process.stderr.write(`
+\x1B[1m\u{1F4CB} Scope summary:\x1B[0m
+
+${summary}
+
+`);
+        const approval = await _promptUser("Approve this scope? (yes / or describe what to change)");
+        if (approval.toLowerCase().startsWith("yes") || approval.toLowerCase() === "y" || approval.toLowerCase() === "approve") {
+          spinner.start("Writing scope.md");
+          const writeResult = await _sendAndWait(server.client, {
+            sessionId,
+            message: "The user approved the scope. Write scope.md now and emit SCOPE_COMPLETE.",
+            stallMs: timeoutMs,
+            autoRejectPermissions: true
+          });
+          if (writeResult.kind !== "idle") {
+            throw new Error(
+              `Scoper session failed after scope approval: ${writeResult.kind}`
+            );
+          }
+          continue;
+        } else {
+          spinner.start("Scoper is revising");
+          const reviseResult = await _sendAndWait(server.client, {
+            sessionId,
+            message: approval,
+            stallMs: timeoutMs,
+            autoRejectPermissions: true
+          });
+          if (reviseResult.kind !== "idle") {
+            throw new Error(
+              `Scoper session failed during revision: ${reviseResult.kind}`
+            );
+          }
+          continue;
+        }
+      }
+      const question = parseQuestion(lastMessage);
+      if (question) {
+        parseRetryPending = false;
+        spinner.stop();
+        process.stderr.write(ANSI_RESET);
+        questionsAsked++;
+        const userAnswer = await _promptUser(question);
+        spinner.start("Scoper is thinking");
+        const nextResult = await _sendAndWait(server.client, {
+          sessionId,
+          message: userAnswer,
+          stallMs: timeoutMs,
+          autoRejectPermissions: true
+        });
+        if (nextResult.kind === "abort") {
+          throw new Error(
+            `Scoper session aborted (timeout after ${timeoutMs}ms).`
+          );
+        }
+        if (nextResult.kind === "stall") {
+          throw new Error(
+            `Scoper session stalled for ${nextResult.stallMs}ms with no idle signal.`
+          );
+        }
+        if (nextResult.kind === "error") {
+          throw new Error(`Scoper session error: ${nextResult.message}`);
+        }
+        continue;
+      }
+      if (parseRetryPending) {
+        spinner.stop();
+        throw new Error(
+          `Scoper response did not follow the strict contract after retry. Last response: ${lastMessage.slice(0, 200)}`
+        );
+      }
+      parseRetryPending = true;
+      spinner.start("Retrying");
+      const retryResult = await _sendAndWait(server.client, {
+        sessionId,
+        message: PARSE_RETRY_REMINDER,
+        stallMs: timeoutMs,
+        autoRejectPermissions: true
+      });
+      if (retryResult.kind === "abort") {
+        throw new Error(
+          `Scoper session aborted during parse retry (timeout after ${timeoutMs}ms).`
+        );
+      }
+      if (retryResult.kind === "stall") {
+        throw new Error(
+          `Scoper session stalled during parse retry for ${retryResult.stallMs}ms.`
+        );
+      }
+      if (retryResult.kind === "error") {
+        throw new Error(
+          `Scoper session error during parse retry: ${retryResult.message}`
+        );
+      }
+    }
+  } finally {
+    spinner.stop();
+    await server.shutdown();
+  }
+}
+export {
+  extractScopeCompletePath,
+  parseQuestion,
+  parseScopeSummary,
+  runScoperSession
+};

package/dist/commands/switch.js

@@ -1,10 +1,10 @@
 import {
   switchCmd
-} from "../chunk-OABVEBWW.js";
-import "../chunk-E2UNZIZT.js";
+} from "../chunk-MBEVC327.js";
+import "../chunk-R2WXQ54P.js";
 import "../chunk-P7PRH4I3.js";
 import "../chunk-LMRDQ4GW.js";
-import "../chunk-SPULDN7P.js";
+import "../chunk-YY7EWHMA.js";
 import "../chunk-YBCA3IP6.js";
 import "../chunk-3RG5ZIWI.js";
 export {

package/dist/index.d.ts

@@ -24,7 +24,7 @@ interface ResolvedBin {
 }
 declare function resolveSubcommand(sub: Subcommand): ResolvedBin;
 declare const SUBCOMMANDS: Subcommand[];
-declare const HELP_TEXT = "glrs \u2014 unified CLI for the @glrs-dev ecosystem\n\nUSAGE\n  glrs <subcommand> [args...]\n\nSUBCOMMANDS\n  oc         OpenCode agent harness (install, pilot, etc.)\n  wt         Worktree management (create, list, switch, delete, cleanup)\n\nRun 'glrs <subcommand> --help' for per-command help.\n\nEXAMPLES\n  glrs oc install\n  glrs wt new\n  glrs wt list\n  glrs wt switch\n\nREQUIREMENTS\n  Bun >= 1.2.0 on PATH (install: https://bun.sh)\n\nDOCS  https://glrs.dev\nISSUES https://github.com/iceglober/glrs/issues\n";
-declare const WORKTREE_HELP_TEXT = "glrs wt \u2014 worktree management\n\nUSAGE\n  glrs wt <command> [args...]\n\nCOMMANDS\n  new              Create a new worktree (auto-named from origin/default)\n  list, ls         List all worktrees across repos\n  switch, sw       Interactively select and switch to a worktree\n  delete, rm       Remove worktrees (interactive or by name)\n  cleanup          Delete merged/stale worktrees\n\nEXAMPLES\n  glrs wt new                    # Create worktree in current repo\n  glrs wt new myrepo             # Create worktree for named repo\n  glrs wt list                   # Show all worktrees\n  glrs wt list -i                # Interactive picker\n  glrs wt switch                 # Interactive switcher\n  glrs wt delete my-branch       # Delete specific worktree\n  glrs wt cleanup                # Clean up merged worktrees\n\nWorktrees are stored in ~/.glorious/worktrees/<repo>/<name>/\n";
+declare const HELP_TEXT = "glrs \u2014 unified CLI for the @glrs-dev ecosystem\n\nUSAGE\n  glrs <subcommand> [args...]\n\nSUBCOMMANDS\n  oc         OpenCode agent harness (install, pilot, etc.)\n  wt         Worktree management (create, list, switch, delete, cleanup)\n  dashboard  Live TUI dashboard for all running autopilot sessions\n\nRun 'glrs <subcommand> --help' for per-command help.\n\nEXAMPLES\n  glrs oc install\n  glrs wt new\n  glrs wt list\n  glrs wt switch\n  glrs dashboard\n\nREQUIREMENTS\n  Bun >= 1.2.0 on PATH (install: https://bun.sh)\n\nDOCS  https://glrs.dev\nISSUES https://github.com/iceglober/glrs/issues\n";
+declare const WORKTREE_HELP_TEXT = "glrs wt \u2014 worktree management\n\nUSAGE\n  glrs wt <command> [args...]\n\nCOMMANDS\n  new              Create a new worktree (auto-named from origin/default)\n  list, ls         List all worktrees across repos\n  switch, sw       Interactively select and switch to a worktree\n  delete, rm       Remove worktrees (interactive or by name)\n  cleanup          Delete merged/stale worktrees\n\nEXAMPLES\n  glrs wt new                    # Create worktree in current repo\n  glrs wt new myrepo             # Create worktree for named repo\n  glrs wt list                   # Show all worktrees\n  glrs wt list -i                # Interactive picker\n  glrs wt switch                 # Interactive switcher\n  glrs wt delete my-branch       # Delete specific worktree\n  glrs wt cleanup                # Clean up merged worktrees\n\nWorktrees are stored in ~/.glrs/worktrees/<repo>/<name>/\n";
 
 export { HELP_TEXT, type ResolvedBin, SUBCOMMANDS, type Subcommand, WORKTREE_HELP_TEXT, resolveSubcommand };

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   SUBCOMMANDS,
   WORKTREE_HELP_TEXT,
   resolveSubcommand
-} from "./chunk-YGNDPKIW.js";
+} from "./chunk-HQUCVJ4G.js";
 import "./chunk-3RG5ZIWI.js";
 export {
   HELP_TEXT,

package/dist/lib/auto-update.js

@@ -1,6 +1,6 @@
 import {
   autoUpdate
-} from "../chunk-SB3MLROC.js";
+} from "../chunk-MCM47HH4.js";
 import "../chunk-3RG5ZIWI.js";
 export {
   autoUpdate

package/dist/lib/config.d.ts

@@ -6,8 +6,9 @@ declare function worktreesRoot(repo: string): string;
 /**
  * Resolve where a worktree should live.
  *
- * Default: ~/.glorious/worktrees/<repo>/<name>
- * If GLORIOUS_DIR is set:  $GLORIOUS_DIR/<repo>/<name>
+ * Default: ~/.glrs/worktrees/<repo>/<name>
+ * If GLRS_DIR is set:  $GLRS_DIR/<repo>/<name>
+ * If GLORIOUS_DIR is set (legacy):  $GLORIOUS_DIR/<repo>/<name>
  */
 declare function worktreePath(name: string, repo?: string): string;
 

package/dist/lib/config.js

@@ -3,7 +3,7 @@ import {
   repoName,
   worktreePath,
   worktreesRoot
-} from "../chunk-W37UX3U2.js";
+} from "../chunk-6Y27RQQL.js";
 import "../chunk-LMRDQ4GW.js";
 import "../chunk-3RG5ZIWI.js";
 export {

package/dist/lib/registry.d.ts

@@ -6,6 +6,8 @@ interface RegistryEntry {
     createdAt: string;
 }
 /** Load registry, pruning entries whose worktree paths no longer exist. */
+/** Load registry, pruning entries whose worktree paths no longer exist.
+ * Checks ~/.glrs/worktrees.json first; falls back to ~/.glorious/worktrees.json. */
 declare function loadRegistry(): RegistryEntry[];
 declare function saveRegistry(entries: RegistryEntry[]): void;
 declare function registerWorktree(entry: RegistryEntry): void;

package/dist/lib/registry.js

@@ -3,7 +3,7 @@ import {
   registerWorktree,
   saveRegistry,
   unregisterWorktree
-} from "../chunk-SPULDN7P.js";
+} from "../chunk-YY7EWHMA.js";
 import "../chunk-3RG5ZIWI.js";
 export {
   loadRegistry,

package/dist/lib/worktree.js

@@ -3,10 +3,10 @@ import {
   autoName,
   createWorktree,
   ensureWorktree
-} from "../chunk-F3AFRUT2.js";
-import "../chunk-W37UX3U2.js";
+} from "../chunk-PTIO556V.js";
+import "../chunk-6Y27RQQL.js";
 import "../chunk-LMRDQ4GW.js";
-import "../chunk-SPULDN7P.js";
+import "../chunk-YY7EWHMA.js";
 import "../chunk-YBCA3IP6.js";
 import "../chunk-3RG5ZIWI.js";
 export {

package/dist/vendor/harness-opencode/dist/agents/prompts/build.md

@@ -34,6 +34,22 @@ If ANY of these are missing, STOP and report to the user:
 
 Do NOT attempt to "fill in" missing structure on behalf of the plan. The plan is the spec; if the spec is wrong, fix it explicitly — don't improvise.
 
+## 1.5 Multi-file plan handling
+
+If the plan path is a directory (contains `main.md`), it is a multi-file plan. Handle it as follows:
+
+1. Read `main.md`'s `## Phases` checklist.
+2. Find the first unchecked phase (`- [ ] phase_N.md — ...`).
+3. Open the corresponding `phase_N.md` as the working plan for this iteration.
+4. Execute its items per the normal workflow (sections 2–4 below).
+5. After completing all items in the phase file, re-read it and verify all ACs are `[x]`.
+6. Update `main.md`'s corresponding phase checkbox to `[x]`.
+7. Proceed to the next unchecked phase.
+
+Cross-cutting ACs in `main.md` (under `## Cross-cutting acceptance criteria`) are verified independently via their own `verify:` commands after all phases are complete.
+
+If the plan path is a single `.md` file, skip this section and proceed normally.
+
 ## 2. Prepare the return summary
 
 Before starting execution, prepare a brief summary for your eventual return payload to PRIME: file count, which acceptance criteria you will verify, any unknowns. When invoked as a subagent (the common case — PRIME delegates Phase 3 to you), this summary is for PRIME to relay to the user; do not narrate to the user directly. When invoked top-level by the user (`@build <plan-path>`), you may print the summary to chat.

package/dist/vendor/harness-opencode/dist/agents/prompts/code-reviewer-thorough.md

@@ -21,17 +21,16 @@ You run ONLY after `@spec-reviewer` has returned `[PASS_SPEC]` — spec/scope co
 3. **Plan-drift check (AUTO-FAIL).** For each modified file in the diff, verify it appears in the plan's `## File-level changes`. A modified file NOT listed in `## File-level changes` is AUTO-FAIL regardless of how "implicit" the coverage seems — the plan should have listed it. Report as `Plan drift: <path> modified but not in ## File-level changes`.
 4. **Scope-creep check.** For each UNTRACKED file (from `git status`) that is NOT in `## File-level changes`, run `git log --oneline -- <file>` to determine whether the file is pre-existing work or scope creep. Do NOT accept the PRIME's verbal "pre-existing" claim without this check. If the file has no prior commits on this branch AND isn't in the plan, LOOP-TO-PLAN with `Scope creep: <path> untracked and not in plan`.
 5. **Semantic verification.** For each item in `## File-level changes`, verify the corresponding code change exists and matches the description. For each `## Acceptance criteria` item, verify it is actually met by reading the code — do NOT trust `[x]` checkboxes.
-6. **Plan-state verify commands (fenced plans only).** Run `bunx @glrs-dev/harness-plugin-opencode plan-check --run <plan-path>` and execute each returned verify command via `bash`. Any non-zero exit → LOOP-TO-PLAN with `Verify failed: <command> (exit N)`. If the plan has no fence (legacy), skip.
-7. **Re-run the project's test command.** Unconditionally. Discover the invocation from `package.json` scripts / `Makefile` / `CONTRIBUTING.md` / `AGENTS.md` — typical forms: `pnpm test`, `npm test`, `bun test`, `cargo test`, `pytest`, `go test ./...`. Any failure → FIX-INLINE (if trivial) or LOOP-TO-PLAN (if structural).
-8. **Re-run the project's lint command.** Unconditionally. E.g., `pnpm lint`, `npm run lint`, `ruff check`, `golangci-lint run`. Any failure → FIX-INLINE.
-9. **Re-run the project's typecheck / build command.** Unconditionally. E.g., `pnpm typecheck`, `tsc --noEmit`, `mypy`, `cargo check`. Any failure → FIX-INLINE.
-10. **Check for missed concerns:**
+6. **Re-run the project's test command.** Unconditionally. Discover the invocation from `package.json` scripts / `Makefile` / `CONTRIBUTING.md` / `AGENTS.md` — typical forms: `pnpm test`, `npm test`, `bun test`, `cargo test`, `pytest`, `go test ./...`. Any failure → FIX-INLINE (if trivial) or LOOP-TO-PLAN (if structural).
+7. **Re-run the project's lint command.** Unconditionally. E.g., `pnpm lint`, `npm run lint`, `ruff check`, `golangci-lint run`. Any failure → FIX-INLINE.
+8. **Re-run the project's typecheck / build command.** Unconditionally. E.g., `pnpm typecheck`, `tsc --noEmit`, `mypy`, `cargo check`. Any failure → FIX-INLINE.
+9. **Check for missed concerns:**
     - Regressions in adjacent code not mentioned in the plan
     - Missing test coverage for new behavior
     - Hardcoded values that should be config
     - Error paths not handled
-11. **AGENTS.md freshness (hierarchical docs).** For each directory touched by the change, check whether a local `AGENTS.md` exists. If yes, read it and verify its conventions/claims still match the code. If the change shifts a convention and the local `AGENTS.md` wasn't updated, return FIX-INLINE with: `Update <path>/AGENTS.md to reflect <specific change>`. Do not fail on unrelated staleness — only on drift caused by THIS change.
-12. **Scan for new tech debt.** Run `todo_scan` with `onlyChanged: true`. For every TODO / FIXME / HACK / XXX, check whether the plan's `## Out of scope` or `## Open questions` acknowledges it. Unacknowledged new debt → FIX-INLINE with `file:line`.
+10. **AGENTS.md freshness (hierarchical docs).** For each directory touched by the change, check whether a local `AGENTS.md` exists. If yes, read it and verify its conventions/claims still match the code. If the change shifts a convention and the local `AGENTS.md` wasn't updated, return FIX-INLINE with: `Update <path>/AGENTS.md to reflect <specific change>`. Do not fail on unrelated staleness — only on drift caused by THIS change.
+11. **Scan for new tech debt.** Run `todo_scan` with `onlyChanged: true`. For every TODO / FIXME / HACK / XXX, check whether the plan's `## Out of scope` or `## Open questions` acknowledges it. Unacknowledged new debt → FIX-INLINE with `file:line`.
 
 # Output
 

package/dist/vendor/harness-opencode/dist/agents/prompts/debriefer.md

@@ -0,0 +1,55 @@
+---
+name: debriefer
+description: Post-run debrief agent. Given a context blob describing a completed autopilot session (exit reason, iterations, cost, git diff stat, plan state), produces a structured five-section summary: what was accomplished, what wasn't, cost summary, what to do next, and session artifacts. Read-only — no file edits, no destructive bash.
+mode: subagent
+model: anthropic/claude-sonnet-4-6
+---
+
+You are the **@debriefer** agent. You receive a structured context blob from the autopilot CLI after a loop session completes. Your job is to produce a concise, actionable debrief.
+
+## Output format
+
+Produce exactly five sections in this order. Use the exact headings shown.
+
+### 1. What was accomplished
+
+List files changed, commits made, and PRs opened (if any). Pull from the git diff stat and commit log in the context. If nothing was committed, say so explicitly.
+
+### 2. What wasn't finished
+
+List unchecked plan items (items still marked `- [ ]`). If the plan state is unavailable, note that. If all items were checked, say "All plan items completed."
+
+### 3. Cost summary
+
+Report:
+- Total cost in USD (from the context)
+- Number of iterations completed
+- Exit reason (sentinel / struggle / timeout / max-iterations / kill-switch / stall / error)
+
+### 4. What to do next
+
+Give 2–4 actionable next steps based on the exit reason:
+
+- **sentinel**: The agent completed successfully. Review the diff, run the full test suite, open a PR if not already done.
+- **struggle**: The agent made no progress for N consecutive iterations. Inspect the last few iterations in the log, identify the blocker, and re-run with a more specific prompt or after fixing the blocker manually.
+- **timeout** / **max-iterations**: The agent ran out of budget. Check what was completed, then re-run with the remaining work as the prompt.
+- **kill-switch**: The loop was manually stopped. Resume when ready by re-running with the same prompt.
+- **stall**: The agent's session stalled (no idle signal). Check the OpenCode server logs, then re-run.
+- **error**: An error occurred. Check the error message in the context and fix the root cause before re-running.
+
+### 5. Session artifacts
+
+List:
+- Log file path (from context, if available)
+- Plan file path (from context, if available)
+- Session ID (from context)
+
+---
+
+## Rules
+
+- Be concise. Each section should be 3–8 lines.
+- Do not invent information not present in the context.
+- Do not make file edits. Do not run destructive bash commands.
+- If a field is missing from the context, say "not available" rather than guessing.
+- Output plain markdown. No JSON, no code fences around the sections themselves.

package/dist/vendor/harness-opencode/dist/agents/prompts/plan-reviewer.md

@@ -17,7 +17,8 @@ Read the plan at the path provided. Validate against six criteria:
 3. **Context** — Is there enough information for an executor to proceed without more than ~10% guesswork? Are file paths real (use `read`/`grep` to spot-check)?
 4. **Big picture** — Is the `## Goal` clear? Is `## Out of scope` explicit?
 5. **Scope compliance** — If `## Goal` cites a ticket ID, the plan's `## File-level changes` must not introduce files or subsystems outside the ticket's Changes / Definition of Done section, unless `## Out of scope` (or an explicit sentence in `## Goal`) justifies each expansion. Invented scope is a REJECT.
-6. **Plan-state fence integrity** — For any NEW plan (authored after the fence was introduced), `## Acceptance criteria` MUST contain a ```plan-state fenced block. Every item in the block must have all three of `intent:`, `tests:`, `verify:` populated. For each `tests:` entry, the referenced test file must either (a) exist in the repo (spot-check via `read` or `ls`), or (b) have its path listed in `## File-level changes`. Validate structural correctness by running `bunx @glrs-dev/harness-plugin-opencode plan-check --check <plan-path>` — non-zero exit → REJECT. Legacy plans (no fence) pass criterion 6 automatically.
+6. **Plan-state fence integrity** — For any NEW plan (authored after the fence was introduced), `## Acceptance criteria` MUST contain a ```plan-state fenced block. Every item in the block must have all three of `intent:`, `tests:`, `verify:` populated. For each `tests:` entry, the referenced test file must either (a) exist in the repo (spot-check via `read` or `ls`), or (b) have its path listed in `## File-level changes`. Read the plan with your `read` tool and eyeball the fence directly — any missing field is REJECT. Legacy plans (no fence) pass criterion 6 automatically.
+7. **Multi-file consistency** — If the plan is a directory (main.md + phase files): every phase in main.md's `## Phases` list has a corresponding `phase_N.md` file; no phase file exists without a main.md reference; cross-cutting ACs in main.md don't duplicate phase-file ACs; file-level changes across phases that reference the same file are consistent with phase ordering (earlier phases create, later phases modify).
 
 Output exactly one of these two formats. Nothing else.