@opengsd/gsd-core 1.15.0 → 1.17.0

package/.claude-plugin/marketplace.json

@@ -9,7 +9,7 @@
     {
       "name": "gsd-core",
       "description": "GSD Core is a meta-prompting, context engineering, and spec-driven development system for AI coding agents.",
-      "version": "1.15.0",
+      "version": "1.17.0",
       "source": "./",
       "author": {
         "name": "open-gsd",

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "gsd-core",
   "displayName": "GSD Core",
-  "version": "1.15.0",
+  "version": "1.17.0",
   "description": "GSD Core is a meta-prompting, context engineering, and spec-driven development system for AI coding agents.",
   "author": {
     "name": "open-gsd",
@@ -18,6 +18,5 @@
     "claude-code",
     "gsd"
   ],
-  "commands": "./commands/gsd/",
   "skills": "./skills/"
 }

package/.opencode/plugins/gsd-core.js

@@ -146,6 +146,11 @@ const TOOL_NAME_MAP = {
   websearch: "WebSearch",
   task: "Task",
   subagent: "Task",
+  // >>> gsd:opencode-v2
+  // OpenCode 2.x tool ids (ADR-5331 E4): `shell` replaces `bash`, `patch` replaces `apply_patch`.
+  shell: "Bash",
+  patch: "MultiEdit",
+  // <<< gsd:opencode-v2
 };
 
 function mapToolName(tool) {
@@ -207,6 +212,50 @@ function mapToolInput(args) {
  */
 const warnedMissingHooks = new Set();
 
+// A hook this adapter kills on timeout has no exit status, so runHook below
+// reports it as exit 0 — an ALLOW. For a guard that blocks, a bound shorter
+// than the guard's own worst case therefore silently disables the gate. The
+// two guards that probe git (worktree path, workflow force-add) run up to
+// BLOCKING_GUARD_MAX_SEQUENTIAL_PROBES sequential probes of
+// BLOCKING_GUARD_PROBE_TIMEOUT_MS each (hooks/lib/git-probe.js, #5180), so
+// their bound is that product plus a margin for node start/kill/reap. Read
+// from the staged hooks/lib so it can never drift from the guards' own budget;
+// the fallback is used only when that lib is missing from a partial install,
+// and is sized for the same worst case.
+const GIT_PROBING_GUARDS = new Set([
+  "gsd-worktree-path-guard.js",
+  "gsd-workflow-guard.js",
+]);
+const GIT_PROBING_GUARD_MARGIN_MS = 5000;
+const GIT_PROBING_GUARD_FALLBACK_TIMEOUT_MS = 20000;
+
+function gitProbingGuardTimeoutMs() {
+  try {
+    const probe = require(path.join(HOOKS_DIR, "lib", "git-probe.js"));
+    const worstCaseMs =
+      probe.BLOCKING_GUARD_MAX_SEQUENTIAL_PROBES *
+      probe.BLOCKING_GUARD_PROBE_TIMEOUT_MS;
+    if (Number.isFinite(worstCaseMs) && worstCaseMs > 0) {
+      return worstCaseMs + GIT_PROBING_GUARD_MARGIN_MS;
+    }
+  } catch {
+    // hooks/lib/git-probe.js unavailable — use the fallback below.
+  }
+  return GIT_PROBING_GUARD_FALLBACK_TIMEOUT_MS;
+}
+
+// Hooks are Node scripts. `process.execPath` is only a JS runtime when the host is Node or Bun
+// itself; inside OpenCode's single-file binary (1.x and 2.x) spawning it with a .js path boots
+// OpenCode instead and exits 0, silently disabling every guard (#4849). So: an explicit
+// GSD_HOOK_RUNTIME wins, then a Node/Bun host's own executable, else `node` from PATH.
+let warnedMissingRuntime = false;
+function hookRuntime() {
+  const fromEnv = process.env.GSD_HOOK_RUNTIME;
+  if (typeof fromEnv === "string" && fromEnv.length > 0) return fromEnv;
+  const base = path.basename(process.execPath).toLowerCase().replace(/\.exe$/, "");
+  return base === "node" || base === "bun" ? process.execPath : "node";
+}
+
 function runHook(hookFile, payload, opts = {}) {
   const hookPath = path.join(HOOKS_DIR, hookFile);
   if (!fs.existsSync(hookPath)) {
@@ -224,10 +273,12 @@ function runHook(hookFile, payload, opts = {}) {
     }
     return { stdout: "", exitCode: 0, timedOut: false };
   }
-  const timeout = opts.timeout ?? 8000;
+  const timeout =
+    opts.timeout ??
+    (GIT_PROBING_GUARDS.has(hookFile) ? gitProbingGuardTimeoutMs() : 8000);
   let result;
   try {
-    result = spawnSync(process.execPath, [hookPath], {
+    result = spawnSync(hookRuntime(), [hookPath], {
       input: JSON.stringify(payload),
       encoding: "utf8",
       timeout,
@@ -239,6 +290,15 @@ function runHook(hookFile, payload, opts = {}) {
     return { stdout: "", exitCode: 0, timedOut: false };
   }
 
+  if (result.error && !warnedMissingRuntime) {
+    // The runtime could not be started: the guard did not run. Fail open (adapter contract) but
+    // never silently (#4849).
+    warnedMissingRuntime = true;
+    console.error(
+      `[gsd-core] cannot start hook runtime '${hookRuntime()}' (${result.error.code || result.error.message}) — ` +
+        "GSD hooks are NOT enforced. Install Node.js or set GSD_HOOK_RUNTIME to a node/bun executable.",
+    );
+  }
   const stdout = (result.stdout || "").trim();
   const exitCode = result.status == null ? 0 : result.status;
   return { stdout, exitCode, timedOut: result.signal === "SIGTERM" };
@@ -324,18 +384,134 @@ function handleHookResult(hookResult, output) {
     }
     // Best-effort visibility when metadata isn't surfaced to the model
     console.error(advisory);
+    // >>> gsd:opencode-parity
+    deliverAdvisory(advisory, output);
+    // <<< gsd:opencode-parity
   }
 }
+// >>> gsd:opencode-parity (ADR-5331 Phase 3; OpenCode-only — the Kilo mirror omits this block)
+// The four opt-in community hooks are bash scripts. Their gates (hooks.community, graphify.*) are
+// re-checked here in-process so a project that has not opted in never pays a bash spawn per tool call.
+function readProjectConfig(cwd) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(cwd, ".planning", "config.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function communityHooksEnabled(cwd) {
+  const config = readProjectConfig(cwd);
+  return !!config && config.hooks && config.hooks.community === true;
+}
+
+function graphifyAutoUpdateEnabled(cwd) {
+  const config = readProjectConfig(cwd);
+  return !!config && !process.env.CI && !!config.graphify &&
+    config.graphify.enabled === true && config.graphify.auto_update === true;
+}
+
+/**
+ * Run a GSD `.sh` hook under bash with the hook payload on stdin. Fails open: a missing script or no
+ * bash on PATH (a Windows host without Git Bash) is the same as the hook not being installed.
+ */
+function runShellHook(hookFile, payload, opts = {}) {
+  const hookPath = path.join(HOOKS_DIR, hookFile);
+  if (!fs.existsSync(hookPath)) return { stdout: "", exitCode: 0, timedOut: false };
+  let result;
+  try {
+    result = spawnSync(process.env.GSD_HOOK_SHELL || "bash", [hookPath], {
+      input: JSON.stringify(payload),
+      encoding: "utf8",
+      timeout: opts.timeout ?? 15000,
+      cwd: opts.cwd || currentCwd,
+      windowsHide: true,
+    });
+  } catch {
+    return { stdout: "", exitCode: 0, timedOut: false };
+  }
+  if (result.error) return { stdout: "", exitCode: 0, timedOut: false };
+  return {
+    stdout: (result.stdout || "").trim(),
+    exitCode: result.status == null ? 0 : result.status,
+    timedOut: result.signal === "SIGTERM",
+  };
+}
+
+// The SessionStart orientation text, produced once per session and handed to the model with its next request.
+let pendingSessionContext = null;
+
+// Advisories (read-before-edit, injection findings, phase-boundary, context warnings) were logged to stderr
+// only — OpenCode does not show a plugin's stderr or metadata to the model. They are appended to the tool's
+// own output instead, which is the one channel the model reads on both generations. An advisory raised before
+// the tool runs waits here for that tool's result.
+const pendingAdvisories = [];
+function deliverAdvisory(text, output) {
+  if (output && typeof output.output === "string") {
+    output.output += "\n\n[GSD advisory] " + text;
+    return;
+  }
+  if (!pendingAdvisories.includes(text) && pendingAdvisories.length < 5) pendingAdvisories.push(text);
+}
+function flushPendingAdvisories(output) {
+  if (!output || typeof output.output !== "string") return;
+  while (pendingAdvisories.length > 0) output.output += "\n\n[GSD advisory] " + pendingAdvisories.shift();
+}
+// <<< gsd:opencode-parity
 
 // ---------------------------------------------------------------------------
 // Frontmatter helpers (for config registration)
 // ---------------------------------------------------------------------------
 
+// A self-contained copy of `locateFrontmatterFence` (src/frontmatter-fence.cts, the
+// one frontmatter fence owner). Kept here, not required from the built
+// gsd-core/bin/lib/frontmatter-fence.cjs, because this plugin must load in every
+// layout it is copied to — including a package/git-spec tree, which may carry no
+// built bin/lib. Found while implementing #5105: tests/frontmatter-fence.test.cjs
+// ("kept frontmatter fence copies agree with the owner") pins this copy to the owner
+// over a fixture corpus and a property test, and
+// scripts/lint-frontmatter-fence-drift.cjs allowlists exactly this function.
+function locateFrontmatterFence(text) {
+  if (typeof text !== "string") {
+    throw new TypeError(`locateFrontmatterFence: expected a string, got ${typeof text}`);
+  }
+  const closingFenceLine = /^---[ \t]*$/;
+  const lenientClosingFenceLine = /^-{4,}[ \t]*$/;
+  const bom = text.charCodeAt(0) === 0xfeff ? text.slice(0, 1) : "";
+  const start = bom.length;
+  let eol;
+  if (text.startsWith("---\r\n", start)) eol = "\r\n";
+  else if (text.startsWith("---\n", start)) eol = "\n";
+  else return null;
+  const openEnd = start + 3 + eol.length;
+  const closedAt = (lineStart, lineEnd) => {
+    let bodyEnd = openEnd;
+    if (lineStart > openEnd) {
+      bodyEnd = lineStart - 1;
+      if (bodyEnd > openEnd && text[bodyEnd - 1] === "\r") bodyEnd -= 1;
+    }
+    return { bom, eol, openEnd, closed: true, closingStart: lineStart, closingFenceEnd: lineEnd, bodyEnd };
+  };
+  let lenient = null;
+  let lineStart = openEnd;
+  while (lineStart <= text.length) {
+    const newline = text.indexOf("\n", lineStart);
+    const lineEnd = newline === -1 ? text.length : newline > lineStart && text[newline - 1] === "\r" ? newline - 1 : newline;
+    const line = text.slice(lineStart, lineEnd);
+    if (closingFenceLine.test(line)) return closedAt(lineStart, lineEnd);
+    if (lenient === null && lenientClosingFenceLine.test(line)) lenient = [lineStart, lineEnd];
+    if (newline === -1) break;
+    lineStart = newline + 1;
+  }
+  if (lenient !== null) return closedAt(lenient[0], lenient[1]);
+  return { bom, eol, openEnd, closed: false, closingStart: -1, closingFenceEnd: -1, bodyEnd: text.length };
+}
+
 function parseFrontmatter(content) {
-  const m = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
-  if (!m) return { frontmatter: {}, body: content };
+  const fence = locateFrontmatterFence(content);
+  if (!fence || !fence.closed) return { frontmatter: {}, body: content };
   const fm = {};
-  for (const line of m[1].split("\n")) {
+  for (const line of content.slice(fence.openEnd, fence.bodyEnd).split(/\r?\n/)) {
     const i = line.indexOf(":");
     if (i > 0) {
       let v = line.slice(i + 1).trim();
@@ -343,7 +519,8 @@ function parseFrontmatter(content) {
       fm[line.slice(0, i).trim()] = v;
     }
   }
-  return { frontmatter: fm, body: m[2] };
+  // The body is everything past the closing fence line and its line ending.
+  return { frontmatter: fm, body: content.slice(fence.closingFenceEnd).replace(/^\r?\n/, "") };
 }
 
 // Rewrite @~/.claude/ includes to point at the repo root.
@@ -588,6 +765,13 @@ const GsdCorePlugin = async ({ directory } = {}) => {
         const r = runHook("gsd-secret-read-guard.js", prePayload());
         handleHookResult(r, output);
       }
+      // >>> gsd:opencode-parity
+      // 7. gsd-validate-commit.sh — Conventional Commits gate (opt-in: hooks.community)
+      if (claudeTool === "Bash" && communityHooksEnabled(cwd)) {
+        const r = runShellHook("gsd-validate-commit.sh", prePayload());
+        handleHookResult(r, output);
+      }
+      // <<< gsd:opencode-parity
     },
 
     // ── tool.execute.after — PostToolUse hooks ─────────────────────────
@@ -611,6 +795,25 @@ const GsdCorePlugin = async ({ directory } = {}) => {
             : String(output.output);
         output.output = rewriteContent(content);
       }
+      // >>> gsd:opencode-parity
+      flushPendingAdvisories(output);
+      // gsd-phase-boundary.sh — reminder when .planning/ files change outside the workflow (opt-in)
+      // gsd-graphify-update.sh — rebuild the knowledge graph after a HEAD-advancing git op (opt-in)
+      {
+        const postPayload = {
+          hook_event_name: "PostToolUse",
+          tool_name: claudeTool,
+          tool_input: toolInput,
+          cwd,
+        };
+        if ((claudeTool === "Write" || claudeTool === "Edit") && communityHooksEnabled(cwd)) {
+          handleHookResult(runShellHook("gsd-phase-boundary.sh", postPayload), output);
+        }
+        if (claudeTool === "Bash" && graphifyAutoUpdateEnabled(cwd)) {
+          handleHookResult(runShellHook("gsd-graphify-update.sh", postPayload, { timeout: 8000 }), output);
+        }
+      }
+      // <<< gsd:opencode-parity
 
       // gsd-read-injection-scanner.js — scan Read/WebFetch/WebSearch results
       if (
@@ -648,6 +851,16 @@ const GsdCorePlugin = async ({ directory } = {}) => {
         handleHookResult(r, output);
       }
     },
+    // >>> gsd:opencode-parity
+    // ── experimental.chat.system.transform — SessionStart orientation (gsd-session-state.sh) ──
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (!pendingSessionContext) return;
+      const text = pendingSessionContext;
+      pendingSessionContext = null;
+      output.system = output.system || [];
+      output.system.push(text);
+    },
+    // <<< gsd:opencode-parity
 
     // ── experimental.session.compacting — PreCompact ───────────────────
     "experimental.session.compacting": async (_input, output) => {
@@ -691,6 +904,23 @@ const GsdCorePlugin = async ({ directory } = {}) => {
           session_id: currentSessionId,
           cwd: currentCwd,
         });
+        // >>> gsd:opencode-parity
+        // gsd-session-state.sh — project state orientation for the session (opt-in: hooks.community)
+        if (communityHooksEnabled(currentCwd)) {
+          const r = runShellHook("gsd-session-state.sh", {
+            hook_event_name: "SessionStart",
+            session_id: currentSessionId,
+            cwd: currentCwd,
+          });
+          try {
+            const parsed = JSON.parse(r.stdout);
+            const text = parsed && parsed.hookSpecificOutput && parsed.hookSpecificOutput.additionalContext;
+            pendingSessionContext = typeof text === "string" && text ? text : null;
+          } catch {
+            pendingSessionContext = null;
+          }
+        }
+        // <<< gsd:opencode-parity
         return;
       }
 
@@ -777,6 +1007,7 @@ GsdCorePlugin._internals = {
   IS_PACKAGE_TREE,
   mapToolName,
   mapToolInput,
+  locateFrontmatterFence,
   parseFrontmatter,
   rewriteContent,
   isGsdManagedFile,
@@ -784,7 +1015,106 @@ GsdCorePlugin._internals = {
   GsdCorePlugin,
 };
 
+// >>> gsd:opencode-v2 (ADR-5331 D2; OpenCode 2.x entrypoint — the Kilo mirror omits this block)
+// OpenCode 2.x calls `setup(ctx)` with a `ctx` exposing `ctx.tool.hook(...)`; 1.x loads `server`
+// and never calls `setup` with such a ctx. `setup` therefore returns at once unless it is
+// handed a 2.x ctx. The 1.x hook handlers are reused through thin adapters so both generations
+// run the same guards.
+function v2ResultText(result) {
+  const first = result && Array.isArray(result.content) ? result.content[0] : null;
+  return first && typeof first.text === "string" ? first.text : null;
+}
+
+async function setupV2(ctx) {
+  if (!(ctx && ctx.tool && typeof ctx.tool.hook === "function")) return undefined;
+  const hooks = await GsdCorePlugin({ directory: ctx.directory });
+  // A thrown error in a 2.x before-hook blocks the tool (verified on 2.0.27), as in 1.x.
+  await ctx.tool.hook("execute.before", async (e) => {
+    await hooks["tool.execute.before"]({ tool: e.tool }, { args: e.input || {} });
+  });
+  await ctx.tool.hook("execute.after", async (e) => {
+    if (e.status !== "completed") return;
+    const text = v2ResultText(e.result);
+    const out = { output: text, metadata: {} };
+    await hooks["tool.execute.after"]({ tool: e.tool, args: e.input || {} }, out);
+    if (text !== null && typeof out.output === "string" && out.output !== text) {
+      e.result.content[0].text = out.output;
+    }
+    // 2.x emits no file.edited event (observed on 2.0.27), so derive it from the edit tools: the
+    // only consumer is the .planning/config.json reload hook.
+    const claudeTool = mapToolName(e.tool);
+    if (claudeTool === "Write" || claudeTool === "Edit" || claudeTool === "MultiEdit") {
+      const edited = mapToolInput(e.input || {}).file_path;
+      if (typeof edited === "string" && edited.endsWith("config.json")) {
+        await hooks.event({
+          event: { type: "file.edited", properties: { file: edited, cwd: path.dirname(path.dirname(edited)) } },
+        });
+      }
+    }
+  });
+  if (ctx.session && typeof ctx.session.hook === "function") {
+    // 2.x compaction event: { sessionID, system: [{ type: "text", text }], messages, … }; items added
+    // to `system` reach the summarizer (observed on 2.0.27).
+    // gsd:opencode-parity: SessionStart orientation reaches the model through the 2.x context hook.
+    await ctx.session.hook("context", async (e) => {
+      if (!e || !Array.isArray(e.system)) return;
+      const out = { system: [] };
+      await hooks["experimental.chat.system.transform"]({}, out);
+      for (const line of out.system) e.system.push({ type: "text", text: String(line) });
+    });
+    await ctx.session.hook("compaction", async (e) => {
+      if (!e || !Array.isArray(e.system)) return;
+      const out = { context: [] };
+      await hooks["experimental.session.compacting"]({}, out);
+      for (const line of out.context) e.system.push({ type: "text", text: String(line) });
+    });
+  }
+  if (ctx.shell && typeof ctx.shell.hook === "function") {
+    await ctx.shell.hook("create.before", async (e) => {
+      if (e && e.env && typeof e.env === "object") e.env.GSD_DIR = GSD_CORE;
+    });
+  }
+  let stop = null;
+  const seenSessions = new Set();
+  if (ctx.event && typeof ctx.event.subscribe === "function") {
+    const ac = new AbortController();
+    stop = () => ac.abort();
+    (async () => {
+      for await (const ev of ctx.event.subscribe({ signal: ac.signal })) {
+        // 2.0.27 shape (observed): { type, location: { directory }, data: { sessionID, … } }.
+        const d = (ev && ev.data) || {};
+        const dir = (ev && ev.location && ev.location.directory) || (d.location && d.location.directory);
+        try {
+          // A 2.x `run` never emits `session.created` (observed on 2.0.27: the first event of a session is
+          // `session.inbox.enqueued`). The first event that names a session is its SessionStart.
+          if (ev.type !== "session.created" && typeof d.sessionID === "string" && !seenSessions.has(d.sessionID)) {
+            seenSessions.add(d.sessionID);
+            await hooks.event({
+              event: { type: "session.created", properties: { info: { id: d.sessionID, directory: dir } }, sessionID: d.sessionID },
+            });
+          } else if (ev.type === "session.created" && typeof d.sessionID === "string") {
+            seenSessions.add(d.sessionID);
+          }
+          await hooks.event({
+            event: {
+              type: ev.type,
+              properties: { info: { id: d.sessionID, directory: dir }, file: d.file, cwd: dir },
+              sessionID: d.sessionID,
+            },
+          });
+        } catch {
+          // one bad event must not end the subscription
+        }
+      }
+    })().catch(() => {});
+  }
+  return stop || undefined;
+}
+// <<< gsd:opencode-v2
 const gsdCorePluginExport = { server: GsdCorePlugin };
+// >>> gsd:opencode-v2
+Object.defineProperty(gsdCorePluginExport, "setup", { value: setupV2, enumerable: false });
+// <<< gsd:opencode-v2
 Object.defineProperty(gsdCorePluginExport, "id", {
   value: "gsd-core",
   enumerable: false,

package/.opencode/plugins/gsd-statusline/tui.tsx

@@ -0,0 +1,55 @@
+// GSD statusline and update banner for the OpenCode 2.x terminal client (ADR-5331 Phase 3).
+//
+// A CLI plugin (https://opencode.ai/v2/docs/build/plugins/cli): OpenCode 2.x loads `tui.tsx` from a
+// directory under plugins/ and renders the slots registered here. The line itself comes from GSD's own
+// hooks/gsd-statusline.js — the script Claude Code runs — so state, progress, git and update-available
+// output stay one implementation. OpenCode 1.x never loads this directory (it scans plugins/*.js|ts only).
+import { Plugin } from "@opencode/plugin/tui"
+import { execFile } from "node:child_process"
+import { existsSync } from "node:fs"
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+
+const REFRESH_MS = 10_000
+// Strip terminal colour codes: the host styles its own footer.
+const ANSI = /\u001b\[[0-9;?]*[ -/]*[@-~]/g
+
+function hooksDir() {
+  // <config>/plugins/gsd-statusline/tui.tsx  →  <config>/hooks
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "..", "hooks")
+}
+
+function runtime() {
+  return process.env.GSD_HOOK_RUNTIME || "node"
+}
+
+function render(directory: string, model: string, done: (line: string) => void) {
+  const script = path.join(hooksDir(), "gsd-statusline.js")
+  // Only inside a GSD project, and only when the script is installed.
+  if (!existsSync(script) || !existsSync(path.join(directory, ".planning"))) return done("")
+  const child = execFile(runtime(), [script], { cwd: directory, timeout: 4000, windowsHide: true }, (error, stdout) => {
+    done(error ? "" : String(stdout).replace(ANSI, "").split("\n")[0].trim())
+  })
+  child.stdin?.end(JSON.stringify({ model: { display_name: model }, workspace: { current_dir: directory } }))
+}
+
+export default Plugin.define({
+  id: "gsd.statusline",
+  setup(context) {
+    const directory = context.location?.directory ?? context.data.location.default().directory
+    const [state, update] = context.storage.memory("line", { initial: { text: "" } })
+    const refresh = () => {
+      const selected = context.ui.model.current()
+      render(directory, selected?.modelID || "OpenCode", (text) => update((draft: { text: string }) => { draft.text = text }))
+    }
+    refresh()
+    const timer = setInterval(refresh, REFRESH_MS)
+    const stopHome = context.ui.slot({ append: "home.footer.status", render: () => <text>{state.text}</text> })
+    const stopPrompt = context.ui.slot({ append: "prompt.footer.status", render: () => <text>{state.text}</text> })
+    return () => {
+      clearInterval(timer)
+      stopHome?.()
+      stopPrompt?.()
+    }
+  },
+})

package/GEMINI.md

@@ -25,7 +25,7 @@ files rather than in the conversation.
 > run the dedicated installer:
 >
 > ```bash
-> npx gsd-core --antigravity --global
+> npx @opengsd/gsd-core@latest --antigravity --global
 > ```
 >
 > The commands below are available only once that installer has run.

package/agents/gsd-code-fixer.compact.md

@@ -287,7 +287,7 @@ For each finding in sorted order:
 **f. Commit atomically.** If verification passed, use `gsd_run query commit` (message first, then every staged file path):
 
 ```bash
-_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; _gsd_at() { for _p; do if [ -f "$_p" ]; then GSD_TOOLS="$_p"; return 0; fi; done; return 1; }; _gsd_id_ok() { case "$("$1" runtime-identity --raw 2>/dev/null || true)" in '{"packageName":"@opengsd/gsd-core"'*'}') return 0;; *) return 1;; esac; }; _gsd_homes() { _gsd_at "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/gsd-core/bin/${_GSD_SHIM_NAME}" "${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}" "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}" "${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}" "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}" "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}" "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}" "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}" "${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}" "${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}" "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}" "${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}" "${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}" "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}" "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}" "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}"; }; if _gsd_at "${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.codex/gsd-core/bin/${_GSD_SHIM_NAME}"; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif _gsd_homes; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif unset -f gsd_run; _G="$(command -v gsd_run)"; [ -n "$_G" ] && _gsd_id_ok "$_G"; then GSD_TOOLS="$_G"; gsd_run() { "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and no identity-proving gsd_run is on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi; GSD_IDENTITY_STATUS=unverified; _gsd_id_ok gsd_run && GSD_IDENTITY_STATUS=ok; export GSD_IDENTITY_STATUS; [ "$GSD_IDENTITY_STATUS" = ok ] || echo "WARNING: \"$GSD_TOOLS\" did not prove it is @opengsd/gsd-core - it is either a different package or an @opengsd/gsd-core older than the runtime-identity verb. See docs/how-to/diagnose-a-foreign-gsd-tools.md" >&2; if [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -n "${GSD_TOOLS:-}" ]; then printf "export PATH='%s':\"\$PATH\"\n" "${GSD_TOOLS%/*}" >> "$CLAUDE_ENV_FILE" 2>/dev/null || true; fi
+_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; _gsd_at() { for _p; do if [ -f "$_p" ]; then GSD_TOOLS="$_p"; return 0; fi; done; return 1; }; _gsd_id_ok() { case "$("$1" runtime-identity --raw 2>/dev/null || true)" in '{"packageName":"@opengsd/gsd-core"'*'}') return 0;; *) return 1;; esac; }; _gsd_homes() { set -- "${CLAUDE_CONFIG_DIR:-$HOME/.claude}" "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}" "$HOME/.gemini/antigravity-ide" "$HOME/.gemini/antigravity-cli" "${AUGMENT_CONFIG_DIR:-$HOME/.augment}" "${CLINE_CONFIG_DIR:-$HOME/.cline}" "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}" "${CODEX_HOME:-$HOME/.codex}" "${COPILOT_CONFIG_DIR:-${COPILOT_HOME:-$HOME/.copilot}}" "${CURSOR_CONFIG_DIR:-$HOME/.cursor}" "${HERMES_HOME:-$HOME/.hermes}" "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}" "${KIMI_CONFIG_DIR:-$HOME/.config/agents}" "$HOME/.agents" "${KIMI_CODE_HOME:-$HOME/.kimi-code}" "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}" "${PI_CODING_AGENT_DIR:-$HOME/.pi/agent}" "${QWEN_CONFIG_DIR:-$HOME/.qwen}" "${TRAE_CONFIG_DIR:-$HOME/.trae}" "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}" "${ZCODE_CONFIG_DIR:-$HOME/.zcode}" "${GROK_AGENTS_HOME:-$HOME/.agents}"; for _h; do _gsd_at "$_h/gsd-core/bin/${_GSD_SHIM_NAME}" && return 0; done; return 1; }; if _gsd_at "${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.codex/gsd-core/bin/${_GSD_SHIM_NAME}"; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif _gsd_homes; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif unset -f gsd_run; _G="$(command -v gsd_run)"; [ -n "$_G" ] && _gsd_id_ok "$_G"; then GSD_TOOLS="$_G"; gsd_run() { "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and no identity-proving gsd_run is on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi; GSD_IDENTITY_STATUS=unverified; _gsd_id_ok gsd_run && GSD_IDENTITY_STATUS=ok; export GSD_IDENTITY_STATUS; [ "$GSD_IDENTITY_STATUS" = ok ] || echo "WARNING: \"$GSD_TOOLS\" did not prove it is @opengsd/gsd-core - it is either a different package or an @opengsd/gsd-core older than the runtime-identity verb. See docs/how-to/diagnose-a-foreign-gsd-tools.md" >&2; if [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -n "${GSD_TOOLS:-}" ]; then printf "export PATH='%s':\"\$PATH\"\n" "${GSD_TOOLS%/*}" >> "$CLAUDE_ENV_FILE" 2>/dev/null || true; fi
 gsd_run query commit \
   "fix({padded_phase}): {finding_id} {short_description}" \
   --files \

package/agents/gsd-code-fixer.md

@@ -532,7 +532,7 @@ For each finding in sorted order:
 
 Use `gsd_run query commit` with conventional format (message first, then every staged file path):
 ```bash
-_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; _gsd_at() { for _p; do if [ -f "$_p" ]; then GSD_TOOLS="$_p"; return 0; fi; done; return 1; }; _gsd_id_ok() { case "$("$1" runtime-identity --raw 2>/dev/null || true)" in '{"packageName":"@opengsd/gsd-core"'*'}') return 0;; *) return 1;; esac; }; _gsd_homes() { _gsd_at "${CLAUDE_CONFIG_DIR:-$HOME/.claude}/gsd-core/bin/${_GSD_SHIM_NAME}" "${HERMES_HOME:-$HOME/.hermes}/gsd-core/bin/${_GSD_SHIM_NAME}" "${CURSOR_CONFIG_DIR:-$HOME/.cursor}/gsd-core/bin/${_GSD_SHIM_NAME}" "${CODEX_HOME:-$HOME/.codex}/gsd-core/bin/${_GSD_SHIM_NAME}" "${GEMINI_CONFIG_DIR:-$HOME/.gemini}/gsd-core/bin/${_GSD_SHIM_NAME}" "${COPILOT_CONFIG_DIR:-$HOME/.copilot}/gsd-core/bin/${_GSD_SHIM_NAME}" "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}/gsd-core/bin/${_GSD_SHIM_NAME}" "${AUGMENT_CONFIG_DIR:-$HOME/.augment}/gsd-core/bin/${_GSD_SHIM_NAME}" "${TRAE_CONFIG_DIR:-$HOME/.trae}/gsd-core/bin/${_GSD_SHIM_NAME}" "${QWEN_CONFIG_DIR:-$HOME/.qwen}/gsd-core/bin/${_GSD_SHIM_NAME}" "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}/gsd-core/bin/${_GSD_SHIM_NAME}" "${CLINE_CONFIG_DIR:-$HOME/.cline}/gsd-core/bin/${_GSD_SHIM_NAME}" "${GROK_AGENTS_HOME:-$HOME/.agents}/gsd-core/bin/${_GSD_SHIM_NAME}" "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}/gsd-core/bin/${_GSD_SHIM_NAME}" "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}/gsd-core/bin/${_GSD_SHIM_NAME}" "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}/gsd-core/bin/${_GSD_SHIM_NAME}"; }; if _gsd_at "${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.codex/gsd-core/bin/${_GSD_SHIM_NAME}"; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif _gsd_homes; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif unset -f gsd_run; _G="$(command -v gsd_run)"; [ -n "$_G" ] && _gsd_id_ok "$_G"; then GSD_TOOLS="$_G"; gsd_run() { "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and no identity-proving gsd_run is on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi; GSD_IDENTITY_STATUS=unverified; _gsd_id_ok gsd_run && GSD_IDENTITY_STATUS=ok; export GSD_IDENTITY_STATUS; [ "$GSD_IDENTITY_STATUS" = ok ] || echo "WARNING: \"$GSD_TOOLS\" did not prove it is @opengsd/gsd-core - it is either a different package or an @opengsd/gsd-core older than the runtime-identity verb. See docs/how-to/diagnose-a-foreign-gsd-tools.md" >&2; if [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -n "${GSD_TOOLS:-}" ]; then printf "export PATH='%s':\"\$PATH\"\n" "${GSD_TOOLS%/*}" >> "$CLAUDE_ENV_FILE" 2>/dev/null || true; fi
+_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; _gsd_at() { for _p; do if [ -f "$_p" ]; then GSD_TOOLS="$_p"; return 0; fi; done; return 1; }; _gsd_id_ok() { case "$("$1" runtime-identity --raw 2>/dev/null || true)" in '{"packageName":"@opengsd/gsd-core"'*'}') return 0;; *) return 1;; esac; }; _gsd_homes() { set -- "${CLAUDE_CONFIG_DIR:-$HOME/.claude}" "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}" "$HOME/.gemini/antigravity-ide" "$HOME/.gemini/antigravity-cli" "${AUGMENT_CONFIG_DIR:-$HOME/.augment}" "${CLINE_CONFIG_DIR:-$HOME/.cline}" "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}" "${CODEX_HOME:-$HOME/.codex}" "${COPILOT_CONFIG_DIR:-${COPILOT_HOME:-$HOME/.copilot}}" "${CURSOR_CONFIG_DIR:-$HOME/.cursor}" "${HERMES_HOME:-$HOME/.hermes}" "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}" "${KIMI_CONFIG_DIR:-$HOME/.config/agents}" "$HOME/.agents" "${KIMI_CODE_HOME:-$HOME/.kimi-code}" "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}" "${PI_CODING_AGENT_DIR:-$HOME/.pi/agent}" "${QWEN_CONFIG_DIR:-$HOME/.qwen}" "${TRAE_CONFIG_DIR:-$HOME/.trae}" "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}" "${ZCODE_CONFIG_DIR:-$HOME/.zcode}" "${GROK_AGENTS_HOME:-$HOME/.agents}"; for _h; do _gsd_at "$_h/gsd-core/bin/${_GSD_SHIM_NAME}" && return 0; done; return 1; }; if _gsd_at "${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.codex/gsd-core/bin/${_GSD_SHIM_NAME}"; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif _gsd_homes; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif unset -f gsd_run; _G="$(command -v gsd_run)"; [ -n "$_G" ] && _gsd_id_ok "$_G"; then GSD_TOOLS="$_G"; gsd_run() { "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and no identity-proving gsd_run is on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi; GSD_IDENTITY_STATUS=unverified; _gsd_id_ok gsd_run && GSD_IDENTITY_STATUS=ok; export GSD_IDENTITY_STATUS; [ "$GSD_IDENTITY_STATUS" = ok ] || echo "WARNING: \"$GSD_TOOLS\" did not prove it is @opengsd/gsd-core - it is either a different package or an @opengsd/gsd-core older than the runtime-identity verb. See docs/how-to/diagnose-a-foreign-gsd-tools.md" >&2; if [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -n "${GSD_TOOLS:-}" ]; then printf "export PATH='%s':\"\$PATH\"\n" "${GSD_TOOLS%/*}" >> "$CLAUDE_ENV_FILE" 2>/dev/null || true; fi
 gsd_run query commit \
   "fix({padded_phase}): {finding_id} {short_description}" \
   --files \

package/agents/gsd-code-reviewer.compact.md

@@ -84,12 +84,14 @@ files:
 ```
 Present and non-empty → use directly, skip fallback below.
 
-**Fallback (safety net only, when invoked directly without workflow context — `/gsd:code-review` always passes `files`):** if `files` absent/empty, compute DIFF_BASE from `diff_base` if provided; otherwise **fail closed**: "Cannot determine review scope. Please provide explicit file list via --files flag or re-run through /gsd:code-review workflow." Do NOT invent a heuristic (e.g. HEAD~5) — silent mis-scoping is worse than failing loudly.
+**Fallback (safety net only, when invoked directly without workflow context — `/gsd:code-review` always passes `files`):** if `files` absent/empty, ask the evaluation-scope resolver (#5164) for the phase named by `phase_dir`; otherwise **fail closed**: "Cannot determine review scope. Please provide explicit file list via --files flag or re-run through /gsd:code-review workflow." Do NOT invent a heuristic (e.g. HEAD~5) or a `base..HEAD` range — silent mis-scoping is worse than failing loudly.
 
-If DIFF_BASE set:
+Resolver call (phase number = the leading digits of the `phase_dir` basename; add `--since "$diff_base"` when `diff_base` is provided):
 ```bash
-git diff --name-only ${DIFF_BASE}..HEAD -- . ':!.planning/' ':!ROADMAP.md' ':!STATE.md' ':!*-SUMMARY.md' ':!*-VERIFICATION.md' ':!*-PLAN.md' ':!package-lock.json' ':!yarn.lock' ':!Gemfile.lock' ':!poetry.lock'
+_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; _gsd_at() { for _p; do if [ -f "$_p" ]; then GSD_TOOLS="$_p"; return 0; fi; done; return 1; }; _gsd_id_ok() { case "$("$1" runtime-identity --raw 2>/dev/null || true)" in '{"packageName":"@opengsd/gsd-core"'*'}') return 0;; *) return 1;; esac; }; _gsd_homes() { set -- "${CLAUDE_CONFIG_DIR:-$HOME/.claude}" "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}" "$HOME/.gemini/antigravity-ide" "$HOME/.gemini/antigravity-cli" "${AUGMENT_CONFIG_DIR:-$HOME/.augment}" "${CLINE_CONFIG_DIR:-$HOME/.cline}" "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}" "${CODEX_HOME:-$HOME/.codex}" "${COPILOT_CONFIG_DIR:-${COPILOT_HOME:-$HOME/.copilot}}" "${CURSOR_CONFIG_DIR:-$HOME/.cursor}" "${HERMES_HOME:-$HOME/.hermes}" "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}" "${KIMI_CONFIG_DIR:-$HOME/.config/agents}" "$HOME/.agents" "${KIMI_CODE_HOME:-$HOME/.kimi-code}" "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}" "${PI_CODING_AGENT_DIR:-$HOME/.pi/agent}" "${QWEN_CONFIG_DIR:-$HOME/.qwen}" "${TRAE_CONFIG_DIR:-$HOME/.trae}" "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}" "${ZCODE_CONFIG_DIR:-$HOME/.zcode}" "${GROK_AGENTS_HOME:-$HOME/.agents}"; for _h; do _gsd_at "$_h/gsd-core/bin/${_GSD_SHIM_NAME}" && return 0; done; return 1; }; if _gsd_at "${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.codex/gsd-core/bin/${_GSD_SHIM_NAME}"; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif _gsd_homes; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif unset -f gsd_run; _G="$(command -v gsd_run)"; [ -n "$_G" ] && _gsd_id_ok "$_G"; then GSD_TOOLS="$_G"; gsd_run() { "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and no identity-proving gsd_run is on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi; GSD_IDENTITY_STATUS=unverified; _gsd_id_ok gsd_run && GSD_IDENTITY_STATUS=ok; export GSD_IDENTITY_STATUS; [ "$GSD_IDENTITY_STATUS" = ok ] || echo "WARNING: \"$GSD_TOOLS\" did not prove it is @opengsd/gsd-core - it is either a different package or an @opengsd/gsd-core older than the runtime-identity verb. See docs/how-to/diagnose-a-foreign-gsd-tools.md" >&2; if [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -n "${GSD_TOOLS:-}" ]; then printf "export PATH='%s':\"\$PATH\"\n" "${GSD_TOOLS%/*}" >> "$CLAUDE_ENV_FILE" 2>/dev/null || true; fi
+gsd_run check evaluation-scope --phase "<phase number>" --raw
 ```
+Use its `files`. A `status` of `unresolvable` (exit 69, JSON still printed), or empty `files`, is the fail-closed case above; `degraded` is usable but say so in REVIEW.md.
 
 **4. Parse structural findings when present:** `<structural_findings>...</structural_findings>` → parse JSON, cache as `STRUCTURAL_FINDINGS`. Include in `## Structural Findings (fallow)` section of REVIEW.md during `write_review` (verbatim if small; concise summary if large). Optional block — absence means no structural pre-pass.
 

package/agents/gsd-code-reviewer.md

@@ -127,16 +127,18 @@ Parse each `- path` line under `files:` into the REVIEW_FILES array. If `files`
 
 This fallback runs ONLY when invoked directly without workflow context. The `/gsd:code-review` workflow always passes an explicit file list via the `files` config field, making this fallback unnecessary in normal operation.
 
-If `files` is absent or empty, compute DIFF_BASE:
-1. If `diff_base` is provided in config, use it
-2. Otherwise, **fail closed** with error: "Cannot determine review scope. Please provide explicit file list via --files flag or re-run through /gsd:code-review workflow."
+If `files` is absent or empty, ask the evaluation-scope resolver (#5164, ADR-5057 §4) for the phase named by `phase_dir`:
+1. The phase number is the leading digits of the `phase_dir` basename; add `--since "$diff_base"` when `diff_base` is provided in config
+2. If the resolver reports `status: unresolvable` (it exits 69 and still prints its JSON), or returns no `files`, **fail closed** with error: "Cannot determine review scope. Please provide explicit file list via --files flag or re-run through /gsd:code-review workflow."
 
-Do NOT invent a heuristic (e.g., HEAD~5) — silent mis-scoping is worse than failing loudly.
+Do NOT invent a heuristic (e.g., HEAD~5) or a `base..HEAD` range — silent mis-scoping is worse than failing loudly.
 
-If DIFF_BASE is set, run:
+Run:
 ```bash
-git diff --name-only ${DIFF_BASE}..HEAD -- . ':!.planning/' ':!ROADMAP.md' ':!STATE.md' ':!*-SUMMARY.md' ':!*-VERIFICATION.md' ':!*-PLAN.md' ':!package-lock.json' ':!yarn.lock' ':!Gemfile.lock' ':!poetry.lock'
+_GSD_SHIM_NAME="gsd-tools.cjs"; _GSD_RUNTIME_ROOT="${RUNTIME_DIR:-$(git rev-parse --show-toplevel 2>/dev/null || pwd)}"; GSD_TOOLS="${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}"; _gsd_at() { for _p; do if [ -f "$_p" ]; then GSD_TOOLS="$_p"; return 0; fi; done; return 1; }; _gsd_id_ok() { case "$("$1" runtime-identity --raw 2>/dev/null || true)" in '{"packageName":"@opengsd/gsd-core"'*'}') return 0;; *) return 1;; esac; }; _gsd_homes() { set -- "${CLAUDE_CONFIG_DIR:-$HOME/.claude}" "${ANTIGRAVITY_CONFIG_DIR:-$HOME/.gemini/antigravity}" "$HOME/.gemini/antigravity-ide" "$HOME/.gemini/antigravity-cli" "${AUGMENT_CONFIG_DIR:-$HOME/.augment}" "${CLINE_CONFIG_DIR:-$HOME/.cline}" "${CODEBUDDY_CONFIG_DIR:-$HOME/.codebuddy}" "${CODEX_HOME:-$HOME/.codex}" "${COPILOT_CONFIG_DIR:-${COPILOT_HOME:-$HOME/.copilot}}" "${CURSOR_CONFIG_DIR:-$HOME/.cursor}" "${HERMES_HOME:-$HOME/.hermes}" "${KILO_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/kilo}" "${KIMI_CONFIG_DIR:-$HOME/.config/agents}" "$HOME/.agents" "${KIMI_CODE_HOME:-$HOME/.kimi-code}" "${OPENCODE_CONFIG_DIR:-${XDG_CONFIG_HOME:-$HOME/.config}/opencode}" "${PI_CODING_AGENT_DIR:-$HOME/.pi/agent}" "${QWEN_CONFIG_DIR:-$HOME/.qwen}" "${TRAE_CONFIG_DIR:-$HOME/.trae}" "${WINDSURF_CONFIG_DIR:-$HOME/.codeium/windsurf}" "${ZCODE_CONFIG_DIR:-$HOME/.zcode}" "${GROK_AGENTS_HOME:-$HOME/.agents}"; for _h; do _gsd_at "$_h/gsd-core/bin/${_GSD_SHIM_NAME}" && return 0; done; return 1; }; if _gsd_at "${_GSD_RUNTIME_ROOT}/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.claude/gsd-core/bin/${_GSD_SHIM_NAME}" "${_GSD_RUNTIME_ROOT}/.codex/gsd-core/bin/${_GSD_SHIM_NAME}"; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif _gsd_homes; then gsd_run() { node "$GSD_TOOLS" "$@"; }; elif unset -f gsd_run; _G="$(command -v gsd_run)"; [ -n "$_G" ] && _gsd_id_ok "$_G"; then GSD_TOOLS="$_G"; gsd_run() { "$GSD_TOOLS" "$@"; }; else echo "ERROR: gsd-tools.cjs not found at $GSD_TOOLS and no identity-proving gsd_run is on PATH. Run: npx -y @opengsd/gsd-core@latest --claude --local" >&2; exit 1; fi; GSD_IDENTITY_STATUS=unverified; _gsd_id_ok gsd_run && GSD_IDENTITY_STATUS=ok; export GSD_IDENTITY_STATUS; [ "$GSD_IDENTITY_STATUS" = ok ] || echo "WARNING: \"$GSD_TOOLS\" did not prove it is @opengsd/gsd-core - it is either a different package or an @opengsd/gsd-core older than the runtime-identity verb. See docs/how-to/diagnose-a-foreign-gsd-tools.md" >&2; if [ -n "${CLAUDE_ENV_FILE:-}" ] && [ -n "${GSD_TOOLS:-}" ]; then printf "export PATH='%s':\"\$PATH\"\n" "${GSD_TOOLS%/*}" >> "$CLAUDE_ENV_FILE" 2>/dev/null || true; fi
+gsd_run check evaluation-scope --phase "<phase number>" --raw
 ```
+Use its `files` (the union of the phase's own commits' file sets, planning artifacts and lockfiles excluded). A `degraded` status is usable, but say so in REVIEW.md. A `status` of `unresolvable` (exit `69`, JSON still printed) means the scope could not be resolved: an empty `files` then is not a clean review — fail loudly as above.
 
 **4. Parse structural findings when present:** If prompt includes:
 ```xml