continuous-improvement 3.19.0 → 3.20.4

package/scripts/scan-past-mistakes.mjs

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+// scripts/scan-past-mistakes.mjs
+//
+// Scan the three past-mistake surfaces named in Phase 0 P-MAG of
+// `proceed-with-the-recommendation` and surface their content as a
+// machine-readable list, so the skill's most-skipped phase becomes
+// mechanically detectable: if the scan never runs, no output is emitted.
+//
+// Surfaces (all three are scanned every invocation):
+//   1. observations.jsonl  — JSONL lines whose type (or legacy event field)
+//      is "failure" or "correction". Last N (default 10) returned.
+//   2. memory feedback     — every feedback_*.md file in the project's
+//      auto-memory directory whose frontmatter declares `type: feedback`.
+//   3. CLAUDE.md           — rows extracted from a "## Past Mistakes" table
+//      in the project's CLAUDE.md (markdown table, first column = date).
+//
+// Defaults derive each path from the project root (positional arg; default
+// cwd). All three can be overridden explicitly via flags for testing or
+// non-default layouts.
+//
+// Usage:
+//   node scripts/scan-past-mistakes.mjs                       # cwd default
+//   node scripts/scan-past-mistakes.mjs <repo-root>           # explicit root
+//   node scripts/scan-past-mistakes.mjs --json                # JSON output
+//   node scripts/scan-past-mistakes.mjs \
+//     --observations <path> --memory-dir <dir> --claude-md <path>
+//   node scripts/scan-past-mistakes.mjs --max-observations 25
+//
+// Active-in-scope assessment is the LLM's job, not the script's. The script
+// surfaces raw entries with citations; the skill body annotates each line
+// with "Active in current scope: yes|no" based on the current task.
+//
+// Cited by:
+//   - skills/proceed-with-the-recommendation.md Phase 0 Rule 1
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { argv, cwd, exit, stdout } from "node:process";
+
+function parseArgs() {
+  const args = argv.slice(2);
+  const out = {
+    json: false,
+    root: cwd(),
+    observations: null,
+    memoryDir: null,
+    claudeMd: null,
+    maxObservations: 10,
+  };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--json") {
+      out.json = true;
+    } else if (a === "--observations") {
+      out.observations = args[++i];
+    } else if (a === "--memory-dir") {
+      out.memoryDir = args[++i];
+    } else if (a === "--claude-md") {
+      out.claudeMd = args[++i];
+    } else if (a === "--max-observations") {
+      out.maxObservations = parseInt(args[++i], 10) || 10;
+    } else if (a === "-h" || a === "--help") {
+      stdout.write(
+        "usage: scan-past-mistakes.mjs [--json] [<repo-root>]\n" +
+          "       [--observations <path>] [--memory-dir <dir>] [--claude-md <path>]\n" +
+          "       [--max-observations <n>]\n",
+      );
+      exit(0);
+    } else {
+      out.root = a;
+    }
+  }
+  return out;
+}
+
+// Map a project root to the auto-memory subdirectory name. Lowercases the
+// Windows drive letter and replaces path separators with dashes, matching
+// the convention used by `~/.claude/projects/<hash>/memory/` and
+// `~/.claude/instincts/<hash>/`. On POSIX paths the leading slash becomes
+// a leading dash, which is fine — the host has the same path on both
+// surfaces and the resolved file existence is what's checked, not the
+// hash format itself.
+function projectHash(root) {
+  let p = root;
+  p = p.replace(/^([A-Za-z]):/, (_m, d) => d.toLowerCase() + ":");
+  p = p.replace(/:[\\/]/, "--");
+  p = p.replace(/[\\/]/g, "-");
+  return p;
+}
+
+function defaultObservationsPath(root) {
+  return join(homedir(), ".claude", "instincts", projectHash(root), "observations.jsonl");
+}
+
+function defaultMemoryDir(root) {
+  return join(homedir(), ".claude", "projects", projectHash(root), "memory");
+}
+
+function defaultClaudeMdPath(root) {
+  return join(root, "CLAUDE.md");
+}
+
+function scanObservations(path, maxN) {
+  if (!path || !existsSync(path)) return [];
+  const raw = readFileSync(path, "utf8");
+  const lines = raw.split(/\r?\n/);
+  const matches = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (!line) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    // Support both the current `type` field and the legacy `event` field
+    // (per feedback_observer_field_name_bug — pre-2026-05-06T00:38Z rows).
+    const t = obj.type ?? obj.event;
+    if (t !== "failure" && t !== "correction") continue;
+    const summary =
+      obj.summary ??
+      obj.output_summary ??
+      (typeof obj.tool_response === "string"
+        ? obj.tool_response
+        : JSON.stringify(obj).slice(0, 240));
+    matches.push({
+      line: i + 1,
+      ts: obj.ts ?? obj.timestamp ?? null,
+      type: t,
+      summary,
+    });
+  }
+  // Last N (chronologically — JSONL is append-only).
+  return matches.slice(-maxN);
+}
+
+function parseFrontmatter(content) {
+  const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  if (!m) return null;
+  const fm = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    const kv = /^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/.exec(line);
+    if (!kv) continue;
+    let value = kv[2].trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    fm[kv[1]] = value;
+  }
+  return fm;
+}
+
+function scanFeedbackMemories(dir) {
+  if (!dir || !existsSync(dir)) return [];
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const file of entries) {
+    if (!file.startsWith("feedback_") || !file.endsWith(".md")) continue;
+    let content;
+    try {
+      content = readFileSync(join(dir, file), "utf8");
+    } catch {
+      continue;
+    }
+    const fm = parseFrontmatter(content);
+    if (!fm) continue;
+    // Only surface entries explicitly typed as feedback.
+    if (fm.type && fm.type !== "feedback") continue;
+    out.push({
+      file,
+      name: fm.name ?? null,
+      description: fm.description ?? null,
+    });
+  }
+  out.sort((a, b) => a.file.localeCompare(b.file));
+  return out;
+}
+
+function scanClaudeMdPastMistakes(path) {
+  if (!path || !existsSync(path)) return [];
+  const content = readFileSync(path, "utf8");
+  const headingIdx = content.search(/^##\s+Past Mistakes\s*$/m);
+  if (headingIdx === -1) return [];
+
+  // Slice from the heading to the start of the next ## heading (or EOF).
+  const fromHeading = content.slice(headingIdx);
+  const nextSectionRel = fromHeading.slice(2).search(/^##\s/m);
+  const section = nextSectionRel === -1 ? fromHeading : fromHeading.slice(0, nextSectionRel + 2);
+
+  const out = [];
+  for (const rawLine of section.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    // Skip blank, heading, and the markdown table divider.
+    if (!line || line.startsWith("#")) continue;
+    if (/^\|[\s|:-]+\|$/.test(line)) continue;
+    if (!line.startsWith("|") || !line.endsWith("|")) continue;
+
+    // Parse pipe-delimited cells; strip leading/trailing pipe.
+    const inner = line.slice(1, -1);
+    const cells = inner.split("|").map((c) => c.trim());
+    if (cells.length < 2) continue;
+
+    // Header detection: literal "Date" first cell.
+    if (cells[0].toLowerCase() === "date") continue;
+    if (/^[-: ]+$/.test(cells[0])) continue;
+
+    out.push({
+      date: cells[0],
+      mistake: cells[1] ?? "",
+      lesson: cells[2] ?? null,
+    });
+  }
+  return out;
+}
+
+function pretty(scan) {
+  const total = scan.observations.length + scan.feedback.length + scan.claude_md.length;
+  if (total === 0) return "No prior mistakes recorded — proceed.\n";
+
+  const out = [`Past mistakes scanned: ${total} found across 3 surfaces.`, ""];
+
+  if (scan.observations.length > 0) {
+    out.push(`== observations.jsonl (${scan.observations.length}) ==`);
+    for (const o of scan.observations) {
+      const ts = o.ts ? `${o.ts} ` : "";
+      out.push(`  [line ${o.line}] ${ts}${o.type}: ${o.summary}`);
+    }
+    out.push("");
+  }
+
+  if (scan.feedback.length > 0) {
+    out.push(`== feedback memories (${scan.feedback.length}) ==`);
+    for (const f of scan.feedback) {
+      out.push(`  [${f.file}] ${f.name ?? ""}`);
+      if (f.description) out.push(`    — ${f.description}`);
+    }
+    out.push("");
+  }
+
+  if (scan.claude_md.length > 0) {
+    out.push(`== CLAUDE.md Past Mistakes (${scan.claude_md.length}) ==`);
+    for (const e of scan.claude_md) {
+      out.push(`  [${e.date}] ${e.mistake}`);
+      if (e.lesson) out.push(`    Lesson: ${e.lesson}`);
+    }
+  }
+
+  return out.join("\n") + "\n";
+}
+
+function main() {
+  const args = parseArgs();
+  const obsPath = args.observations ?? defaultObservationsPath(args.root);
+  const memDir = args.memoryDir ?? defaultMemoryDir(args.root);
+  const claudeMd = args.claudeMd ?? defaultClaudeMdPath(args.root);
+
+  const scan = {
+    observations: scanObservations(obsPath, args.maxObservations),
+    feedback: scanFeedbackMemories(memDir),
+    claude_md: scanClaudeMdPastMistakes(claudeMd),
+    sources: {
+      observations: obsPath,
+      memory_dir: memDir,
+      claude_md: claudeMd,
+    },
+  };
+
+  if (args.json) {
+    stdout.write(JSON.stringify(scan, null, 2) + "\n");
+  } else {
+    stdout.write(pretty(scan));
+  }
+}
+
+main();

package/skills/deploy-receipt.md

@@ -21,7 +21,7 @@ This skill defines the receipt that closes that gap, without modifying the vendo
 Activate when ALL of the following are true:
 
 1. A merge into the deploy branch (typically `main` or `master`) has just landed
-2. [`scripts/detect-deploy-target.sh`](../scripts/detect-deploy-target.sh) returns a value other than `none` at the repo root. The script encodes the full file-marker table — `railway.toml` / `railway.json` → `railway`, `wrangler.toml` / `wrangler.jsonc` → `cloudflare`, `vercel.json` / `.vercel/` → `vercel`, `netlify.toml` → `netlify`, `fly.toml` → `fly`, `app.yaml` → `appengine`, `apprunner.yaml` → `apprunner`, `.github/workflows/*.yml` with a `deploy:` job → `gha-deploy`. First match wins, in that order. The script is the source of truth; the file list above is documentation
+2. `bash "${CLAUDE_PLUGIN_ROOT}/scripts/detect-deploy-target.sh"` (source: `scripts/detect-deploy-target.sh`) returns a value other than `none` at the repo root. The script encodes the full file-marker table — `railway.toml` / `railway.json` → `railway`, `wrangler.toml` / `wrangler.jsonc` → `cloudflare`, `vercel.json` / `.vercel/` → `vercel`, `netlify.toml` → `netlify`, `fly.toml` → `fly`, `app.yaml` → `appengine`, `apprunner.yaml` → `apprunner`, `.github/workflows/*.yml` with a `deploy:` job → `gha-deploy`. First match wins, in that order. The script is the source of truth; the file list above is documentation
 3. `finishing-a-development-branch` has reported "merged" — not "PR opened", not "review pending"
 
 Do NOT activate when:
@@ -45,7 +45,7 @@ The skill is provider-aware but never hardcodes a specific API key or token shap
 
 ### Route A — Provider CLI (preferred when authenticated)
 
-The CLI is the highest-fidelity source. Run [`scripts/get-deployed-sha.sh <provider>`](../scripts/get-deployed-sha.sh) — the script owns the per-provider pipeline (CLI + jq filter) and prints just the SHA on stdout. Inspect the pipeline shape without executing via `bash scripts/get-deployed-sha.sh --show-command <provider>`.
+The CLI is the highest-fidelity source. Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/get-deployed-sha.sh" <provider>` (source: `scripts/get-deployed-sha.sh`) — the script owns the per-provider pipeline (CLI + jq filter) and prints just the SHA on stdout. Inspect the pipeline shape without executing via `bash "${CLAUDE_PLUGIN_ROOT}/scripts/get-deployed-sha.sh" --show-command <provider>`.
 
 Provider-to-pipeline map (cited from the script, not redefined here):
 

package/skills/gateguard.md

@@ -97,7 +97,7 @@ A second Claude/Codex/Maulana session can be running on the same host and the sa
 
 **On the first Edit / Write / mutating Bash of a session:**
 
-Run [`scripts/git-state-snapshot.sh`](../scripts/git-state-snapshot.sh) and quote its JSON envelope verbatim. Example output:
+Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/git-state-snapshot.sh"` (source: `scripts/git-state-snapshot.sh`) and quote its JSON envelope verbatim. Example output:
 
 ```
 {"head":"966ce51","upstream":"966ce51","dirty":0,"root":"/path/to/repo","branch":"main"}
@@ -115,7 +115,7 @@ If `upstream` is `"none"` or `branch` is `"detached"`, say so explicitly. Do not
 
 **On every subsequent Edit / Write / mutating Bash, before allowing the action:**
 
-Re-run [`scripts/git-state-snapshot.sh`](../scripts/git-state-snapshot.sh) and diff against the baseline:
+Re-run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/git-state-snapshot.sh"` (source: `scripts/git-state-snapshot.sh`) and diff against the baseline:
 
 1. `head` — has it advanced past your baseline without your commits?
 2. `upstream` — did upstream move while you worked?

package/skills/proceed-with-the-recommendation.md

@@ -135,7 +135,7 @@ Before research begins, the skill must read its own track record. The instinct s
 
 ### Rule 1 — Acknowledge before context (right context from the beginning)
 
-Run [`scripts/scan-past-mistakes.mjs`](../scripts/scan-past-mistakes.mjs) at the project root. Scan three surfaces in one pass and surface every entry with a citation:
+Run `node "${CLAUDE_PLUGIN_ROOT}/scripts/scan-past-mistakes.mjs"` (source: `scripts/scan-past-mistakes.mjs`) at the project root. Scan three surfaces in one pass and surface every entry with a citation:
 
 - `~/.claude/instincts/<project-hash>/observations.jsonl` — last N (default 10) entries with `type: failure` or `correction` (legacy `event` field also matched for pre-2026-05-06 rows)
 - `~/.claude/projects/<project-hash>/memory/feedback_*.md` — every file whose frontmatter declares `type: feedback`; the canonical home of the operator's named corrections (e.g. `feedback_past_mistake_gate.md`, `feedback_no_git_add_all_on_windows.md`)
@@ -202,7 +202,7 @@ For each item in the ORIGINAL order:
 
 ### Routing Table (with Inline Fallbacks)
 
-Run [`scripts/route-recommendation.mjs "<item>"`](../scripts/route-recommendation.mjs) to match a single recommendation item to its preferred chain + inline fallback. Default mode prints the matched row; `--json` for programmatic consumption; `--list` enumerates every row. The programmatic source of truth is [`scripts/route-recommendation.routes.json`](../scripts/route-recommendation.routes.json) — the table below is the human-readable documentation that mirrors it. If they drift, the routes.json file wins.
+Run `node "${CLAUDE_PLUGIN_ROOT}/scripts/route-recommendation.mjs" "<item>"` (source: `scripts/route-recommendation.mjs`) to match a single recommendation item to its preferred chain + inline fallback. Default mode prints the matched row; `--json` for programmatic consumption; `--list` enumerates every row. The programmatic source of truth is `scripts/route-recommendation.routes.json` — the table below is the human-readable documentation that mirrors it. If they drift, the routes.json file wins.
 
 Rows whose **Preferred skill** is not bundled with the `continuous-improvement` plugin carry a `(Reference behavior — does not require <skill>.)` marker on the fallback cell. The marker makes the soft-dependency contract visible at point of use: the inline fallback is fully self-contained and runs without that skill installed. Rows whose preferred skill ships with the plugin (`ralph`, `tdd-workflow`, `continuous-improvement`) carry no marker — the dedicated skill is always available.
 

package/skills/reconcile.md

@@ -40,7 +40,7 @@ When another session/loop may be active, do not assume the tree is yours:
 - An in-progress `MERGE_HEAD` / `rebase-merge` you did not start means another actor is mid-operation. Do not "help" by editing conflicted files — wait, or hand off.
 - Re-read the current branch immediately before any mutation; if it shifted since your snapshot, re-survey from the top.
 - If `.git/index` keeps changing while you are idle, a writer is active. Pause and surface it rather than racing.
-- If `gateguard` is installed, its Parallel-Actor Gate already captured this baseline on the session's first mutation (via `scripts/git-state-snapshot.sh`) and divergence-checks every later mutation — `reconcile` complements that gate, it does not replace it. Without gateguard, run the snapshot above yourself.
+- If `gateguard` is installed, its Parallel-Actor Gate already captured this baseline on the session's first mutation by running `bash "${CLAUDE_PLUGIN_ROOT}/scripts/git-state-snapshot.sh"` (source: `scripts/git-state-snapshot.sh`) and divergence-checks every later mutation — `reconcile` complements that gate, it does not replace it. Without gateguard, run the snapshot above yourself.
 
 ## Classify, Then Act
 

package/skills/verification-loop.md

@@ -23,10 +23,10 @@ Invoke this skill:
 
 Every project has its own actual invocation for build / typecheck / lint / test / security / deploy-receipt. Hardcoding `npm run build` and `npm run test` works when the project happens to use those exact scripts; for everything else (pnpm, yarn, cargo, go, mise, just, custom scripts, monorepos with workspace-scoped commands) it returns "deps not installed" or "config not found" misreads from the wrong invocation. Phase 0 runs first so Phases 1–6 never have to guess.
 
-**Run [`scripts/resolve-verify-ladder.mjs`](../scripts/resolve-verify-ladder.mjs)** at the repo root. It encodes the full four-step resolution priority and emits the fenced block below. Use `--json` for machine consumption.
+**Run `node "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-verify-ladder.mjs"`** (source: `scripts/resolve-verify-ladder.mjs`) at the repo root. It encodes the full four-step resolution priority and emits the fenced block below. Use `--json` for machine consumption.
 
 ```
-$ node scripts/resolve-verify-ladder.mjs
+$ node "${CLAUDE_PLUGIN_ROOT}/scripts/resolve-verify-ladder.mjs"
 verify-ladder (resolved):
   build:             npm run build  (sniff:package.json:scripts.build)
   typecheck:         npm run typecheck  (sniff:package.json:scripts.typecheck)
@@ -147,9 +147,9 @@ If either is `No`, the verification report goes back to the operator with the ex
 
 For repos whose `verify-ladder.json` declares a `deploy_receipt` field — or whose sniff path detects an auto-deploy target — the verify is not complete until the deployed SHA matches the merge SHA and a healthcheck returns 200. Hand off to the `deploy-receipt` skill (Law 4 deploy-seam companion landed in PR #83) and treat its `Receipt status: COMPLETE` as the gate.
 
-**Detection.** Run [`scripts/detect-deploy-target.sh`](../scripts/detect-deploy-target.sh) at the repo root. Output is one of `railway` / `cloudflare` / `vercel` / `netlify` / `fly` / `appengine` / `apprunner` / `gha-deploy` / `none`. Anything except `none` triggers handoff to `deploy-receipt`; `none` means Phase 8 is skipped (no deploy seam exists).
+**Detection.** Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/detect-deploy-target.sh"` (source: `scripts/detect-deploy-target.sh`) at the repo root. Output is one of `railway` / `cloudflare` / `vercel` / `netlify` / `fly` / `appengine` / `apprunner` / `gha-deploy` / `none`. Anything except `none` triggers handoff to `deploy-receipt`; `none` means Phase 8 is skipped (no deploy seam exists).
 
-**SHA extraction.** For the detected provider, [`scripts/get-deployed-sha.sh <provider>`](../scripts/get-deployed-sha.sh) returns the currently-deployed SHA via the provider CLI; `--show-command <provider>` prints the pipeline shape without executing (useful for dry-runs and citation). `deploy-receipt` owns the receipt's other components (health endpoint, build artifact, on-incomplete modes) and Route B/C fallbacks.
+**SHA extraction.** For the detected provider, `bash "${CLAUDE_PLUGIN_ROOT}/scripts/get-deployed-sha.sh" <provider>` (source: `scripts/get-deployed-sha.sh`) returns the currently-deployed SHA via the provider CLI; `bash "${CLAUDE_PLUGIN_ROOT}/scripts/get-deployed-sha.sh" --show-command <provider>` prints the pipeline shape without executing (useful for dry-runs and citation). `deploy-receipt` owns the receipt's other components (health endpoint, build artifact, on-incomplete modes) and Route B/C fallbacks.
 
 INCOMPLETE receipts move to "Immediate operator action" in the close, never to "ready". Library-only / package-published repos skip this phase entirely (no deploy seam exists).
 
@@ -164,7 +164,7 @@ Phase 8 confirms the deploy seam. Phase 9 confirms the deployed surface matches
 
 **What the runner does:**
 
-Implementation: `scripts/run-synthetic.mjs` encodes the lexical walk, interpreter map, env injection, and exit-code aggregation below. The prose is documentation, not the contract — when the two disagree, the script wins.
+Run `node "${CLAUDE_PLUGIN_ROOT}/scripts/run-synthetic.mjs"` (source: `scripts/run-synthetic.mjs`); it encodes the lexical walk, interpreter map, env injection, and exit-code aggregation below. The prose is documentation, not the contract — when the two disagree, the script wins.
 
 1. List every `*.synthetic.{sh,mjs,ts,py}` file in the resolved directory in lexical order.
 2. For each file, set the input env vars: `BASE_URL` (production base from project config), `BASELINE_URL` (staging baseline from project config), `EXPECTED_SHA` (the merge SHA Phase 8 reported COMPLETE), `DEPLOY_BRANCH` (the deploy branch name), `RECEIPT_TIMESTAMP` (ISO-8601 of the receipt).

package/skills/workspace-surface-audit.md

@@ -74,7 +74,7 @@ Probe and record (no destructive commands; quote results inline):
 - **jq availability.** `command -v jq` (or `Get-Command jq`). When jq is missing, observation-pipeline hooks fall back to a thin schema and curl/JSON one-liners need a node/python rewrite.
 - **Case-sensitive filesystem.** Test by creating two paths differing only in case in a tempdir. NTFS (Windows) and APFS (macOS default) are case-insensitive; Linux ext4 and case-sensitive APFS are case-sensitive. Affects `CLAUDE.md` vs `claude.md` resolution and import paths.
 - **CWD baseline.** `pwd` (or `Get-Location`) recorded at session start. `tsc`, build scripts, and some test runners change CWD as a side effect; subsequent commands run from the wrong directory return "deps not installed" or "config not found" misreads.
-- **Parallel-actor expectation.** Document whether a second Claude / Codex / Maulana session may operate on the same working tree. If yes, the `gateguard` Parallel-Actor Gate uses [`scripts/git-state-snapshot.sh`](../scripts/git-state-snapshot.sh) to produce a single JSON envelope (`{head, upstream, dirty, root, branch}`) for the baseline and the divergence check. This skill records whether parallel-actor is expected; gateguard owns the runtime mechanics, so the audit doesn't restate the git-command triple.
+- **Parallel-actor expectation.** Document whether a second Claude / Codex / Maulana session may operate on the same working tree. If yes, the `gateguard` Parallel-Actor Gate runs `bash "${CLAUDE_PLUGIN_ROOT}/scripts/git-state-snapshot.sh"` (source: `scripts/git-state-snapshot.sh`) to produce a single JSON envelope (`{head, upstream, dirty, root, branch}`) for the baseline and the divergence check. This skill records whether parallel-actor is expected; gateguard owns the runtime mechanics, so the audit doesn't restate the git-command triple.
 
 Output the recorded grain as a single fenced block so it survives context compaction and any later phase can reference it without re-probing:
 

package/skills/worktree-safety.md

@@ -32,7 +32,7 @@ The continuous-improvement repo runs on Windows + Git Bash with `autocrlf=true`
 
 Before any source-writing call, verify all five. Fail closed on any miss.
 
-1. **Root validity** — `git rev-parse --show-toplevel` resolves; the resolved path matches CWD after symlink-safe canonicalization. The `root` field of [`scripts/git-state-snapshot.sh`](../scripts/git-state-snapshot.sh) carries the canonicalized root, and its non-zero exit on `{"error":"not-a-git-repo"}` is itself the fail-closed signal — no second probe needed.
+1. **Root validity** — `git rev-parse --show-toplevel` resolves; the resolved path matches CWD after symlink-safe canonicalization. Run `bash "${CLAUDE_PLUGIN_ROOT}/scripts/git-state-snapshot.sh"` (source: `scripts/git-state-snapshot.sh`); its `root` field carries the canonicalized root, and its non-zero exit on `{"error":"not-a-git-repo"}` is itself the fail-closed signal — no second probe needed.
 2. **`.git` presence** — `.git` exists (file pointer for worktrees, directory for primary checkout). A missing or unreadable `.git` is an immediate stop.
 3. **Worktree registration** — `git worktree list` includes the resolved root with no `prunable` flag. Prunable worktrees can be deleted by another process at any moment.
 4. **Branch alignment** — current branch matches the lease ledger; `HEAD` is not detached unless the unit explicitly asked for detached state. The snapshot script's `branch` field carries either the branch name or the literal `"detached"`, so detached-state is observable without a second probe.