pi-gauntlet 5.10.2 → 5.11.0

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## v5.11.0 - 2026-09-18
+
+- `checkoutOf` falls back to `jj root` when `git rev-parse` fails, so `plan_check`, Guard 2, and telemetry resolve the checkout inside a plain (non-colocated) jj workspace; colocated jj repos still resolve through git first. The settings loader goes through the same resolution via a new sync `checkoutOfSync`, and telemetry records bound to a jj workspace carry a one-time `record written, not committed: not a git checkout` warning instead of a failed `git commit` per checkpoint. (#38)
+
 ## v5.10.2 - 2026-09-18
 
 - The telemetry record is a deliverable: brainstorming, `finishing-a-development-branch`, and `gatekeep-pr` name it beside the spec, and a new shipped `gauntlet-telemetry-salvage` bin restores a record that a plan strip or a fix commit deleted (from the deleting commit's parent, as one `telemetry: ` commit, exit 0 for valid invocations, never pushes). Finishing strips the plan on the feature branch before the Option 1 squash; gatekeep-pr checks at assessment, restores after each fix wave, and restores as the first step of a merge course. CI pins the bin, its test, its tarball imports, and the rule's presence in the three skills.

package/README.md

@@ -75,7 +75,7 @@ pi-gauntlet ships three kinds of pieces, layered on top of pi-cohort's dispatch:
 
 pi-gauntlet is **opinionated**: every non-trivial change is *meant* to ride this one pipeline, entered through `brainstorming`. Enforcement is opt-in by entry, not ambient: once brainstorming starts a flow, the phase-tracker extension mechanically blocks a phase from closing before its gate runs, and warns once if the main loop writes code during implement (subagents own implement-phase edits). A change made *without* entering the flow (a typo, a formatting run, a dependency bump - see "When to use / when NOT to use") is not gated; the discipline of routing real work through the pipeline is a convention the tooling supports, not a trap it springs on every edit.
 
-**Worktree contract.** pi runs in the primary checkout; the work happens in `.worktrees/<branch>`. Skills never `cd` there - the worktree path is a value from the `using-git-worktrees` report (or the handoff brief on `gauntlet-resume`), carried as dispatch `cwd: "<path>"`, as `git -C <path>`, or as `(cd "<path>" && <cmd>)` for other cwd-bound commands; the runtime extensions derive the checkout from the artifact path they act on. Requires git >= 2.31.
+**Worktree contract.** pi runs in the primary checkout; the work happens in `.worktrees/<branch>`. Skills never `cd` there - the worktree path is a value from the `using-git-worktrees` report (or the handoff brief on `gauntlet-resume`), carried as dispatch `cwd: "<path>"`, as `git -C <path>`, or as `(cd "<path>" && <cmd>)` for other cwd-bound commands; the runtime extensions derive the checkout from the artifact path they act on. Requires git >= 2.31; a plain (non-colocated) jj workspace has no `.git`, so the resolver falls back to `jj root` there, reading primary-vs-workspace from `.jj/repo` (a directory in the primary checkout, a pointer file in added workspaces).
 
 ## Key concepts
 

package/extensions/lib/checkout.test.ts

@@ -3,7 +3,7 @@ import { after, test } from "node:test";
 import { mkdtempSync, mkdirSync, rmSync, writeFileSync, realpathSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { checkoutOf, parseCheckout, gitSync, type GitResult } from "./checkout.ts";
+import { checkoutOf, checkoutOfSync, parseCheckout, gitSync, jjSync, type GitResult } from "./checkout.ts";
 
 const tempDirs: string[] = [];
 after(() => { for (const d of tempDirs) rmSync(d, { recursive: true, force: true }); });
@@ -32,7 +32,7 @@ test("checkoutOf: a file path runs git in its dirname", async () => {
   writeFileSync(join(dir, "spec.md"), "# s\n");
   const cwds: string[] = [];
   const git = (_args: string[], cwd: string): GitResult => { cwds.push(cwd); return out([dir, dir + "/.git", dir + "/.git"]); };
-  assert.deepEqual(await checkoutOf(join(dir, "spec.md"), git), { toplevel: dir, isPrimary: true });
+  assert.deepEqual(await checkoutOf(join(dir, "spec.md"), git), { toplevel: dir, isPrimary: true, via: "git" });
   assert.deepEqual(cwds, [dir]);
 });
 
@@ -57,3 +57,66 @@ test("gitSync: never throws; nonzero code outside a repo", () => {
   assert.notEqual(r.code, 0);
   assert.equal(typeof r.stdout, "string");
 });
+
+test("checkoutOf: falls back to `jj root` when git fails, added workspace is not primary", async () => {
+  const dir = tmp();
+  mkdirSync(join(dir, ".jj"));
+  writeFileSync(join(dir, ".jj", "repo"), "/main/repo/.jj/repo\n"); // pointer file in added workspaces
+  const git = (): GitResult => ({ code: 128, stdout: "" });
+  const jj = (args: string[], cwd: string): GitResult => {
+    assert.deepEqual(args, ["root"]);
+    assert.equal(cwd, dir);
+    return { code: 0, stdout: dir + "\n" };
+  };
+  assert.deepEqual(await checkoutOf(join(dir, "doc", "plan.md"), git, jj), { toplevel: dir, isPrimary: false, via: "jj" });
+});
+
+test("checkoutOf: jj primary checkout keeps .jj/repo as a directory", async () => {
+  const dir = tmp();
+  mkdirSync(join(dir, ".jj", "repo"), { recursive: true });
+  const git = (): GitResult => ({ code: 128, stdout: "" });
+  const jj = (): GitResult => ({ code: 0, stdout: dir + "\n" });
+  assert.deepEqual(await checkoutOf(dir, git, jj), { toplevel: dir, isPrimary: true, via: "jj" });
+});
+
+test("checkoutOf: git result wins when it resolves, jj is not consulted", async () => {
+  const dir = tmp();
+  let jjCalled = false;
+  const git = (): GitResult => out([dir, dir + "/.git", dir + "/.git"]);
+  const jj = (): GitResult => { jjCalled = true; return { code: 0, stdout: "/elsewhere\n" }; };
+  assert.deepEqual(await checkoutOf(dir, git, jj), { toplevel: dir, isPrimary: true, via: "git" });
+  assert.equal(jjCalled, false);
+});
+
+test("checkoutOf: undefined when neither git nor jj resolves", async () => {
+  const fail = (): GitResult => ({ code: 1, stdout: "" });
+  assert.equal(await checkoutOf(join(tmp(), "x.md"), fail, fail), undefined);
+});
+
+test("jjSync: never throws; nonzero code outside a jj repo", () => {
+  const r = jjSync(["root"], tmp());
+  assert.notEqual(r.code, 0);
+  assert.equal(typeof r.stdout, "string");
+});
+
+test("checkoutOfSync: git wins without consulting jj", () => {
+  const dir = tmp();
+  let jjCalled = false;
+  const git = (): GitResult => out([dir, dir + "/.git", dir + "/.git"]);
+  const jj = (): GitResult => { jjCalled = true; return { code: 0, stdout: "/elsewhere\n" }; };
+  assert.deepEqual(checkoutOfSync(dir, git, jj), { toplevel: dir, isPrimary: true, via: "git" });
+  assert.equal(jjCalled, false);
+});
+
+test("checkoutOfSync: falls back to `jj root` when git fails", () => {
+  const dir = tmp();
+  mkdirSync(join(dir, ".jj", "repo"), { recursive: true });
+  const git = (): GitResult => ({ code: 128, stdout: "" });
+  const jj = (): GitResult => ({ code: 0, stdout: dir + "\n" });
+  assert.deepEqual(checkoutOfSync(join(dir, "doc", "specs"), git, jj), { toplevel: dir, isPrimary: true, via: "jj" });
+});
+
+test("checkoutOfSync: undefined when neither git nor jj resolves", () => {
+  const fail = (): GitResult => ({ code: 1, stdout: "" });
+  assert.equal(checkoutOfSync(join(tmp(), "x.md"), fail, fail), undefined);
+});

package/extensions/lib/checkout.ts

@@ -1,17 +1,23 @@
 // One checkout resolver for every extension that needs "which git checkout owns this
 // path" (#37): plan_check, the settings loader, Guard 2, telemetry. `--path-format=absolute`
 // (git >= 2.31) makes git-dir and common-dir comparable as strings from any subdirectory.
+// A plain (non-colocated) jj checkout has no .git for rev-parse, so when git fails the
+// resolver falls back to `jj root`; colocated jj repos still resolve through git first.
+// checkoutOfSync is the same resolution for sync callers (the settings loader).
 import { execFileSync } from "node:child_process";
 import { existsSync, statSync } from "node:fs";
-import { dirname } from "node:path";
+import { dirname, join } from "node:path";
 
 export type GitResult = { code: number; stdout: string };
-export type Checkout = { toplevel: string; isPrimary: boolean };
+// `via` records which binary resolved the checkout, so callers with git-only follow-ups
+// (telemetry's checkpoint commit) can skip them in a plain jj workspace.
+export type Checkout = { toplevel: string; isPrimary: boolean; via: "git" | "jj" };
+type ResolvedCheckout = { toplevel: string; isPrimary: boolean };
 
 export const CHECKOUT_ARGS = ["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-dir", "--git-common-dir"];
 
 // isPrimary = gitDir === commonDir (both absolute thanks to --path-format).
-export function parseCheckout(r: GitResult): Checkout | undefined {
+export function parseCheckout(r: GitResult): ResolvedCheckout | undefined {
   if (r.code !== 0) return undefined;
   const lines = r.stdout.trim().split("\n").map((l) => l.trim());
   if (lines.length < 3 || !lines[0]) return undefined;
@@ -38,20 +44,54 @@ export function nearestExistingDir(absPath: string): string {
   return p;
 }
 
+export const JJ_ROOT_ARGS = ["root"];
+
+// Added jj workspaces keep .jj/repo as a pointer file into the main repo; the primary
+// checkout keeps it as the real directory.
+function parseJjRoot(r: GitResult): ResolvedCheckout | undefined {
+  if (r.code !== 0) return undefined;
+  const toplevel = r.stdout.trim();
+  if (!toplevel) return undefined;
+  return { toplevel, isPrimary: isDir(join(toplevel, ".jj", "repo")) };
+}
+
 export async function checkoutOf(
   absPath: string,
   git: (args: string[], cwd: string) => GitResult | Promise<GitResult>,
+  jj: (args: string[], cwd: string) => GitResult | Promise<GitResult> = jjSync,
 ): Promise<Checkout | undefined> {
-  return parseCheckout(await git(CHECKOUT_ARGS, nearestExistingDir(absPath)));
+  const cwd = nearestExistingDir(absPath);
+  const g = parseCheckout(await git(CHECKOUT_ARGS, cwd));
+  if (g) return { ...g, via: "git" };
+  const j = parseJjRoot(await jj(JJ_ROOT_ARGS, cwd));
+  return j ? { ...j, via: "jj" } : undefined;
 }
 
-// Never throws: any failure (not a repo, missing dir, old git) is a nonzero code.
-export const gitSync = (args: string[], cwd: string): GitResult => {
-  try {
-    const stdout = execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 });
-    return { code: 0, stdout };
-  } catch (e) {
-    const status = (e as { status?: unknown }).status;
-    return { code: typeof status === "number" ? status : 1, stdout: "" };
-  }
-};
+// Same git-then-jj resolution for sync callers; either side injectable for tests.
+export function checkoutOfSync(
+  absPath: string,
+  git: (args: string[], cwd: string) => GitResult = gitSync,
+  jj: (args: string[], cwd: string) => GitResult = jjSync,
+): Checkout | undefined {
+  const cwd = nearestExistingDir(absPath);
+  const g = parseCheckout(git(CHECKOUT_ARGS, cwd));
+  if (g) return { ...g, via: "git" };
+  const j = parseJjRoot(jj(JJ_ROOT_ARGS, cwd));
+  return j ? { ...j, via: "jj" } : undefined;
+}
+
+// Never throws: any failure (not a repo, missing dir, missing binary) is a nonzero code.
+const commandSync =
+  (bin: string) =>
+  (args: string[], cwd: string): GitResult => {
+    try {
+      const stdout = execFileSync(bin, args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 });
+      return { code: 0, stdout };
+    } catch (e) {
+      const status = (e as { status?: unknown }).status;
+      return { code: typeof status === "number" ? status : 1, stdout: "" };
+    }
+  };
+
+export const gitSync = commandSync("git");
+export const jjSync = commandSync("jj");

package/extensions/lib/gauntlet-settings-loader.test.ts

@@ -30,3 +30,16 @@ test("outside any checkout the loader falls back to cwd", () => {
   assert.equal(loaded.root, dir);
   assert.deepEqual(loaded.gauntlet.flowGuards, { enforce: false });
 });
+
+test("settings resolve through the jj fallback in a plain jj workspace (no .git)", () => {
+  const dir = tmp();
+  mkdirSync(join(dir, ".jj", "repo"), { recursive: true }); // primary jj checkout marker
+  mkdirSync(join(dir, ".pi"));
+  mkdirSync(join(dir, "doc"));
+  writeFileSync(join(dir, ".pi", "settings.json"), JSON.stringify({ piGauntlet: { specCouncil: { members: ["p/jj"] } } }));
+  const jjCheckout = () => ({ toplevel: dir, isPrimary: true, via: "jj" as const });
+  const loaded = loadGauntletSettings(join(dir, "doc"), "/tmp/pi-gauntlet-test-agent", jjCheckout);
+  assert.equal(loaded.root, dir);
+  assert.deepEqual(loaded.gauntlet.specCouncil, { members: ["p/jj"] });
+  assert.deepEqual(loaded.errors, []);
+});

package/extensions/lib/gauntlet-settings-loader.ts

@@ -2,7 +2,7 @@
 // ci.mjs unit tests. Only pi-loaded extensions import this file.
 import { SettingsManager, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { mergeGauntlet, type PiGauntlet } from "./gauntlet-settings.ts";
-import { gitSync, parseCheckout } from "./checkout.ts";
+import { checkoutOfSync, type Checkout } from "./checkout.ts";
 
 export interface LoadedGauntlet {
   gauntlet: PiGauntlet;
@@ -12,12 +12,13 @@ export interface LoadedGauntlet {
 }
 
 // Reads the preset (agentDir/settings.json) and repo (<root>/.pi/settings.json) layers
-// via pi's own SettingsManager, where <root> is the git toplevel of cwd - pi launched in a
-// subdirectory or a linked worktree still finds that checkout's file (#37). SettingsManager
+// via pi's own SettingsManager, where <root> is the checkout toplevel of cwd (git, falling
+// back to `jj root` in a plain jj workspace) - pi launched in a subdirectory or a linked
+// worktree still finds that checkout's file (#37). SettingsManager
 // never throws on a bad file - it substitutes {} for that layer and records the error,
 // surfaced here via errors[] so callers can report a degraded read instead of failing silent.
-export function loadGauntletSettings(cwd: string, agentDir: string = getAgentDir()): LoadedGauntlet {
-  const root = parseCheckout(gitSync(["rev-parse", "--path-format=absolute", "--show-toplevel", "--git-dir", "--git-common-dir"], cwd))?.toplevel ?? cwd;
+export function loadGauntletSettings(cwd: string, agentDir: string = getAgentDir(), checkout: (path: string) => Checkout | undefined = checkoutOfSync): LoadedGauntlet {
+  const root = checkout(cwd)?.toplevel ?? cwd;
   const sm = SettingsManager.create(root, agentDir);
   const preset = sm.getGlobalSettings() as { piGauntlet?: Record<string, unknown> };
   const repo = sm.getProjectSettings() as { piGauntlet?: Record<string, unknown> };

package/extensions/telemetry.test.ts

@@ -20,7 +20,7 @@
 
   type Handler = (event: any, ctx: any) => unknown;
 
-  function harness(o: { branch?: unknown[]; enabled?: boolean; gitFail?: (args: string[], cwd: string) => GitResult | undefined; cwdSub?: string; sessionId?: string; model?: { provider: string; id: string }; thinkingLevel?: string; contextTokens?: number | null; telemetryWarning?: string; telemetryDir?: string } = {}) {
+  function harness(o: { branch?: unknown[]; enabled?: boolean; gitFail?: (args: string[], cwd: string) => GitResult | undefined; jjWorkspace?: boolean; cwdSub?: string; sessionId?: string; model?: { provider: string; id: string }; thinkingLevel?: string; contextTokens?: number | null; telemetryWarning?: string; telemetryDir?: string } = {}) {
     const root = mkdtempSync(join(tmpdir(), "telemetry-test-"));
     tempDirs.push(root);
     mkdirSync(join(root, "doc/specs"), { recursive: true });
@@ -52,6 +52,8 @@
         return { code: 0, stdout: "", stderr: "" };
       },
       settings: () => ({ telemetry: { enabled: o.enabled ?? true, dir: o.telemetryDir ?? ".pi/gauntlet/telemetry", buckets: DEFAULT_TELEMETRY_BUCKETS, warning: o.telemetryWarning }, errors: [], agentOverrides: { implementer: { model: "p/x" } }, versions: { pi: "0.85.1" } }),
+      // A plain jj workspace: `jj root` answers the temp root while git rev-parse fails.
+      ...(o.jjWorkspace ? { jj: async () => ({ code: 0, stdout: root + "\n", stderr: "" }) } : {}),
     };
     let branch = o.branch ?? [];
     const ctx = {
@@ -281,6 +283,25 @@
     assert.deepEqual(nogit.readRecord().events.filter((e) => e.kind === "warning").map((e: any) => e.message), [`spec ${outsideSpec} is outside a git checkout; telemetry not recorded`]);
   });
 
+  test("jj-bound checkout: record is written, never committed, and the warning fires once", async () => {
+    const h = harness({
+      jjWorkspace: true,
+      gitFail: (args) =>
+        args[0] === "rev-parse" && args.includes("--path-format=absolute")
+          ? { code: 128, stdout: "", stderr: "fatal: not a git repository" }
+          : undefined,
+    });
+    await h.phaseResult("start", P({ brainstorm: "in_progress" }));
+    await h.writeSpec("doc/specs/a.md");
+    await h.phaseResult("complete", P({ brainstorm: "complete" }));
+    const rec = h.readRecord();
+    assert.deepEqual(
+      rec.events.filter((e) => e.kind === "warning").map((e: any) => e.message),
+      ["record written, not committed: not a git checkout"],
+    );
+    assert.equal(h.commits().length, 0);
+  });
+
   test("worktree spec from a primary cwd: record keyed under the worktree, committed there (AC 8)", async () => {
     const h = harness();
     await h.emit("session_start", { type: "session_start", reason: "startup" });

package/extensions/telemetry.ts

@@ -48,6 +48,8 @@
   export interface Deps {
     fs: FsPort;
     git: (args: string[], cwd: string) => Promise<GitResult>;
+    // Optional jj override for tests; production resolves plain jj workspaces via jjSync.
+    jj?: (args: string[], cwd: string) => GitResult | Promise<GitResult>;
     now: () => string;
     settings: (cwd: string) => SettingsSnapshot;
   }
@@ -160,6 +162,7 @@
   export default function (pi: ExtensionAPI, deps: Deps = realDeps) {
     let phases: PhaseMap = emptyPhases();
     let toplevel: string | undefined; // toplevel of the bound record's checkout; undefined until bind
+    let checkoutVia: "git" | "jj" | undefined; // which binary resolved toplevel; undefined until bind
     let boundSpec: string | undefined; // repo-relative
     let record: TelemetryRecord | undefined;
     const predecessorLinks = new Set<string>();
@@ -170,6 +173,7 @@
     let lastCommitted = "";
     let frozen = false;
     let settingsWarned = false;
+    let notGitWarned = false;
     let sessionId = "";
 
     // Per-event settings read; undefined => this event is a no-op.
@@ -182,11 +186,11 @@
 
     // Resolves a tool path (relative to ctx.cwd or absolute) to its owning checkout and
     // checkout-relative key. undefined outside any checkout.
-    const locate = async (ctx: ExtensionContext, p: string): Promise<{ toplevel: string; rel: string } | undefined> => {
+    const locate = async (ctx: ExtensionContext, p: string): Promise<{ toplevel: string; rel: string; via: "git" | "jj" } | undefined> => {
       const candidateAbs = isAbsolute(p) ? p : resolve(ctx.cwd, p);
-      const co = await checkoutOf(candidateAbs, deps.git);
+      const co = await checkoutOf(candidateAbs, deps.git, deps.jj);
       const rel = co ? repoRelativeToolPath(co.toplevel, ctx.cwd, p) : undefined;
-      return co && rel ? { toplevel: co.toplevel, rel } : undefined;
+      return co && rel ? { toplevel: co.toplevel, rel, via: co.via } : undefined;
     };
 
     const live = (): Accumulators => record
@@ -230,6 +234,15 @@
 
     const commitRecord = async () => {
       if (!record || !recordRel || frozen || !toplevel) return;
+      if (checkoutVia === "jj") {
+        // A jj-bound checkout has no .git to commit into; say so once per session instead
+        // of failing `git commit` at every checkpoint.
+        if (!notGitWarned) {
+          notGitWarned = true;
+          warn("record written, not committed: not a git checkout");
+        }
+        return;
+      }
       const text = deps.fs.readFile(abs(recordRel)) ?? "";
       if (text === lastCommitted) return;
       const paths = [recordRel, ...(oldRecordRel ? [oldRecordRel] : [])];
@@ -274,8 +287,9 @@
       return newRecord({ spec: specRel, session: sessionId, now: buffer[0]?.ts ?? deps.now(), runId: randomUUID() });
     };
 
-    const bind = async (specRel: string, snap: SettingsSnapshot, specToplevel: string) => {
+    const bind = async (specRel: string, snap: SettingsSnapshot, specToplevel: string, via: "git" | "jj") => {
       toplevel = specToplevel;
+      checkoutVia = via;
       currentDir = snap.telemetry.dir;
       boundSpec = specRel;
       recordRel = recordPathFor(currentDir, specRel);
@@ -314,6 +328,7 @@
 
     const unbind = () => {
       toplevel = undefined;
+      checkoutVia = undefined;
       boundSpec = undefined;
       record = undefined;
       recordRel = undefined;
@@ -416,7 +431,7 @@
       const candidate = replay.planCheckSpec ?? replay.lastSpecWrite;
       const loc = candidate ? await locate(ctx, candidate) : undefined;
       if (loc && isSpecPath(loc.rel)) {
-        await bind(loc.rel, snap, loc.toplevel);
+        await bind(loc.rel, snap, loc.toplevel, loc.via);
         await flush(false);
       }
     });
@@ -450,7 +465,7 @@
         const pass = d?.status === "pass";
         if (pass && specLoc && (specLoc.rel !== boundSpec || specLoc.toplevel !== toplevel)) {
           if (record) unbind();
-          await bind(specLoc.rel, snap, specLoc.toplevel);
+          await bind(specLoc.rel, snap, specLoc.toplevel, specLoc.via);
         }
         live().gates.plan_rounds += 1;
         pushEvent({ kind: "plan_check", pass, spec, plan });
@@ -498,11 +513,11 @@
     });
 
     // Binding + spec-write bookkeeping; the bound-spec hooks are defined in block 2.
-    const onSpecInteraction = async (tool: "write" | "edit" | "read", loc: { toplevel: string; rel: string }, event: { input: unknown; content: unknown[] }, snap: SettingsSnapshot): Promise<unknown> => {
+    const onSpecInteraction = async (tool: "write" | "edit" | "read", loc: { toplevel: string; rel: string; via: "git" | "jj" }, event: { input: unknown; content: unknown[] }, snap: SettingsSnapshot): Promise<unknown> => {
       const rel = loc.rel;
       if (!boundSpec) {
         if ((tool === "write" || tool === "edit") && isSpecPath(rel)) {
-          await bind(rel, snap, loc.toplevel);
+          await bind(rel, snap, loc.toplevel, loc.via);
           const patch = onBoundSpecWrite(tool, rel, event);
           await flush(true);
           return patch;
@@ -510,7 +525,7 @@
           const spec = planSpecHeader(deps.fs.readFile(join(loc.toplevel, rel)) ?? "");
           const specRel = spec ? repoRelativeToolPath(loc.toplevel, loc.toplevel, spec) : undefined;
           if (specRel && deps.fs.exists(join(loc.toplevel, specRel))) {
-            await bind(specRel, snap, loc.toplevel);
+            await bind(specRel, snap, loc.toplevel, loc.via);
             await flush(true);
           }
         }
@@ -520,7 +535,7 @@
         // Another checkout: a fresh run, never a rename of this record.
         if ((tool === "write" || tool === "edit") && isSpecPath(rel)) {
           unbind();
-          await bind(rel, snap, loc.toplevel);
+          await bind(rel, snap, loc.toplevel, loc.via);
           const patch = onBoundSpecWrite(tool, rel, event);
           await flush(true);
           return patch;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-gauntlet",
-  "version": "5.10.2",
+  "version": "5.11.0",
   "description": "Opinionated, gated workflow skills, subagent personas, and runtime extensions for the pi coding agent.",
   "author": "Jacek Juraszek",
   "type": "module",