continuous-improvement 3.22.0 → 3.22.1

package/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "continuous-improvement",
       "description": "The persistent-memory and runtime-discipline layer for Claude Code. It remembers the corrections you already gave, grounds every edit in real facts before it lands, and — through the Mulahazah engine — turns each fix into a reusable instinct, so a lesson learned once is applied automatically next time with no re-teaching. Built on the 7 Laws of AI Agent Discipline (research, plan, verify, reflect, learn) and shipped as 28 bundled skills, instinct-aware hooks, an MCP toolset for recall and reflection, and a GitHub Action transcript linter that feeds real work history back into sharper instincts.",
-      "version": "3.22.0",
+      "version": "3.22.1",
       "source": "./plugins/continuous-improvement",
       "author": {
         "name": "naimkatiman"

package/CHANGELOG.md

@@ -4,6 +4,19 @@ All notable changes to this skill are documented here.
 
 ---
 
+## [3.22.1] — 2026-08-04
+
+### Fixed
+
+- **`ci-reconcile` blocks an unborn HEAD instead of treating it as a usable baseline** — `git init` with no commit yet is a real git repository, but `git rev-parse HEAD` fails there. The runner accepted that as a pinnable state, and `--snapshot` emitted an empty `head` field that reads like success. Now reported as a `head-commit` blocker, with `--snapshot` emitting `head: "unborn"` and `blocked: true`. (#291)
+- **`isSafeRefName` rejects ref shapes git itself rejects** — empty path components (`a//b`), dot-prefixed or dot-suffixed components (`a/.b`, `a/b.`), and a per-component `.lock` suffix (`a/b.lock/c`) previously passed. Validation is now component-by-component, closer to `git check-ref-format`. (#291)
+- **`parseRevListCounts` uses `Number.isSafeInteger`** — `Number.isInteger` accepts values beyond `MAX_SAFE_INTEGER`, where arithmetic silently loses precision. Out-of-range counts now read as `unknown`, consistent with the module's fail-closed stance. (#291)
+- **The CLI rejects malformed argument combinations instead of resolving them silently** — a repeated `--verify-push` or `--cwd` used to be last-wins, an empty or whitespace-only `--cwd` fell back to the process working directory, and `--snapshot` / `--explain` / `--verify-push` together picked one arbitrarily. Each is now an explicit error. (#291)
+
+### Changed
+
+- **`--snapshot` follows the same exit contract as the default mode** (`0` clear / `1` blocked / `2` not a repository) where it previously always exited `0`, and its envelope gains `blocked` and `blockers`. It still writes the JSON on a blocker, so a `set -e` script capturing a baseline must tolerate exit 1. Documented in the skill and command, along with the unborn-HEAD row. (#291)
+
 ## [3.22.0] — 2026-08-02
 
 ### Added

package/bin/reconcile.mjs

@@ -54,6 +54,7 @@ function parseArgs(args) {
         verifyPush: null,
         root: cwd(),
     };
+    let cwdProvided = false;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i] ?? "";
         if (arg === "--json")
@@ -63,6 +64,9 @@ function parseArgs(args) {
         else if (arg === "--explain")
             options.explain = true;
         else if (arg === "--verify-push") {
+            if (options.verifyPush !== null) {
+                throw new Error("--verify-push may only be provided once");
+            }
             const value = args[i + 1];
             if (value === undefined || value.startsWith("--")) {
                 throw new Error("--verify-push requires a branch name");
@@ -74,11 +78,15 @@ function parseArgs(args) {
             i++;
         }
         else if (arg === "--cwd") {
+            if (cwdProvided) {
+                throw new Error("--cwd may only be provided once");
+            }
             const value = args[i + 1];
-            if (value === undefined || value.startsWith("--")) {
+            if (value === undefined || value.startsWith("--") || value.trim().length === 0) {
                 throw new Error("--cwd requires a directory");
             }
             options.root = value;
+            cwdProvided = true;
             i++;
         }
         else if (arg === "--help" || arg === "-h") {
@@ -88,6 +96,14 @@ function parseArgs(args) {
             throw new Error(`unknown argument: ${arg}`);
         }
     }
+    const actions = [
+        options.snapshot ? "--snapshot" : null,
+        options.explain ? "--explain" : null,
+        options.verifyPush !== null ? "--verify-push" : null,
+    ].filter((action) => action !== null);
+    if (actions.length > 1) {
+        throw new Error(`mutually exclusive action modes: ${actions.join(", ")}`);
+    }
     return options;
 }
 /** Probe each in-progress marker through `--git-path`, which is worktree-correct. */
@@ -160,20 +176,35 @@ function main() {
     const status = git(["status", "--porcelain=v1"], options.root);
     const drift = git(["diff", "--name-only", "--ignore-all-space"], options.root);
     const dirty = accountDirty(status.code === 0 ? status.stdout : null, drift.code === 0 ? drift.stdout : null);
+    const inProgress = probeInProgress(options.root);
+    const baseFindings = assessGitState({
+        headCommit: headSha.code === 0 ? headSha.stdout.trim() : null,
+        head,
+        upstreamRef,
+        counts,
+        inProgress,
+        dirty,
+    });
     if (options.snapshot) {
-        // Field-compatible with scripts/git-state-snapshot.sh, plus `contentDrift`
-        // and `inProgress`, which the shell version cannot report.
+        // Field-compatible with scripts/git-state-snapshot.sh, plus `contentDrift`,
+        // `inProgress`, and a fail-closed blocker summary the shell version cannot
+        // report. An unborn HEAD is a git repo, but not a usable mutation baseline;
+        // do not emit an empty `head` field that looks like success.
         const upstreamSha = upstreamRef === null ? "none" : git(["rev-parse", "--short", "@{u}"], options.root).stdout.trim() || "none";
+        const shortHead = headSha.code === 0 ? git(["rev-parse", "--short", "HEAD"], options.root).stdout.trim() : "";
+        const blockers = baseFindings.filter((finding) => finding.severity === "blocker").map((finding) => finding.id);
         stdout.write(`${JSON.stringify({
-            head: git(["rev-parse", "--short", "HEAD"], options.root).stdout.trim(),
+            head: shortHead.length > 0 ? shortHead : "unborn",
             upstream: upstreamSha,
             dirty: dirty.reported,
             root: repoRoot,
             branch: head.branch ?? "detached",
             contentDrift: dirty.contentDrift,
-            inProgress: probeInProgress(options.root),
+            inProgress,
+            blocked: blockers.length > 0,
+            blockers,
         })}\n`);
-        exit(0);
+        exit(blockers.length > 0 ? 1 : 0);
         return;
     }
     if (options.verifyPush !== null) {
@@ -191,14 +222,7 @@ function main() {
         exit(verdict.verdict === "landed" ? 0 : 1);
         return;
     }
-    const inProgress = probeInProgress(options.root);
-    const findings = assessGitState({
-        head,
-        upstreamRef,
-        counts,
-        inProgress,
-        dirty,
-    });
+    const findings = [...baseFindings];
     const stashes = git(["stash", "list"], options.root);
     const stashCount = stashes.code === 0
         ? stashes.stdout.split(/\r?\n/).filter((line) => line.trim().length > 0).length

package/commands/reconcile.md

@@ -42,6 +42,9 @@ Four boundaries where the obvious command lies:
 - **Detached HEAD** — the `--show-current` form of `git branch` prints "" and exits 0, indistinguishable from success. `symbolic-ref --quiet` exits non-zero instead. Detached blocks.
 - **Linked worktree** — `.git` is a *file* there, so a `.git/`-relative marker probe exits 2 exactly as it does on a clean tree: a real conflicted merge reads as clean. Use `rev-parse --git-path`.
 - **autocrlf** — `git status` overstates drift. Stage by explicit filename, never `git add -A`.
+- **Unborn HEAD** — `git init` with no commit is a real repo with no usable baseline; `rev-parse HEAD` fails. Reported as `head: "unborn"` and blocked, never as an empty field that reads like success.
+
+`--snapshot` shares the exit contract (`0` clear / `1` blocked / `2` not a repo) and adds `contentDrift`, `inProgress`, `blocked`, `blockers` to the shell script's envelope. It still writes the JSON on a blocker, so tolerate exit 1 when capturing a baseline under `set -e`.
 
 ## Then act, with gates
 

package/lib/git-state.mjs

@@ -112,7 +112,8 @@ function isSha(value) {
  * comparison that authorizes a mutation.
  *
  * Fails closed: null, empty, surrounding whitespace, shell metacharacters,
- * `..`, refspec syntax (`@{`), a leading `-`, a trailing `/` or `.lock`, and
+ * `..`, refspec syntax (`@{`), a leading `-`, empty path components,
+ * dot-prefixed or dot-suffixed components, components ending `.lock`, and
  * anything over 255 characters all return false rather than being sanitized
  * into something that then looks valid.
  */
@@ -129,6 +130,13 @@ export function isSafeRefName(name) {
         return false;
     if (name.includes("..") || name.includes("@{"))
         return false;
+    const components = name.split("/");
+    if (components.some((component) => component.length === 0 ||
+        component.startsWith(".") ||
+        component.endsWith(".") ||
+        component.endsWith(".lock"))) {
+        return false;
+    }
     return SAFE_REF.test(name);
 }
 /**
@@ -154,8 +162,8 @@ export function classifyHead(rawBranch, exitCode = 0) {
  * Parse `git rev-list --left-right --count @{u}...HEAD` output, which is
  * `"<behind>\t<ahead>"`.
  *
- * Returns null for empty, malformed, negative, or non-integer output. Callers
- * must treat null as "unknown" — never as zero.
+ * Returns null for empty, malformed, negative, non-integer, or unsafe-integer
+ * output. Callers must treat null as "unknown" — never as zero.
  */
 export function parseRevListCounts(raw) {
     if (typeof raw !== "string")
@@ -168,9 +176,9 @@ export function parseRevListCounts(raw) {
         return null;
     const behind = Number(parts[0]);
     const ahead = Number(parts[1]);
-    if (!Number.isInteger(behind) || behind < 0)
+    if (!Number.isSafeInteger(behind) || behind < 0)
         return null;
-    if (!Number.isInteger(ahead) || ahead < 0)
+    if (!Number.isSafeInteger(ahead) || ahead < 0)
         return null;
     return { behind, ahead };
 }
@@ -312,6 +320,17 @@ export function baselineShifted(before, after) {
 export function assessGitState(input) {
     const findings = [];
     const protectedList = input.protectedBranches ?? DEFAULT_PROTECTED_BRANCHES;
+    if (Object.hasOwn(input, "headCommit")) {
+        const commit = (input.headCommit ?? "").trim();
+        findings.push({
+            id: "head-commit",
+            label: "HEAD commit",
+            detail: isSha(commit)
+                ? commit.slice(0, 12)
+                : "unborn or not a usable commit — create or verify the first commit before mutating",
+            severity: isSha(commit) ? "ok" : "blocker",
+        });
+    }
     if (input.head.kind === "branch") {
         const onProtected = isProtectedBranch(input.head.branch, protectedList);
         findings.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "continuous-improvement",
-  "version": "3.22.0",
+  "version": "3.22.1",
   "description": "Claude Code that gets sharper every session: the persistent-memory and runtime-discipline layer built on the 7 Laws of AI Agent Discipline. It grounds every edit in real facts before it lands and, through the Mulahazah engine, turns each fix into a reusable instinct, so a lesson learned once is applied automatically next time with no re-teaching. Shipped as 28 bundled skills, instinct-aware hooks, an MCP toolset for recall and reflection, and a GitHub Action transcript linter that feeds real work history back into sharper instincts. Beginner: one /plugin install command. Expert: adds MCP tools and session hooks.",
   "keywords": [
     "claude-code",

package/plugins/beginner.json

@@ -1,6 +1,6 @@
 {
   "name": "continuous-improvement",
-  "version": "3.22.0",
+  "version": "3.22.1",
   "mode": "beginner",
   "description": "Beginner mode: see what your agent learned, list its instincts, and request a session reflection. Bundles three grounding skills (gateguard, tdd-workflow, verification-loop) so research, memory, tests, and verification happen by default — every edit starts from facts, not guesses.",
   "tools": [

package/plugins/continuous-improvement/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "continuous-improvement",
       "description": "The persistent-memory and runtime-discipline layer for Claude Code. It remembers the corrections you already gave, grounds every edit in real facts before it lands, and — through the Mulahazah engine — turns each fix into a reusable instinct, so a lesson learned once is applied automatically next time with no re-teaching. Built on the 7 Laws of AI Agent Discipline (research, plan, verify, reflect, learn) and shipped as 28 bundled skills, instinct-aware hooks, an MCP toolset for recall and reflection, and a GitHub Action transcript linter that feeds real work history back into sharper instincts.",
-      "version": "3.22.0",
+      "version": "3.22.1",
       "source": "./",
       "author": {
         "name": "naimkatiman"

package/plugins/continuous-improvement/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "continuous-improvement",
-  "version": "3.22.0",
+  "version": "3.22.1",
   "description": "The persistent-memory and runtime-discipline layer for Claude Code. It remembers the corrections you already gave, grounds every edit in real facts before it lands, and — through the Mulahazah engine — turns each fix into a reusable instinct, so a lesson learned once is applied automatically next time with no re-teaching. Built on the 7 Laws of AI Agent Discipline (research, plan, verify, reflect, learn) and shipped as 28 bundled skills, instinct-aware hooks, an MCP toolset for recall and reflection, and a GitHub Action transcript linter that feeds real work history back into sharper instincts.",
   "author": {
     "name": "naimkatiman",

package/plugins/continuous-improvement/bin/reconcile.mjs

@@ -54,6 +54,7 @@ function parseArgs(args) {
         verifyPush: null,
         root: cwd(),
     };
+    let cwdProvided = false;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i] ?? "";
         if (arg === "--json")
@@ -63,6 +64,9 @@ function parseArgs(args) {
         else if (arg === "--explain")
             options.explain = true;
         else if (arg === "--verify-push") {
+            if (options.verifyPush !== null) {
+                throw new Error("--verify-push may only be provided once");
+            }
             const value = args[i + 1];
             if (value === undefined || value.startsWith("--")) {
                 throw new Error("--verify-push requires a branch name");
@@ -74,11 +78,15 @@ function parseArgs(args) {
             i++;
         }
         else if (arg === "--cwd") {
+            if (cwdProvided) {
+                throw new Error("--cwd may only be provided once");
+            }
             const value = args[i + 1];
-            if (value === undefined || value.startsWith("--")) {
+            if (value === undefined || value.startsWith("--") || value.trim().length === 0) {
                 throw new Error("--cwd requires a directory");
             }
             options.root = value;
+            cwdProvided = true;
             i++;
         }
         else if (arg === "--help" || arg === "-h") {
@@ -88,6 +96,14 @@ function parseArgs(args) {
             throw new Error(`unknown argument: ${arg}`);
         }
     }
+    const actions = [
+        options.snapshot ? "--snapshot" : null,
+        options.explain ? "--explain" : null,
+        options.verifyPush !== null ? "--verify-push" : null,
+    ].filter((action) => action !== null);
+    if (actions.length > 1) {
+        throw new Error(`mutually exclusive action modes: ${actions.join(", ")}`);
+    }
     return options;
 }
 /** Probe each in-progress marker through `--git-path`, which is worktree-correct. */
@@ -160,20 +176,35 @@ function main() {
     const status = git(["status", "--porcelain=v1"], options.root);
     const drift = git(["diff", "--name-only", "--ignore-all-space"], options.root);
     const dirty = accountDirty(status.code === 0 ? status.stdout : null, drift.code === 0 ? drift.stdout : null);
+    const inProgress = probeInProgress(options.root);
+    const baseFindings = assessGitState({
+        headCommit: headSha.code === 0 ? headSha.stdout.trim() : null,
+        head,
+        upstreamRef,
+        counts,
+        inProgress,
+        dirty,
+    });
     if (options.snapshot) {
-        // Field-compatible with scripts/git-state-snapshot.sh, plus `contentDrift`
-        // and `inProgress`, which the shell version cannot report.
+        // Field-compatible with scripts/git-state-snapshot.sh, plus `contentDrift`,
+        // `inProgress`, and a fail-closed blocker summary the shell version cannot
+        // report. An unborn HEAD is a git repo, but not a usable mutation baseline;
+        // do not emit an empty `head` field that looks like success.
         const upstreamSha = upstreamRef === null ? "none" : git(["rev-parse", "--short", "@{u}"], options.root).stdout.trim() || "none";
+        const shortHead = headSha.code === 0 ? git(["rev-parse", "--short", "HEAD"], options.root).stdout.trim() : "";
+        const blockers = baseFindings.filter((finding) => finding.severity === "blocker").map((finding) => finding.id);
         stdout.write(`${JSON.stringify({
-            head: git(["rev-parse", "--short", "HEAD"], options.root).stdout.trim(),
+            head: shortHead.length > 0 ? shortHead : "unborn",
             upstream: upstreamSha,
             dirty: dirty.reported,
             root: repoRoot,
             branch: head.branch ?? "detached",
             contentDrift: dirty.contentDrift,
-            inProgress: probeInProgress(options.root),
+            inProgress,
+            blocked: blockers.length > 0,
+            blockers,
         })}\n`);
-        exit(0);
+        exit(blockers.length > 0 ? 1 : 0);
         return;
     }
     if (options.verifyPush !== null) {
@@ -191,14 +222,7 @@ function main() {
         exit(verdict.verdict === "landed" ? 0 : 1);
         return;
     }
-    const inProgress = probeInProgress(options.root);
-    const findings = assessGitState({
-        head,
-        upstreamRef,
-        counts,
-        inProgress,
-        dirty,
-    });
+    const findings = [...baseFindings];
     const stashes = git(["stash", "list"], options.root);
     const stashCount = stashes.code === 0
         ? stashes.stdout.split(/\r?\n/).filter((line) => line.trim().length > 0).length

package/plugins/continuous-improvement/commands/reconcile.md

@@ -42,6 +42,9 @@ Four boundaries where the obvious command lies:
 - **Detached HEAD** — the `--show-current` form of `git branch` prints "" and exits 0, indistinguishable from success. `symbolic-ref --quiet` exits non-zero instead. Detached blocks.
 - **Linked worktree** — `.git` is a *file* there, so a `.git/`-relative marker probe exits 2 exactly as it does on a clean tree: a real conflicted merge reads as clean. Use `rev-parse --git-path`.
 - **autocrlf** — `git status` overstates drift. Stage by explicit filename, never `git add -A`.
+- **Unborn HEAD** — `git init` with no commit is a real repo with no usable baseline; `rev-parse HEAD` fails. Reported as `head: "unborn"` and blocked, never as an empty field that reads like success.
+
+`--snapshot` shares the exit contract (`0` clear / `1` blocked / `2` not a repo) and adds `contentDrift`, `inProgress`, `blocked`, `blockers` to the shell script's envelope. It still writes the JSON on a blocker, so tolerate exit 1 when capturing a baseline under `set -e`.
 
 ## Then act, with gates
 

package/plugins/continuous-improvement/lib/git-state.mjs

@@ -112,7 +112,8 @@ function isSha(value) {
  * comparison that authorizes a mutation.
  *
  * Fails closed: null, empty, surrounding whitespace, shell metacharacters,
- * `..`, refspec syntax (`@{`), a leading `-`, a trailing `/` or `.lock`, and
+ * `..`, refspec syntax (`@{`), a leading `-`, empty path components,
+ * dot-prefixed or dot-suffixed components, components ending `.lock`, and
  * anything over 255 characters all return false rather than being sanitized
  * into something that then looks valid.
  */
@@ -129,6 +130,13 @@ export function isSafeRefName(name) {
         return false;
     if (name.includes("..") || name.includes("@{"))
         return false;
+    const components = name.split("/");
+    if (components.some((component) => component.length === 0 ||
+        component.startsWith(".") ||
+        component.endsWith(".") ||
+        component.endsWith(".lock"))) {
+        return false;
+    }
     return SAFE_REF.test(name);
 }
 /**
@@ -154,8 +162,8 @@ export function classifyHead(rawBranch, exitCode = 0) {
  * Parse `git rev-list --left-right --count @{u}...HEAD` output, which is
  * `"<behind>\t<ahead>"`.
  *
- * Returns null for empty, malformed, negative, or non-integer output. Callers
- * must treat null as "unknown" — never as zero.
+ * Returns null for empty, malformed, negative, non-integer, or unsafe-integer
+ * output. Callers must treat null as "unknown" — never as zero.
  */
 export function parseRevListCounts(raw) {
     if (typeof raw !== "string")
@@ -168,9 +176,9 @@ export function parseRevListCounts(raw) {
         return null;
     const behind = Number(parts[0]);
     const ahead = Number(parts[1]);
-    if (!Number.isInteger(behind) || behind < 0)
+    if (!Number.isSafeInteger(behind) || behind < 0)
         return null;
-    if (!Number.isInteger(ahead) || ahead < 0)
+    if (!Number.isSafeInteger(ahead) || ahead < 0)
         return null;
     return { behind, ahead };
 }
@@ -312,6 +320,17 @@ export function baselineShifted(before, after) {
 export function assessGitState(input) {
     const findings = [];
     const protectedList = input.protectedBranches ?? DEFAULT_PROTECTED_BRANCHES;
+    if (Object.hasOwn(input, "headCommit")) {
+        const commit = (input.headCommit ?? "").trim();
+        findings.push({
+            id: "head-commit",
+            label: "HEAD commit",
+            detail: isSha(commit)
+                ? commit.slice(0, 12)
+                : "unborn or not a usable commit — create or verify the first commit before mutating",
+            severity: isSha(commit) ? "ok" : "blocker",
+        });
+    }
     if (input.head.kind === "branch") {
         const onProtected = isProtectedBranch(input.head.branch, protectedList);
         findings.push({

package/plugins/continuous-improvement/skills/reconcile/SKILL.md

@@ -62,7 +62,11 @@ The ground-truth pass has to work wherever the agent runs, not only in Bash. `ci
 | `scripts/git-state-snapshot.sh` | needs Git Bash | yes | yes | root/branch only | reports `detached` | reports `none` |
 | Hand-run probe list above | yes | yes | yes | correct | non-zero exit | non-zero exit |
 
-Smoke-test on the OS you actually ship on. Both surfaces emit the same `{head, upstream, dirty, root, branch}` envelope — `ci-reconcile --snapshot` adds `contentDrift` and `inProgress` — and a test pins that parity so the two cannot drift apart silently.
+Smoke-test on the OS you actually ship on. Both surfaces emit the same `{head, upstream, dirty, root, branch}` envelope — `ci-reconcile --snapshot` adds `contentDrift`, `inProgress`, `blocked` and `blockers` — and a test pins that parity so the two cannot drift apart silently.
+
+`--snapshot` follows the same exit-code contract as the default mode: `0` clear, `1` at least one blocker, `2` not a git repository. It still writes the envelope on a blocker, so a script that wants the JSON regardless must tolerate exit 1 (`set -e` will otherwise abort on a detached HEAD or an unborn repo).
+
+An **unborn HEAD** — `git init` with no commit yet — is a real git repository with no usable baseline. `git rev-parse HEAD` fails there, so the shell script reports `not-a-git-repo` and the envelope's `head` field would otherwise be empty in a way that reads like success. `ci-reconcile` reports `head: "unborn"` with `blocked: true` and blocks the mutation instead.
 
 ## Detect a Concurrent Writer
 
@@ -75,7 +79,7 @@ When another session/loop may be active, do not assume the tree is yours:
   # ... do work ...
   npx ci-reconcile --snapshot                                   # compare head + branch against the baseline
   ```
-  If either field moved, another writer got there first — re-survey from the top instead of committing onto an unexpected base. A missing or unparseable field counts as *shifted*; "we could not tell" is never "nothing moved".
+  If either field moved, another writer got there first — re-survey from the top instead of committing onto an unexpected base. A missing or unparseable field counts as *shifted*; "we could not tell" is never "nothing moved". Both calls exit 1 if the tree is blocked, so capture the baseline without `set -e` (or guard it) when a blocker is expected.
 - More than one entry in `git worktree list --porcelain` means a sibling checkout exists that another session may be writing to. The runner flags this.
 - If the 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 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. That shell snapshot needs Git Bash and derives its `dirty` count from `git status`, which overstates drift on an `autocrlf` tree; `ci-reconcile --snapshot` is the same envelope without either limitation. Without gateguard, run one of them yourself.

package/plugins/expert.json

@@ -1,6 +1,6 @@
 {
   "name": "continuous-improvement",
-  "version": "3.22.0",
+  "version": "3.22.1",
   "mode": "expert",
   "description": "Expert mode: tune confidence, manage instincts, and persist plans on disk. Adds safety, token-budget, and strategic-compact skills plus the /learn-eval command so long sessions stay sharp and learnings survive context resets.",
   "tools": [

package/skills/reconcile.md

@@ -62,7 +62,11 @@ The ground-truth pass has to work wherever the agent runs, not only in Bash. `ci
 | `scripts/git-state-snapshot.sh` | needs Git Bash | yes | yes | root/branch only | reports `detached` | reports `none` |
 | Hand-run probe list above | yes | yes | yes | correct | non-zero exit | non-zero exit |
 
-Smoke-test on the OS you actually ship on. Both surfaces emit the same `{head, upstream, dirty, root, branch}` envelope — `ci-reconcile --snapshot` adds `contentDrift` and `inProgress` — and a test pins that parity so the two cannot drift apart silently.
+Smoke-test on the OS you actually ship on. Both surfaces emit the same `{head, upstream, dirty, root, branch}` envelope — `ci-reconcile --snapshot` adds `contentDrift`, `inProgress`, `blocked` and `blockers` — and a test pins that parity so the two cannot drift apart silently.
+
+`--snapshot` follows the same exit-code contract as the default mode: `0` clear, `1` at least one blocker, `2` not a git repository. It still writes the envelope on a blocker, so a script that wants the JSON regardless must tolerate exit 1 (`set -e` will otherwise abort on a detached HEAD or an unborn repo).
+
+An **unborn HEAD** — `git init` with no commit yet — is a real git repository with no usable baseline. `git rev-parse HEAD` fails there, so the shell script reports `not-a-git-repo` and the envelope's `head` field would otherwise be empty in a way that reads like success. `ci-reconcile` reports `head: "unborn"` with `blocked: true` and blocks the mutation instead.
 
 ## Detect a Concurrent Writer
 
@@ -75,7 +79,7 @@ When another session/loop may be active, do not assume the tree is yours:
   # ... do work ...
   npx ci-reconcile --snapshot                                   # compare head + branch against the baseline
   ```
-  If either field moved, another writer got there first — re-survey from the top instead of committing onto an unexpected base. A missing or unparseable field counts as *shifted*; "we could not tell" is never "nothing moved".
+  If either field moved, another writer got there first — re-survey from the top instead of committing onto an unexpected base. A missing or unparseable field counts as *shifted*; "we could not tell" is never "nothing moved". Both calls exit 1 if the tree is blocked, so capture the baseline without `set -e` (or guard it) when a blocker is expected.
 - More than one entry in `git worktree list --porcelain` means a sibling checkout exists that another session may be writing to. The runner flags this.
 - If the 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 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. That shell snapshot needs Git Bash and derives its `dirty` count from `git status`, which overstates drift on an `autocrlf` tree; `ci-reconcile --snapshot` is the same envelope without either limitation. Without gateguard, run one of them yourself.