@delorenj/pjangler 1.5.48 → 1.5.50

package/dist/index.js

@@ -464,7 +464,7 @@ var init_executionBinding = __esm({
 });
 
 // src/project/manifestIndex.ts
-import { basename as basename5, dirname as dirname10, join as join12, resolve as resolve8 } from "node:path";
+import { basename as basename6, dirname as dirname10, join as join13, resolve as resolve8 } from "node:path";
 function normalizeProjectId2(value) {
   try {
     return normalizeProjectId(value);
@@ -511,12 +511,12 @@ var init_manifestIndex = __esm({
 });
 
 // src/lifecycle/preflight.ts
-import { createHash as createHash8 } from "node:crypto";
-import { accessSync, constants as constants2, existsSync as existsSync9, lstatSync as lstatSync10, readFileSync as readFileSync12, readdirSync as readdirSync8, realpathSync as realpathSync5, statSync as statSync3 } from "node:fs";
-import { basename as basename6, delimiter, dirname as dirname11, isAbsolute as isAbsolute5, join as join13, relative as relative10, resolve as resolve9 } from "node:path";
+import { createHash as createHash9 } from "node:crypto";
+import { accessSync, constants as constants3, existsSync as existsSync9, lstatSync as lstatSync11, readFileSync as readFileSync13, readdirSync as readdirSync9, realpathSync as realpathSync5, statSync as statSync3 } from "node:fs";
+import { basename as basename7, delimiter, dirname as dirname11, isAbsolute as isAbsolute5, join as join14, relative as relative10, resolve as resolve9 } from "node:path";
 import YAML5 from "yaml";
 function sha256(path) {
-  return createHash8("sha256").update(readFileSync12(path)).digest("base64url");
+  return createHash9("sha256").update(readFileSync13(path)).digest("base64url");
 }
 function fingerprint(path) {
   const absolute = resolve9(path);
@@ -570,15 +570,15 @@ var init_preflight = __esm({
 });
 
 // src/project/boardUrl.ts
-import { existsSync as existsSync10, readFileSync as readFileSync13, statSync as statSync4 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync14, statSync as statSync4 } from "node:fs";
 import { homedir as homedir5 } from "node:os";
-import { dirname as dirname12, isAbsolute as isAbsolute6, join as join14, resolve as resolve10 } from "node:path";
+import { dirname as dirname12, isAbsolute as isAbsolute6, join as join15, resolve as resolve10 } from "node:path";
 function resolveTemplateConfigPath(env2 = process.env, home = homedir5()) {
   const fromEnv = env2.HERMES_TEMPLATE_CONFIG;
   if (fromEnv && fromEnv.trim()) return fromEnv.trim();
   const xdg = env2.XDG_CONFIG_HOME?.trim();
-  const base = xdg && xdg.length ? xdg : join14(home, ".config");
-  return join14(base, "hermes-agent-template", "config.toml");
+  const base = xdg && xdg.length ? xdg : join15(home, ".config");
+  return join15(base, "hermes-agent-template", "config.toml");
 }
 function readTomlScalar(text2, section2, key) {
   let inSection = false;
@@ -604,7 +604,7 @@ function readTomlScalar(text2, section2, key) {
 function readTemplateConfig(env2, home) {
   try {
     const path = resolveTemplateConfigPath(env2, home);
-    return existsSync10(path) ? readFileSync13(path, "utf8") : void 0;
+    return existsSync10(path) ? readFileSync14(path, "utf8") : void 0;
   } catch {
     return void 0;
   }
@@ -668,7 +668,7 @@ function boardUrl(provider, options = {}) {
 function findProjectRoot(from) {
   let dir = resolve10(from);
   for (; ; ) {
-    if (existsSync10(join14(dir, ".project.json"))) return dir;
+    if (existsSync10(join15(dir, ".project.json"))) return dir;
     const parent = dirname12(dir);
     if (parent === dir) return void 0;
     dir = parent;
@@ -676,7 +676,7 @@ function findProjectRoot(from) {
 }
 function readTicketProvider(root) {
   try {
-    const manifest = JSON.parse(readFileSync13(join14(root, ".project.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync14(join15(root, ".project.json"), "utf8"));
     const provider = manifest.ticket_provider;
     if (!provider || typeof provider !== "object") return void 0;
     return provider;
@@ -688,16 +688,16 @@ function currentBranch(from) {
   try {
     let dir = resolve10(from);
     for (; ; ) {
-      const dotgit = join14(dir, ".git");
+      const dotgit = join15(dir, ".git");
       if (existsSync10(dotgit)) {
         let gitDir = dotgit;
         if (statSync4(dotgit).isFile()) {
-          const pointer = /^gitdir:\s*(.+)$/m.exec(readFileSync13(dotgit, "utf8"));
+          const pointer = /^gitdir:\s*(.+)$/m.exec(readFileSync14(dotgit, "utf8"));
           if (!pointer) return void 0;
           const target = pointer[1].trim();
           gitDir = isAbsolute6(target) ? target : resolve10(dir, target);
         }
-        const head = readFileSync13(join14(gitDir, "HEAD"), "utf8").trim();
+        const head = readFileSync14(join15(gitDir, "HEAD"), "utf8").trim();
         const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(head);
         return ref ? ref[1].trim() : void 0;
       }
@@ -726,8 +726,8 @@ var init_boardUrl = __esm({
 });
 
 // src/utils/version.ts
-import { readFileSync as readFileSync14 } from "node:fs";
-import { dirname as dirname13, join as join15 } from "node:path";
+import { readFileSync as readFileSync15 } from "node:fs";
+import { dirname as dirname13, join as join16 } from "node:path";
 import { fileURLToPath } from "node:url";
 var PJANGLER_VERSION;
 var init_version = __esm({
@@ -738,7 +738,7 @@ var init_version = __esm({
         let dir = dirname13(fileURLToPath(import.meta.url));
         for (let i = 0; i < 4; i++) {
           try {
-            const raw = readFileSync14(join15(dir, "package.json"), "utf8");
+            const raw = readFileSync15(join16(dir, "package.json"), "utf8");
             return JSON.parse(raw).version ?? "0.0.0";
           } catch {
             const parent = dirname13(dir);
@@ -755,17 +755,17 @@ var init_version = __esm({
 
 // src/project/boardQuery.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { readFileSync as readFileSync15 } from "node:fs";
+import { readFileSync as readFileSync16 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { basename as basename7, join as join16 } from "node:path";
+import { basename as basename8, join as join17 } from "node:path";
 function readProjectSlug(root) {
   try {
-    const manifest = JSON.parse(readFileSync15(join16(root, ".project.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync16(join17(root, ".project.json"), "utf8"));
     const slug = manifest.project_id ?? manifest.project_slug;
     if (typeof slug === "string" && slug.trim()) return slug.trim().toLowerCase();
   } catch {
   }
-  return basename7(root).toLowerCase();
+  return basename8(root).toLowerCase();
 }
 function resolveProject(cwd) {
   const root = findProjectRoot(cwd);
@@ -780,12 +780,12 @@ function resolveProvider(handle) {
   const type = handle.facts?.type?.trim().toLowerCase();
   if (!type) {
     throw new BoardError(
-      `no ticket board bound for ${handle.slug}: ${join16(handle.root, ".project.json")} has no ticket_provider.type`
+      `no ticket board bound for ${handle.slug}: ${join17(handle.root, ".project.json")} has no ticket_provider.type`
     );
   }
   if (!BOARD_PROVIDERS.includes(type)) {
     throw new BoardError(
-      `unsupported ticket_provider.type "${type}" in ${join16(handle.root, ".project.json")} \u2014 expected one of ${BOARD_PROVIDERS.join(", ")}`
+      `unsupported ticket_provider.type "${type}" in ${join17(handle.root, ".project.json")} \u2014 expected one of ${BOARD_PROVIDERS.join(", ")}`
     );
   }
   return type;
@@ -802,7 +802,7 @@ function workspaceEnvKey(workspace) {
 function dotenvValue(path, key) {
   let text2;
   try {
-    text2 = readFileSync15(path, "utf8");
+    text2 = readFileSync16(path, "utf8");
   } catch {
     return void 0;
   }
@@ -837,7 +837,7 @@ function planeApiKeyNames(workspace) {
   return ["PLANE_API_KEY", workspaceEnvKey(workspace)];
 }
 function resolvePlaneApiKey(workspace, env2 = process.env, home = homedir6()) {
-  const fleetEnv = env2.HERMES_FLEET_ENV?.trim() || join16(home, ".hermes", "fleet.env");
+  const fleetEnv = env2.HERMES_FLEET_ENV?.trim() || join17(home, ".hermes", "fleet.env");
   const scoped = workspaceEnvKey(workspace);
   const candidates = [
     env2.PLANE_API_KEY,
@@ -859,7 +859,7 @@ function planeClient(ctx) {
   const board = ctx.facts.board_id?.trim();
   if (!board) {
     throw new BoardError(
-      `no board linked for ${ctx.slug}: ${join16(ctx.root, ".project.json")} has an empty ticket_provider.board_id`
+      `no board linked for ${ctx.slug}: ${join17(ctx.root, ".project.json")} has an empty ticket_provider.board_id`
     );
   }
   const workspace = planeWorkspace(ctx.facts, ctx.env, ctx.home);
@@ -869,7 +869,7 @@ function planeClient(ctx) {
   const apiKey = resolvePlaneApiKey(workspace, ctx.env, ctx.home);
   if (!apiKey) {
     throw new BoardError(
-      `no Plane API key for workspace "${workspace}": set ${planeApiKeyNames(workspace).join(" or ")}, or add one to ${ctx.env.HERMES_FLEET_ENV?.trim() || join16(ctx.home, ".hermes", "fleet.env")}`
+      `no Plane API key for workspace "${workspace}": set ${planeApiKeyNames(workspace).join(" or ")}, or add one to ${ctx.env.HERMES_FLEET_ENV?.trim() || join17(ctx.home, ".hermes", "fleet.env")}`
     );
   }
   return {
@@ -1036,9 +1036,9 @@ var init_boardQuery = __esm({
 
 // src/project/index.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
-import { chmodSync as chmodSync4, closeSync as closeSync2, copyFileSync as copyFileSync2, existsSync as existsSync11, fchmodSync, fsyncSync, lstatSync as lstatSync11, mkdirSync as mkdirSync7, mkdtempSync as mkdtempSync2, openSync as openSync2, readFileSync as readFileSync16, realpathSync as realpathSync6, renameSync as renameSync5, rmSync as rmSync6, statSync as statSync5, unlinkSync as unlinkSync6, writeFileSync as writeFileSync9 } from "node:fs";
+import { chmodSync as chmodSync4, closeSync as closeSync3, copyFileSync as copyFileSync2, existsSync as existsSync11, fchmodSync as fchmodSync2, fsyncSync, lstatSync as lstatSync12, mkdirSync as mkdirSync8, mkdtempSync as mkdtempSync3, openSync as openSync3, readFileSync as readFileSync17, realpathSync as realpathSync6, renameSync as renameSync5, rmSync as rmSync6, statSync as statSync5, unlinkSync as unlinkSync7, writeFileSync as writeFileSync10 } from "node:fs";
 import { homedir as homedir7, tmpdir as tmpdir2 } from "node:os";
-import { basename as basename8, delimiter as delimiter2, dirname as dirname14, isAbsolute as isAbsolute7, join as join17, relative as relative11, resolve as resolve11, sep as sep3, win32 } from "node:path";
+import { basename as basename9, delimiter as delimiter2, dirname as dirname14, isAbsolute as isAbsolute7, join as join18, relative as relative11, resolve as resolve11, sep as sep3, win32 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import YAML6 from "yaml";
 function normalizeProjectType(value, label = "Project type") {
@@ -1048,7 +1048,7 @@ function normalizeProjectType(value, label = "Project type") {
 }
 function looksLikeObsidianPlugin(dir) {
   try {
-    const manifest = JSON.parse(readFileSync16(join17(dir, "manifest.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync17(join18(dir, "manifest.json"), "utf8"));
     return isRecord3(manifest) && typeof manifest.id === "string" && typeof manifest.minAppVersion === "string";
   } catch {
     return false;
@@ -1056,10 +1056,10 @@ function looksLikeObsidianPlugin(dir) {
 }
 function assertTemplateOffersProjectType(pjanglerRoot, projectType) {
   if (projectType === "base") return;
-  const copierYml = join17(pjanglerRoot, "templates", "commonproject", "copier.yml");
+  const copierYml = join18(pjanglerRoot, "templates", "commonproject", "copier.yml");
   let choices;
   try {
-    const parsed = YAML6.parse(readFileSync16(copierYml, "utf8"));
+    const parsed = YAML6.parse(readFileSync17(copierYml, "utf8"));
     choices = isRecord3(parsed) && isRecord3(parsed.project_type) ? parsed.project_type.choices : void 0;
   } catch {
     choices = void 0;
@@ -1082,9 +1082,9 @@ function carriedAutomation(automation) {
   return Object.keys(rest).length ? { automation: rest } : {};
 }
 function synchronizeCopierIdentity(manifestPath, manifest) {
-  const answersPath = join17(dirname14(manifestPath), ".copier-answers.yml");
+  const answersPath = join18(dirname14(manifestPath), ".copier-answers.yml");
   if (!existsSync11(answersPath)) return [];
-  const current = readFileSync16(answersPath, "utf8");
+  const current = readFileSync17(answersPath, "utf8");
   const document = YAML6.parseDocument(current);
   if (document.errors.length) return [];
   const name = String(document.get("project_name") ?? "");
@@ -1094,7 +1094,7 @@ function synchronizeCopierIdentity(manifestPath, manifest) {
   document.set("project_description", manifest.project_description);
   const next = String(document);
   if (next === current) return [];
-  writeFileSync9(answersPath, next, "utf8");
+  writeFileSync10(answersPath, next, "utf8");
   return [answersPath];
 }
 function projectRegistryPath(env2 = process.env) {
@@ -1118,7 +1118,7 @@ function loadProjectRegistry(path = projectRegistryPath()) {
     return registry2;
   }
   if (!existsSync11(path)) return emptyProjectRegistry();
-  const raw = YAML6.parse(readFileSync16(path, "utf8"));
+  const raw = YAML6.parse(readFileSync17(path, "utf8"));
   if (raw == null) return emptyProjectRegistry();
   if (!isRecord3(raw)) throw new Error(`Project registry must be a mapping: ${path}`);
   const registry = raw;
@@ -1186,11 +1186,11 @@ function mergeYamlMapping(document, path, desired, ownedKeys = []) {
 }
 function fsyncDirectory(path) {
   try {
-    const fd = openSync2(path, "r");
+    const fd = openSync3(path, "r");
     try {
       fsyncSync(fd);
     } finally {
-      closeSync2(fd);
+      closeSync3(fd);
     }
   } catch {
   }
@@ -1204,14 +1204,14 @@ function saveProjectRegistry(registry, path = projectRegistryPath()) {
     return;
   }
   validateProjectRegistry(registry);
-  mkdirSync7(dirname14(path), { recursive: true });
+  mkdirSync8(dirname14(path), { recursive: true });
   let text2;
   let mode = 420;
   if (existsSync11(path)) {
-    const stat = lstatSync11(path);
+    const stat = lstatSync12(path);
     if (!stat.isFile() || stat.isSymbolicLink()) throw new Error(`Project registry must be a regular file: ${path}`);
     mode = stat.mode & 511;
-    const current = readFileSync16(path, "utf8");
+    const current = readFileSync17(path, "utf8");
     const document = YAML6.parseDocument(current);
     if (document.errors.length) throw new Error(`Project registry YAML is invalid: ${path}`);
     setYamlLeaf(document, ["schema_version"], registry.schema_version);
@@ -1232,22 +1232,22 @@ function saveProjectRegistry(registry, path = projectRegistryPath()) {
   const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
   let fd;
   try {
-    fd = openSync2(temp, "wx", mode);
-    writeFileSync9(fd, text2, "utf8");
-    fchmodSync(fd, mode);
+    fd = openSync3(temp, "wx", mode);
+    writeFileSync10(fd, text2, "utf8");
+    fchmodSync2(fd, mode);
     fsyncSync(fd);
-    closeSync2(fd);
+    closeSync3(fd);
     fd = void 0;
     renameSync5(temp, path);
     chmodSync4(path, mode);
     fsyncDirectory(dirname14(path));
   } catch (error) {
     if (fd !== void 0) try {
-      closeSync2(fd);
+      closeSync3(fd);
     } catch {
     }
     try {
-      unlinkSync6(temp);
+      unlinkSync7(temp);
     } catch {
     }
     throw error;
@@ -1355,18 +1355,18 @@ function ticketProviderKeyVars(provider, workspace) {
   return ticketProviderKeyGroups(provider, workspace).flat();
 }
 function ticketProviderSecretsPath(env2 = process.env) {
-  const base = env2.XDG_CONFIG_HOME || join17(env2.HOME || homedir7(), ".config");
-  return join17(base, "zshyzsh", "secrets.zsh");
+  const base = env2.XDG_CONFIG_HOME || join18(env2.HOME || homedir7(), ".config");
+  return join18(base, "zshyzsh", "secrets.zsh");
 }
 function ticketProviderFleetEnvPath(env2 = process.env) {
-  return env2.HERMES_FLEET_ENV?.trim() || join17(env2.HOME || homedir7(), ".hermes", "fleet.env");
+  return env2.HERMES_FLEET_ENV?.trim() || join18(env2.HOME || homedir7(), ".hermes", "fleet.env");
 }
 function readShellAssignments(path, keys) {
   const found = {};
   if (!existsSync11(path)) return found;
   let text2;
   try {
-    text2 = readFileSync16(path, "utf8");
+    text2 = readFileSync17(path, "utf8");
   } catch {
     return found;
   }
@@ -1402,7 +1402,7 @@ function resolveTicketProviderCredentials(input) {
     }
   }
   const candidates = [];
-  if (input.repoPath) candidates.push(join17(input.repoPath, ".env"));
+  if (input.repoPath) candidates.push(join18(input.repoPath, ".env"));
   candidates.push(ticketProviderFleetEnvPath(env2));
   candidates.push(ticketProviderSecretsPath(env2));
   for (const candidate of candidates) {
@@ -1420,19 +1420,19 @@ function resolveTicketProviderAdapter(provider, env2 = process.env) {
   const file = `${provider}.sh`;
   const candidates = [];
   const override = env2[TICKET_PROVIDER_ADAPTERS_ENV];
-  if (override) candidates.push(join17(override, file));
-  const relativeRoot = join17("krebs", "adapters", "tp");
+  if (override) candidates.push(join18(override, file));
+  const relativeRoot = join18("krebs", "adapters", "tp");
   try {
     let dir = dirname14(fileURLToPath2(import.meta.url));
     for (let depth = 0; depth < 8; depth++) {
-      candidates.push(join17(dir, relativeRoot, file));
+      candidates.push(join18(dir, relativeRoot, file));
       const parent = dirname14(dir);
       if (parent === dir) break;
       dir = parent;
     }
   } catch {
   }
-  candidates.push(join17(homedir7(), "code", "33GOD", relativeRoot, file));
+  candidates.push(join18(homedir7(), "code", "33GOD", relativeRoot, file));
   return candidates.find((candidate) => existsSync11(candidate));
 }
 function provisionTicketProviderBoard(action, env2 = process.env) {
@@ -1450,7 +1450,7 @@ function provisionTicketProviderBoard(action, env2 = process.env) {
       ok: true,
       skipped: true,
       logs: [
-        `ticket-provider: ${names} not set; skipping ${provider} board creation (state stays "planned"). Set it in the environment, ${join17(action.repoPath, ".env")}, ${ticketProviderFleetEnvPath(env2)}, or ${ticketProviderSecretsPath(env2)} \u2014 or pass --board-id to link an existing board.`
+        `ticket-provider: ${names} not set; skipping ${provider} board creation (state stays "planned"). Set it in the environment, ${join18(action.repoPath, ".env")}, ${ticketProviderFleetEnvPath(env2)}, or ${ticketProviderSecretsPath(env2)} \u2014 or pass --board-id to link an existing board.`
       ]
     };
   }
@@ -1464,12 +1464,12 @@ function provisionTicketProviderBoard(action, env2 = process.env) {
     };
   }
   const redact = (text2) => Object.values(values).reduce((acc, secret) => secret ? acc.split(secret).join("***") : acc, text2);
-  const staging = mkdtempSync2(join17(tmpdir2(), "pjangler-tp-"));
+  const staging = mkdtempSync3(join18(tmpdir2(), "pjangler-tp-"));
   try {
-    const providersDir = join17(staging, ".tp", "adapters");
-    mkdirSync7(providersDir, { recursive: true });
-    writeFileSync9(
-      join17(staging, ".project.json"),
+    const providersDir = join18(staging, ".tp", "adapters");
+    mkdirSync8(providersDir, { recursive: true });
+    writeFileSync10(
+      join18(staging, ".project.json"),
       `${JSON.stringify(
         {
           project_name: action.boardName,
@@ -1488,7 +1488,7 @@ function provisionTicketProviderBoard(action, env2 = process.env) {
 `,
       "utf8"
     );
-    const staged = join17(providersDir, `${provider}.sh`);
+    const staged = join18(providersDir, `${provider}.sh`);
     copyFileSync2(adapter, staged);
     const childEnv = { ...env2, ...values, TICKET_PROVIDER: provider };
     if (provider === "plane" && action.workspace) childEnv.PLANE_WORKSPACE = action.workspace;
@@ -1584,7 +1584,7 @@ function resolveAgentHooksLayer2(input, env2 = process.env) {
   const override = env2.PJ_AGENT_HOOKS_LAYER;
   if (override === "0" || override === "false") return false;
   if (override === "1" || override === "true") return true;
-  return !existsSync11(join17(homedir7(), ".agents", "hooks"));
+  return !existsSync11(join18(homedir7(), ".agents", "hooks"));
 }
 function jsonStable(value) {
   return JSON.stringify(value, (_key, item) => isRecord3(item) ? Object.fromEntries(Object.keys(item).sort().map((key) => [key, item[key]])) : item);
@@ -1626,10 +1626,10 @@ function resolveSourceSkillPath(sourceSkill, env2 = process.env) {
   const expanded = expandHome(sourceSkill);
   const direct = resolve11(expanded);
   if (existsSync11(direct)) return direct;
-  const name = basename8(sourceSkill);
+  const name = basename9(sourceSkill);
   const roots = sourceSkillRoots(env2);
   for (const root of roots) {
-    const candidate = join17(root, name);
+    const candidate = join18(root, name);
     if (existsSync11(candidate)) return candidate;
   }
   const searched = roots.length ? ` Searched roots: ${roots.join(", ")}.` : "";
@@ -1639,8 +1639,8 @@ function resolveSourceSkillPath(sourceSkill, env2 = process.env) {
 function planProjectInit(input) {
   if (!input.name.trim()) throw new Error("Project name is required");
   const targetDir = resolve11(input.targetDir ?? defaultProjectTargetDir(input.name, input.cwd));
-  const localManifestPath = join17(targetDir, ".project.json");
-  const localManifestContent = existsSync11(localManifestPath) ? readFileSync16(localManifestPath, "utf8") : void 0;
+  const localManifestPath = join18(targetDir, ".project.json");
+  const localManifestContent = existsSync11(localManifestPath) ? readFileSync17(localManifestPath, "utf8") : void 0;
   const localManifest = localManifestContent === void 0 ? void 0 : JSON.parse(localManifestContent);
   const localId = localManifest?.project_id ?? localManifest?.project_slug;
   const slug = normalizeProjectId(input.projectSlug ?? localId ?? slugifyProjectName(input.name));
@@ -1668,7 +1668,7 @@ function planProjectInit(input) {
   const recordedTypeValue = existing?.template?.commonproject?.project_type;
   const recordedType = recordedTypeValue === void 0 ? void 0 : normalizeProjectType(recordedTypeValue, `Recorded project type of ${slug}`);
   const requestedType = input.projectType === void 0 ? void 0 : normalizeProjectType(input.projectType);
-  const freshRender = scaffold && localManifest === void 0 && !existsSync11(join17(targetDir, ".copier-answers.yml"));
+  const freshRender = scaffold && localManifest === void 0 && !existsSync11(join18(targetDir, ".copier-answers.yml"));
   if (requestedType && !freshRender && requestedType !== (recordedType ?? "base")) {
     const adoptingPlugin = !scaffold && recordedType === void 0 && requestedType === "obsidian-plugin" && looksLikeObsidianPlugin(targetDir);
     if (!adoptingPlugin) {
@@ -1766,7 +1766,7 @@ function planProjectInit(input) {
     }));
   }
   actions.push(
-    { kind: "project.write-manifest", path: join17(targetDir, ".project.json"), manifest, expectedContent: localManifestContent },
+    { kind: "project.write-manifest", path: join18(targetDir, ".project.json"), manifest, expectedContent: localManifestContent },
     {
       kind: "ticket-provider.create-or-link",
       enabled: boardEnabled,
@@ -1821,12 +1821,12 @@ function linkTicketProviderBoard(plan, action, boardId, identifier, now = /* @__
   plan.manifest.ticket_provider = manifestProvider;
   action.boardId = boardId;
   action.state = manifestProvider.state;
-  const manifestPath = join17(action.repoPath, ".project.json");
+  const manifestPath = join18(action.repoPath, ".project.json");
   let next;
   if (existsSync11(manifestPath)) {
     let existing = {};
     try {
-      const parsed = JSON.parse(readFileSync16(manifestPath, "utf8"));
+      const parsed = JSON.parse(readFileSync17(manifestPath, "utf8"));
       if (isRecord3(parsed)) existing = parsed;
     } catch {
       existing = {};
@@ -1834,13 +1834,13 @@ function linkTicketProviderBoard(plan, action, boardId, identifier, now = /* @__
     const existingProvider = isRecord3(existing.ticket_provider) ? existing.ticket_provider : {};
     next = { ...existing, ticket_provider: { ...existingProvider, ...manifestProvider } };
   } else {
-    mkdirSync7(dirname14(manifestPath), { recursive: true });
+    mkdirSync8(dirname14(manifestPath), { recursive: true });
     next = plan.manifest;
   }
   const text2 = `${JSON.stringify(next, null, 2)}
 `;
-  if (!existsSync11(manifestPath) || readFileSync16(manifestPath, "utf8") !== text2) {
-    writeFileSync9(manifestPath, text2, "utf8");
+  if (!existsSync11(manifestPath) || readFileSync17(manifestPath, "utf8") !== text2) {
+    writeFileSync10(manifestPath, text2, "utf8");
     return [manifestPath];
   }
   return [];
@@ -1868,7 +1868,7 @@ async function executeProjectInitPlan(plan, options = {}) {
       logs.push(
         action.data.agent_hooks_layer === "false" ? "commonproject: agent-hooks layer skipped (global ~/.agents/hooks detected \u2014 no per-user CLI injection)" : "commonproject: agent-hooks layer included"
       );
-      mkdirSync7(dirname14(action.targetDir), { recursive: true });
+      mkdirSync8(dirname14(action.targetDir), { recursive: true });
       const before = snapshotTree(action.targetDir);
       const copierExecutable = options.trustedCopier?.executable ?? action.command[0];
       const copierEnv = { ...process.env };
@@ -1900,22 +1900,22 @@ async function executeProjectInitPlan(plan, options = {}) {
         break;
       }
       const projectType = action.data.project_type ?? "base";
-      const missing = (PROJECT_TYPE_SENTINELS[projectType] ?? []).filter((rel) => !existsSync11(join17(action.targetDir, rel)));
+      const missing = (PROJECT_TYPE_SENTINELS[projectType] ?? []).filter((rel) => !existsSync11(join18(action.targetDir, rel)));
       if (missing.length) {
         errors.push(`copier rendered no ${projectType} project: ${missing.join(", ")} missing from ${action.targetDir}`);
         break;
       }
       if (projectType !== "base") logs.push(`commonproject: rendered as ${projectType}`);
     } else if (action.kind === "project.write-manifest") {
-      if (action.expectedContent !== void 0 && (!existsSync11(action.path) || readFileSync16(action.path, "utf8") !== action.expectedContent)) {
+      if (action.expectedContent !== void 0 && (!existsSync11(action.path) || readFileSync17(action.path, "utf8") !== action.expectedContent)) {
         errors.push(`Manifest changed after planning: ${action.path}; re-plan before applying`);
         break;
       }
-      mkdirSync7(dirname14(action.path), { recursive: true });
+      mkdirSync8(dirname14(action.path), { recursive: true });
       let value = action.manifest;
       if (existsSync11(action.path)) {
         try {
-          const currentValue = JSON.parse(readFileSync16(action.path, "utf8"));
+          const currentValue = JSON.parse(readFileSync17(action.path, "utf8"));
           if (isRecord3(currentValue)) {
             const currentNotebook = isRecord3(currentValue.notebook) ? currentValue.notebook : {};
             const desiredNotebook = isRecord3(value.notebook) ? value.notebook : {};
@@ -1943,9 +1943,9 @@ async function executeProjectInitPlan(plan, options = {}) {
       value.project_id = normalizeProjectId(value.project_id ?? action.manifest.project_id);
       const next = `${JSON.stringify(value, null, 2)}
 `;
-      const current = existsSync11(action.path) ? readFileSync16(action.path, "utf8") : void 0;
+      const current = existsSync11(action.path) ? readFileSync17(action.path, "utf8") : void 0;
       if (current !== next) {
-        writeFileSync9(action.path, next, "utf8");
+        writeFileSync10(action.path, next, "utf8");
         changedFiles.push(action.path);
       }
       changedFiles.push(...synchronizeCopierIdentity(action.path, action.manifest));
@@ -2128,7 +2128,7 @@ function doctorProjectRegistry(registryPath = projectRegistryPath(), slug) {
     } else if (!statSync5(project.repo_path).isDirectory()) {
       issues.push({ level: "error", slug: projectSlug, message: `repo_path is not a directory: ${project.repo_path}` });
     } else {
-      const manifestPath = join17(project.repo_path, ".project.json");
+      const manifestPath = join18(project.repo_path, ".project.json");
       if (!existsSync11(manifestPath)) issues.push({ level: "warn", slug: projectSlug, message: ".project.json is missing" });
     }
     for (const artifact of project.source_artifacts) {
@@ -2145,7 +2145,7 @@ function doctorProjectRegistry(registryPath = projectRegistryPath(), slug) {
   };
 }
 function buildCommonProjectCopierAction(input) {
-  const templateDir = join17(input.pjanglerRoot, "templates", "commonproject");
+  const templateDir = join18(input.pjanglerRoot, "templates", "commonproject");
   const data = {
     project_name: input.projectName,
     project_description: input.projectDescription ?? "",
@@ -2176,7 +2176,7 @@ function buildCommonProjectCopierAction(input) {
 function resolvePjanglerRoot() {
   let dir = dirname14(fileURLToPath2(import.meta.url));
   while (dir !== dirname14(dir)) {
-    if (existsSync11(join17(dir, "package.json")) && existsSync11(join17(dir, "templates", "commonproject", "copier.yml"))) return dir;
+    if (existsSync11(join18(dir, "package.json")) && existsSync11(join18(dir, "templates", "commonproject", "copier.yml"))) return dir;
     dir = dirname14(dir);
   }
   return resolve11(process.cwd());
@@ -2253,7 +2253,7 @@ function validateProjectRecord(project, key) {
 }
 function expandHome(path) {
   if (path === "~") return homedir7();
-  if (path.startsWith("~/")) return join17(homedir7(), path.slice(2));
+  if (path.startsWith("~/")) return join18(homedir7(), path.slice(2));
   return path;
 }
 function isRecord3(value) {
@@ -2280,7 +2280,7 @@ var init_project = __esm({
       "obsidian-plugin": ["typescript", "javascript"]
     };
     PROJECT_TYPE_SENTINELS = {
-      "obsidian-plugin": ["manifest.json", join17("src", "main.ts")]
+      "obsidian-plugin": ["manifest.json", join18("src", "main.ts")]
     };
     BOARD_URL_DEPRECATION_WARNING = "boardUrl is deprecated and ignored; board URLs are derived at runtime and are never persisted.";
     PROJECT_IDENTIFIER_SOURCES = ["provider", "proposed"];
@@ -2289,8 +2289,8 @@ var init_project = __esm({
     IDENTIFIER_REPAIR_COMMAND = "pj project identity --all --apply";
     DEFAULT_SOURCE_SKILL_ROOTS = [
       "/home/delorenj/code/skillex/all-skills",
-      join17(homedir7(), ".agents", "skills"),
-      join17(homedir7(), ".codex", "skills")
+      join18(homedir7(), ".agents", "skills"),
+      join18(homedir7(), ".codex", "skills")
     ];
     PROJECT_REGISTRY_OWNED_KEYS = [
       "name",
@@ -2322,7 +2322,7 @@ var init_project = __esm({
 import { randomUUID } from "node:crypto";
 import { isDeepStrictEqual } from "node:util";
 import { isIP as isIP2 } from "node:net";
-import { closeSync as closeSync3, existsSync as existsSync12, fchmodSync as fchmodSync2, fsyncSync as fsyncSync2, lstatSync as lstatSync12, openSync as openSync3, readFileSync as readFileSync17, realpathSync as realpathSync7, renameSync as renameSync6, writeFileSync as writeFileSync10 } from "node:fs";
+import { closeSync as closeSync4, existsSync as existsSync12, fchmodSync as fchmodSync3, fsyncSync as fsyncSync2, lstatSync as lstatSync13, openSync as openSync4, readFileSync as readFileSync18, realpathSync as realpathSync7, renameSync as renameSync6, writeFileSync as writeFileSync11 } from "node:fs";
 import { dirname as dirname15, resolve as resolve12 } from "node:path";
 function isRecord4(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -2336,7 +2336,7 @@ function readManifest(repoPath) {
   if (!existsSync12(path)) return null;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync17(path, "utf8"));
+    parsed = JSON.parse(readFileSync18(path, "utf8"));
   } catch {
     throw new NotebookError("INVALID_INPUT", `${path} is not valid JSON`);
   }
@@ -2578,7 +2578,7 @@ function persistProjectNotebookBinding(resolved, binding, policy) {
   const changed = [];
   const manifestPath = resolve12(resolved.project.repo_path, ".project.json");
   if (isRegistryServiceLocation(resolved.registry_path)) {
-    const before = existsSync12(manifestPath) ? readFileSync17(manifestPath, "utf8") : null;
+    const before = existsSync12(manifestPath) ? readFileSync18(manifestPath, "utf8") : null;
     const declaredPolicy = resolved.manifest?.notebook?.policy ?? {};
     const nextProject = {
       ...resolved.project,
@@ -2590,10 +2590,10 @@ function persistProjectNotebookBinding(resolved, binding, policy) {
     resolved.registry = loadProjectRegistry(resolved.registry_path);
     resolved.project = registryProjectBySlug(resolved.registry, nextProject.slug);
     resolved.manifest = readManifest(nextProject.repo_path);
-    const after = existsSync12(manifestPath) ? readFileSync17(manifestPath, "utf8") : null;
+    const after = existsSync12(manifestPath) ? readFileSync18(manifestPath, "utf8") : null;
     return before === after ? [] : [manifestPath];
   }
-  const manifestRaw = existsSync12(manifestPath) ? JSON.parse(readFileSync17(manifestPath, "utf8")) : {};
+  const manifestRaw = existsSync12(manifestPath) ? JSON.parse(readFileSync18(manifestPath, "utf8")) : {};
   if (!isRecord4(manifestRaw)) throw new NotebookError("INVALID_INPUT", `${manifestPath} must contain a JSON object`);
   validateManifestNotebookSurface(manifestRaw.notebook);
   const manifestNotebook2 = isRecord4(manifestRaw.notebook) ? manifestRaw.notebook : {};
@@ -2626,29 +2626,29 @@ function persistProjectNotebookBinding(resolved, binding, policy) {
   };
   const manifestText = `${JSON.stringify(manifestNext, null, 2)}
 `;
-  if (!existsSync12(manifestPath) || readFileSync17(manifestPath, "utf8") !== manifestText) {
+  if (!existsSync12(manifestPath) || readFileSync18(manifestPath, "utf8") !== manifestText) {
     let mode = 420;
     if (existsSync12(manifestPath)) {
-      const current2 = lstatSync12(manifestPath);
+      const current2 = lstatSync13(manifestPath);
       if (!current2.isFile() || current2.isSymbolicLink()) throw new NotebookError("CONFLICT", `${manifestPath} must be a regular non-symlink file`);
       mode = current2.mode & 511;
     }
     const temp = resolve12(dirname15(manifestPath), `.${process.pid}.${randomUUID()}.project.json.tmp`);
-    const fd = openSync3(temp, "wx", mode);
+    const fd = openSync4(temp, "wx", mode);
     try {
-      writeFileSync10(fd, manifestText, "utf8");
-      fchmodSync2(fd, mode);
+      writeFileSync11(fd, manifestText, "utf8");
+      fchmodSync3(fd, mode);
       fsyncSync2(fd);
     } finally {
-      closeSync3(fd);
+      closeSync4(fd);
     }
     renameSync6(temp, manifestPath);
     try {
-      const directory = openSync3(dirname15(manifestPath), "r");
+      const directory = openSync4(dirname15(manifestPath), "r");
       try {
         fsyncSync2(directory);
       } finally {
-        closeSync3(directory);
+        closeSync4(directory);
       }
     } catch {
     }
@@ -2657,9 +2657,9 @@ function persistProjectNotebookBinding(resolved, binding, policy) {
   const current = resolved.project.notebook;
   resolved.project.notebook = { ...isRecord4(current) ? current : { state: "planned" }, ...binding };
   const fileRegistry = !isRegistryServiceLocation(resolved.registry_path);
-  const registryBefore = fileRegistry && existsSync12(resolved.registry_path) ? readFileSync17(resolved.registry_path, "utf8") : null;
+  const registryBefore = fileRegistry && existsSync12(resolved.registry_path) ? readFileSync18(resolved.registry_path, "utf8") : null;
   saveProjectRegistry(resolved.registry, resolved.registry_path);
-  const registryAfter = fileRegistry && existsSync12(resolved.registry_path) ? readFileSync17(resolved.registry_path, "utf8") : null;
+  const registryAfter = fileRegistry && existsSync12(resolved.registry_path) ? readFileSync18(resolved.registry_path, "utf8") : null;
   if (registryBefore !== registryAfter) changed.push(resolved.registry_path);
   resolved.manifest = manifestNext;
   return changed;
@@ -2692,7 +2692,7 @@ var init_config = __esm({
 });
 
 // src/notebook/notes.ts
-import { createHash as createHash9, randomUUID as randomUUID2 } from "node:crypto";
+import { createHash as createHash10, randomUUID as randomUUID2 } from "node:crypto";
 function canonicalJson2(value) {
   if (value === void 0 || typeof value === "function" || typeof value === "symbol" || typeof value === "bigint") throw new NotebookError("INVALID_INPUT", "Canonical JSON value is not JSON-compatible");
   if (value === null || typeof value !== "object") {
@@ -2705,7 +2705,7 @@ function canonicalJson2(value) {
   return `{${Object.keys(record3).filter((key) => record3[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson2(record3[key])}`).join(",")}}`;
 }
 function sha256Hex(value) {
-  return createHash9("sha256").update(value).digest("hex");
+  return createHash10("sha256").update(value).digest("hex");
 }
 function base64UrlEncode(value) {
   return Buffer.from(value, "utf8").toString("base64url");
@@ -3256,32 +3256,32 @@ var init_remote_mutation_schema = __esm({
 });
 
 // src/notebook/state.ts
-import { createHash as createHash10, randomUUID as randomUUID3 } from "node:crypto";
+import { createHash as createHash11, randomUUID as randomUUID3 } from "node:crypto";
 import {
-  closeSync as closeSync4,
-  constants as constants3,
+  closeSync as closeSync5,
+  constants as constants4,
   existsSync as existsSync13,
-  fchmodSync as fchmodSync3,
-  fstatSync,
+  fchmodSync as fchmodSync4,
+  fstatSync as fstatSync2,
   fsyncSync as fsyncSync3,
-  lstatSync as lstatSync13,
-  mkdirSync as mkdirSync8,
-  openSync as openSync4,
+  lstatSync as lstatSync14,
+  mkdirSync as mkdirSync9,
+  openSync as openSync5,
   readSync,
-  readdirSync as readdirSync9,
+  readdirSync as readdirSync10,
   renameSync as renameSync7,
-  unlinkSync as unlinkSync7,
-  writeFileSync as writeFileSync11
+  unlinkSync as unlinkSync8,
+  writeFileSync as writeFileSync12
 } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { basename as basename9, dirname as dirname16, join as join18, parse, relative as relative12, resolve as resolve13, sep as sep4 } from "node:path";
+import { basename as basename10, dirname as dirname16, join as join19, parse, relative as relative12, resolve as resolve13, sep as sep4 } from "node:path";
 function notebookStateRoot(env2 = process.env) {
-  const base = env2.XDG_STATE_HOME || join18(env2.HOME || homedir8(), ".local", "state");
+  const base = env2.XDG_STATE_HOME || join19(env2.HOME || homedir8(), ".local", "state");
   return resolve13(base, "pjangler", "notebook", NOTEBOOK_STATE_VERSION);
 }
 function deriveSessionKey(projectSlug, client, clientSessionId) {
   if (!projectSlug || !client || !clientSessionId) throw new NotebookError("INVALID_INPUT", "project slug, client, and client session id are required");
-  return createHash10("sha256").update(`pjangler-session-v1\0${projectSlug}\0${client}\0${clientSessionId}`, "utf8").digest("hex");
+  return createHash11("sha256").update(`pjangler-session-v1\0${projectSlug}\0${client}\0${clientSessionId}`, "utf8").digest("hex");
 }
 function deriveReceiptId(sessionKey) {
   assertDigest(sessionKey, "session key");
@@ -3295,7 +3295,7 @@ function assertDigest(value, label) {
 }
 function projectStateDir(root, projectSlug) {
   if (!/^[a-z0-9][a-z0-9._-]{0,127}$/iu.test(projectSlug)) throw new NotebookError("INVALID_INPUT", "Invalid project slug for Notebook state");
-  return join18(resolve13(root), "projects", sha256Hex(`pjangler-project-state-v1\0${projectSlug}`));
+  return join19(resolve13(root), "projects", sha256Hex(`pjangler-project-state-v1\0${projectSlug}`));
 }
 function assertContained(root, candidate) {
   const rel = relative12(resolve13(root), resolve13(candidate));
@@ -3308,33 +3308,33 @@ function openPinnedDirectory(path, root, create) {
   assertContained(absoluteRoot, absolute);
   if (!existsSync13("/proc/self/fd")) throw new NotebookError("INTERNAL_ERROR", "Descriptor-pinned Notebook state requires procfs");
   const parsed = parse(absolute);
-  let fd = openSync4(parsed.root, DIRECTORY_OPEN_FLAGS);
+  let fd = openSync5(parsed.root, DIRECTORY_OPEN_FLAGS);
   let cursor = parsed.root;
   try {
     for (const part of absolute.slice(parsed.root.length).split(sep4).filter(Boolean)) {
       const child = `/proc/self/fd/${fd}/${part}`;
-      cursor = join18(cursor, part);
+      cursor = join19(cursor, part);
       let childFd;
       try {
-        childFd = openSync4(child, DIRECTORY_OPEN_FLAGS);
+        childFd = openSync5(child, DIRECTORY_OPEN_FLAGS);
       } catch (error) {
         if (!create || error.code !== "ENOENT") throw error;
         try {
-          mkdirSync8(child, { mode: 448 });
+          mkdirSync9(child, { mode: 448 });
         } catch (mkdirError) {
           if (mkdirError.code !== "EEXIST") throw mkdirError;
         }
-        childFd = openSync4(child, DIRECTORY_OPEN_FLAGS);
+        childFd = openSync5(child, DIRECTORY_OPEN_FLAGS);
       }
-      closeSync4(fd);
+      closeSync5(fd);
       fd = childFd;
-      const stat = fstatSync(fd);
+      const stat = fstatSync2(fd);
       if (!stat.isDirectory()) throw new NotebookError("INTERNAL_ERROR", "Notebook state path component is not a directory");
       if (cursor === absoluteRoot || relative12(absoluteRoot, cursor).startsWith("..") === false) assertOwned(stat);
     }
     return fd;
   } catch (error) {
-    closeSync4(fd);
+    closeSync5(fd);
     if (error.code === "ELOOP" || error.code === "ENOTDIR") {
       throw new NotebookError("INTERNAL_ERROR", "Notebook state path contains a symlink component");
     }
@@ -3342,7 +3342,7 @@ function openPinnedDirectory(path, root, create) {
   }
 }
 function pinnedLeaf(parentFd, path) {
-  return `/proc/self/fd/${parentFd}/${basename9(path)}`;
+  return `/proc/self/fd/${parentFd}/${basename10(path)}`;
 }
 function assertOwned(stat) {
   if (typeof process.getuid === "function" && stat.uid !== process.getuid()) {
@@ -3355,13 +3355,13 @@ function ensureDirectory(path, root) {
   assertContained(absoluteRoot, absolute);
   const fd = openPinnedDirectory(absolute, absoluteRoot, true);
   try {
-    const stat = fstatSync(fd);
+    const stat = fstatSync2(fd);
     if (!stat.isDirectory()) throw new NotebookError("INTERNAL_ERROR", "Notebook state directory is not a real directory");
     assertOwned(stat);
-    fchmodSync3(fd, 448);
+    fchmodSync4(fd, 448);
     fsyncSync3(fd);
   } finally {
-    closeSync4(fd);
+    closeSync5(fd);
   }
 }
 function notebookStatePaths(root, projectSlug) {
@@ -3370,18 +3370,18 @@ function notebookStatePaths(root, projectSlug) {
   return {
     root: absoluteRoot,
     project,
-    baselines: join18(project, "baselines"),
-    claims: join18(project, "claims"),
-    receipts: join18(project, "receipts"),
-    refusals: join18(project, "refusals"),
-    journals: join18(project, "journals"),
-    locks: join18(project, "locks")
+    baselines: join19(project, "baselines"),
+    claims: join19(project, "claims"),
+    receipts: join19(project, "receipts"),
+    refusals: join19(project, "refusals"),
+    journals: join19(project, "journals"),
+    locks: join19(project, "locks")
   };
 }
 function ensureNotebookState(root, projectSlug) {
   const paths = notebookStatePaths(root, projectSlug);
   const { root: absoluteRoot, project } = paths;
-  for (const path of [absoluteRoot, join18(absoluteRoot, "projects"), project, paths.baselines, paths.claims, paths.receipts, paths.refusals, paths.journals, paths.locks]) {
+  for (const path of [absoluteRoot, join19(absoluteRoot, "projects"), project, paths.baselines, paths.claims, paths.receipts, paths.refusals, paths.journals, paths.locks]) {
     ensureDirectory(path, absoluteRoot);
   }
   return paths;
@@ -3397,15 +3397,15 @@ function fsyncDirectory2(path) {
     fsyncSync3(fd);
   } catch {
   } finally {
-    if (fd !== void 0) closeSync4(fd);
+    if (fd !== void 0) closeSync5(fd);
   }
 }
 function readStateDirectory(path, root) {
   const fd = openPinnedDirectory(path, root, false);
   try {
-    return readdirSync9(`/proc/self/fd/${fd}`, { withFileTypes: true });
+    return readdirSync10(`/proc/self/fd/${fd}`, { withFileTypes: true });
   } finally {
-    closeSync4(fd);
+    closeSync5(fd);
   }
 }
 function readNotebookStateDirectory(path, root) {
@@ -3419,22 +3419,22 @@ function unlinkStateFile(path, root, allowMissing = false) {
   let fileFd;
   try {
     try {
-      fileFd = openSync4(target, constants3.O_RDONLY | (constants3.O_NOFOLLOW ?? 0));
+      fileFd = openSync5(target, constants4.O_RDONLY | (constants4.O_NOFOLLOW ?? 0));
     } catch (error) {
       if (allowMissing && error.code === "ENOENT") return false;
       throw error;
     }
-    const stat = fstatSync(fileFd);
+    const stat = fstatSync2(fileFd);
     if (!stat.isFile() || (stat.mode & 511) !== 384) {
       throw new NotebookError("CONFLICT", "Refusing to remove a suspect Notebook state entry; run pj notebook audit --json");
     }
     assertOwned(stat);
-    unlinkSync7(target);
+    unlinkSync8(target);
     fsyncSync3(parentFd);
     return true;
   } finally {
-    if (fileFd !== void 0) closeSync4(fileFd);
-    closeSync4(parentFd);
+    if (fileFd !== void 0) closeSync5(fileFd);
+    closeSync5(parentFd);
   }
 }
 function renameStateFile(source, target, root) {
@@ -3444,12 +3444,12 @@ function renameStateFile(source, target, root) {
   const targetPath = pinnedLeaf(parentFd, target);
   let sourceFd;
   try {
-    sourceFd = openSync4(sourcePath, constants3.O_RDONLY | (constants3.O_NOFOLLOW ?? 0));
-    const stat = fstatSync(sourceFd);
+    sourceFd = openSync5(sourcePath, constants4.O_RDONLY | (constants4.O_NOFOLLOW ?? 0));
+    const stat = fstatSync2(sourceFd);
     if (!stat.isFile() || (stat.mode & 511) !== 384) throw new NotebookError("CONFLICT", "Notebook state rename source has an integrity finding");
     assertOwned(stat);
     try {
-      lstatSync13(targetPath);
+      lstatSync14(targetPath);
       throw new NotebookError("CONFLICT", "Notebook state rename target already exists");
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
@@ -3457,8 +3457,8 @@ function renameStateFile(source, target, root) {
     renameSync7(sourcePath, targetPath);
     fsyncSync3(parentFd);
   } finally {
-    if (sourceFd !== void 0) closeSync4(sourceFd);
-    closeSync4(parentFd);
+    if (sourceFd !== void 0) closeSync5(sourceFd);
+    closeSync5(parentFd);
   }
 }
 function atomicWriteJson(path, value, root, afterParentPinned) {
@@ -3467,34 +3467,34 @@ function atomicWriteJson(path, value, root, afterParentPinned) {
   const text2 = jsonLine(value);
   const parentFd = openPinnedDirectory(dirname16(path), root, false);
   const target = pinnedLeaf(parentFd, path);
-  const tempName = `.${basename9(path)}.${process.pid}.${randomUUID3()}.tmp`;
+  const tempName = `.${basename10(path)}.${process.pid}.${randomUUID3()}.tmp`;
   const temp = `/proc/self/fd/${parentFd}/${tempName}`;
   let existingIdentity = null;
   try {
     afterParentPinned?.();
     try {
-      const existingFd = openSync4(target, constants3.O_RDONLY | (constants3.O_NOFOLLOW ?? 0));
+      const existingFd = openSync5(target, constants4.O_RDONLY | (constants4.O_NOFOLLOW ?? 0));
       try {
-        const existing = fstatSync(existingFd);
+        const existing = fstatSync2(existingFd);
         if (!existing.isFile()) throw new NotebookError("INTERNAL_ERROR", "Refusing to replace a non-regular Notebook state file");
         assertOwned(existing);
         if ((existing.mode & 511) !== 384) throw new NotebookError("CONFLICT", "Refusing to replace a Notebook state file with unsafe permissions");
         existingIdentity = { dev: existing.dev, ino: existing.ino };
       } finally {
-        closeSync4(existingFd);
+        closeSync5(existingFd);
       }
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
-    const fd = openSync4(temp, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL | (constants3.O_NOFOLLOW ?? 0), 384);
+    const fd = openSync5(temp, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | (constants4.O_NOFOLLOW ?? 0), 384);
     try {
-      writeFileSync11(fd, text2, "utf8");
+      writeFileSync12(fd, text2, "utf8");
       fsyncSync3(fd);
     } finally {
-      closeSync4(fd);
+      closeSync5(fd);
     }
     try {
-      const current = lstatSync13(target);
+      const current = lstatSync14(target);
       if (!existingIdentity || !current.isFile() || current.isSymbolicLink() || current.dev !== existingIdentity.dev || current.ino !== existingIdentity.ino) {
         throw new NotebookError("CONFLICT", "Notebook state target changed during atomic update; preserving both entries for audit");
       }
@@ -3505,12 +3505,12 @@ function atomicWriteJson(path, value, root, afterParentPinned) {
     fsyncSync3(parentFd);
   } catch (error) {
     try {
-      unlinkSync7(temp);
+      unlinkSync8(temp);
     } catch {
     }
     throw error;
   } finally {
-    closeSync4(parentFd);
+    closeSync5(parentFd);
   }
   return Buffer.byteLength(text2, "utf8");
 }
@@ -3520,22 +3520,22 @@ function exclusiveWrite(path, text2, root) {
   const target = pinnedLeaf(parentFd, path);
   let fd;
   try {
-    fd = openSync4(target, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL | (constants3.O_NOFOLLOW ?? 0), 384);
+    fd = openSync5(target, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | (constants4.O_NOFOLLOW ?? 0), 384);
   } catch (error) {
-    closeSync4(parentFd);
+    closeSync5(parentFd);
     if (error.code === "EEXIST") return false;
     throw error;
   }
   try {
-    writeFileSync11(fd, text2, "utf8");
+    writeFileSync12(fd, text2, "utf8");
     fsyncSync3(fd);
   } finally {
-    closeSync4(fd);
+    closeSync5(fd);
   }
   try {
     fsyncSync3(parentFd);
   } finally {
-    closeSync4(parentFd);
+    closeSync5(parentFd);
   }
   return true;
 }
@@ -3679,13 +3679,13 @@ function safeReadJson(path, maxBytes) {
   }
   let fd;
   try {
-    fd = openSync4(pinnedLeaf(parentFd, path), constants3.O_RDONLY | (constants3.O_NOFOLLOW ?? 0));
+    fd = openSync5(pinnedLeaf(parentFd, path), constants4.O_RDONLY | (constants4.O_NOFOLLOW ?? 0));
   } catch (error) {
-    closeSync4(parentFd);
+    closeSync5(parentFd);
     return { reason: error.code === "ELOOP" ? "non-regular" : "unreadable", bytes: 0 };
   }
   try {
-    const stat = fstatSync(fd);
+    const stat = fstatSync2(fd);
     if (!stat.isFile()) return { reason: "non-regular", bytes: 0 };
     if ((stat.mode & 511) !== 384) return { reason: "unsafe-permissions", bytes: stat.size };
     try {
@@ -3705,14 +3705,14 @@ function safeReadJson(path, maxBytes) {
       if (total > maxBytes) return { reason: "oversize", bytes: total };
       chunks.push(chunk.subarray(0, count));
     }
-    const after = fstatSync(fd);
+    const after = fstatSync2(fd);
     if (after.size !== stat.size || total !== stat.size) return { reason: "unreadable", bytes: total };
     return { value: JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks, total))), bytes: total };
   } catch (error) {
     return { reason: error instanceof SyntaxError || error instanceof TypeError ? "invalid-json" : "unreadable", bytes: 0 };
   } finally {
-    closeSync4(fd);
-    closeSync4(parentFd);
+    closeSync5(fd);
+    closeSync5(parentFd);
   }
 }
 function safeEntryId(kind, name) {
@@ -3729,7 +3729,7 @@ function baselineReceiptByteCeiling(limits) {
 function createSessionBaseline(root, input) {
   assertDigest(input.session_key, "session key");
   const paths = ensureNotebookState(root, input.project_slug);
-  const path = join18(paths.baselines, `${input.session_key}.json`);
+  const path = join19(paths.baselines, `${input.session_key}.json`);
   const maxBytes = baselineReceiptByteCeiling(input.limits);
   const existing = readBaseline(path, maxBytes);
   if (existing) return { baseline: existing, created: false };
@@ -3770,7 +3770,7 @@ function createSessionBaseline(root, input) {
 function createOverviewClaim(root, input) {
   assertDigest(input.session_key, "session key");
   const paths = ensureNotebookState(root, input.project_slug);
-  const path = join18(paths.claims, `${input.session_key}.overview`);
+  const path = join19(paths.claims, `${input.session_key}.overview`);
   if (existsSync13(path)) {
     const read = safeReadJson(path, 65536);
     const existing = read.value === void 0 ? null : parseClaim(read.value);
@@ -3789,7 +3789,7 @@ function createOverviewClaim(root, input) {
 function readOverviewClaim(root, projectSlug, sessionKey) {
   assertDigest(sessionKey, "session key");
   const paths = notebookStatePaths(root, projectSlug);
-  const path = join18(paths.claims, `${sessionKey}.overview`);
+  const path = join19(paths.claims, `${sessionKey}.overview`);
   if (!existsSync13(path)) return null;
   const read = safeReadJson(path, 65536);
   return read.value === void 0 ? null : parseClaim(read.value);
@@ -3797,10 +3797,10 @@ function readOverviewClaim(root, projectSlug, sessionKey) {
 function readSessionBaseline(root, projectSlug, sessionKey, limits) {
   assertDigest(sessionKey, "session key");
   const paths = ensureNotebookState(root, projectSlug);
-  return readBaseline(join18(paths.baselines, `${sessionKey}.json`), baselineReceiptByteCeiling(limits));
+  return readBaseline(join19(paths.baselines, `${sessionKey}.json`), baselineReceiptByteCeiling(limits));
 }
 function acquireLock(paths, maxWaitMs) {
-  const lock = join18(paths.locks, "admission.lock");
+  const lock = join19(paths.locks, "admission.lock");
   const deadline = Date.now() + Math.max(1, maxWaitMs);
   const token = randomUUID3();
   const record3 = () => ({
@@ -3830,7 +3830,7 @@ function acquireLock(paths, maxWaitMs) {
       throw new NotebookError("CONFLICT", "Notebook state lock has an integrity finding; preserve it and run pj notebook audit --json");
     }
     if (Date.now() >= expiresAt) {
-      const recovery = join18(paths.locks, `recovery-${heldToken}.lock`);
+      const recovery = join19(paths.locks, `recovery-${heldToken}.lock`);
       const recoveryRecord = jsonLine({ schema_version: NOTEBOOK_SCHEMA_VERSION, stale_token: heldToken, recovery_token: token, expires_at: new Date(Date.now() + 5e3).toISOString() });
       if (exclusiveWrite(recovery, recoveryRecord, paths.root)) {
         try {
@@ -3838,7 +3838,7 @@ function acquireLock(paths, maxWaitMs) {
           const currentToken = verify.value && typeof verify.value === "object" && !Array.isArray(verify.value) ? verify.value.token : null;
           const currentExpiry = verify.value && typeof verify.value === "object" && !Array.isArray(verify.value) ? Date.parse(String(verify.value.expires_at ?? "")) : Number.NaN;
           if (currentToken === heldToken && Number.isFinite(currentExpiry) && Date.now() >= currentExpiry) {
-            const recovered = join18(paths.locks, `.recovered-${heldToken}-${randomUUID3()}.json`);
+            const recovered = join19(paths.locks, `.recovered-${heldToken}-${randomUUID3()}.json`);
             renameStateFile(lock, recovered, paths.root);
             unlinkStateFile(recovered, paths.root);
           }
@@ -3918,7 +3918,7 @@ function scanAuxiliaryState(paths, limits) {
         addBoundedIntegrity(scan, limits, { entry_id: entryId, reason: "non-regular" });
         continue;
       }
-      const read = safeReadJson(join18(specification.dir, entry.name), specification.maxBytes);
+      const read = safeReadJson(join19(specification.dir, entry.name), specification.maxBytes);
       if (read.reason || read.value === void 0) {
         addBoundedIntegrity(scan, limits, { entry_id: entryId, reason: read.reason ?? "invalid-json" }, read.bytes);
         continue;
@@ -3943,7 +3943,7 @@ function scanAuxiliaryState(paths, limits) {
         addBoundedIntegrity(scan, limits, { entry_id: entryId, reason: "non-regular" });
         continue;
       }
-      const read = safeReadJson(join18(paths.journals, entry.name), limits.receipt_max_bytes);
+      const read = safeReadJson(join19(paths.journals, entry.name), limits.receipt_max_bytes);
       if (read.reason || read.value === void 0) {
         addBoundedIntegrity(scan, limits, { entry_id: entryId, reason: read.reason ?? "invalid-json" }, read.bytes);
         continue;
@@ -3972,7 +3972,7 @@ function scanAuxiliaryState(paths, limits) {
         addBoundedIntegrity(scan, limits, { entry_id: entryId, reason: "non-regular" });
         continue;
       }
-      const read = safeReadJson(join18(paths.locks, entry.name), 8192);
+      const read = safeReadJson(join19(paths.locks, entry.name), 8192);
       if (read.reason || read.value === void 0) {
         addBoundedIntegrity(scan, limits, { entry_id: entryId, reason: read.reason ?? "invalid-json" }, read.bytes);
         continue;
@@ -4011,7 +4011,7 @@ function scanReceipts(paths, limits) {
   }
   for (const entry of entries) {
     const entryId = safeEntryId("receipts", entry.name);
-    const path = join18(paths.receipts, entry.name);
+    const path = join19(paths.receipts, entry.name);
     if (!entry.isFile() || entry.isSymbolicLink() || !/^[a-f0-9]{64}\.json$/u.test(entry.name)) {
       addIntegrity({ entry_id: entryId, reason: "non-regular" });
       continue;
@@ -4041,7 +4041,7 @@ function scanBaselines(paths, nowMs, limits, referenced) {
   if (!existsSync13(paths.baselines)) return { current, stale };
   for (const entry of readStateDirectory(paths.baselines, paths.root)) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const baseline = readBaseline(join18(paths.baselines, entry.name), baselineReceiptByteCeiling(limits));
+    const baseline = readBaseline(join19(paths.baselines, entry.name), baselineReceiptByteCeiling(limits));
     if (!baseline || referenced.has(baseline.session_key)) continue;
     const expires = Date.parse(baseline.created_at) + limits.receiptless_session_retention_seconds * 1e3;
     if (nowMs >= expires) stale += 1;
@@ -4055,7 +4055,7 @@ function scanRefusals(paths, nowMs, limits, scan) {
   const entries = readStateDirectory(paths.refusals, paths.root).sort((a, b) => a.name.localeCompare(b.name, "en")).slice(0, limits.refusal_max_entries);
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-    const read = safeReadJson(join18(paths.refusals, entry.name), limits.receipt_max_bytes);
+    const read = safeReadJson(join19(paths.refusals, entry.name), limits.receipt_max_bytes);
     const marker = read.value === void 0 ? null : parseRefusal(read.value);
     if (!marker || `${marker.session_key}.json` !== entry.name) continue;
     if (nowMs >= Date.parse(marker.baseline_created_at) + limits.receiptless_session_retention_seconds * 1e3) continue;
@@ -4151,7 +4151,7 @@ function recoveryActions(receiptId, repoPath) {
   ];
 }
 function removeValidRefusal(paths, sessionKey, limits) {
-  const path = join18(paths.refusals, `${sessionKey}.json`);
+  const path = join19(paths.refusals, `${sessionKey}.json`);
   if (!existsSync13(path)) return;
   const read = safeReadJson(path, limits.receipt_max_bytes);
   const marker = read.value === void 0 ? null : parseRefusal(read.value);
@@ -4165,7 +4165,7 @@ function admitCaptureReceipt(input) {
   const release = acquireLock(paths, Math.min(100, input.limits.hook_session_end_timeout_ms));
   try {
     const receiptId = deriveReceiptId(input.sessionKey);
-    const receiptPath = join18(paths.receipts, `${receiptId}.json`);
+    const receiptPath = join19(paths.receipts, `${receiptId}.json`);
     if (existsSync13(receiptPath)) {
       const read = safeReadJson(receiptPath, input.limits.receipt_max_bytes);
       const receipt = read.value === void 0 ? null : parseReceipt(read.value);
@@ -4177,15 +4177,15 @@ function admitCaptureReceipt(input) {
     const scanBefore = scanReceipts(paths, input.limits);
     const auxiliaryBefore = scanAuxiliaryState(paths, input.limits);
     const referencedBefore = /* @__PURE__ */ new Set([...scanBefore.referencedSessions, ...auxiliaryBefore.referencedSessions]);
-    const baselinePath = join18(paths.baselines, `${input.sessionKey}.json`);
+    const baselinePath = join19(paths.baselines, `${input.sessionKey}.json`);
     let baseline = readBaseline(baselinePath, baselineReceiptByteCeiling(input.limits));
     if (baseline) {
       const expired = now.getTime() >= Date.parse(baseline.created_at) + input.limits.receiptless_session_retention_seconds * 1e3;
       if (expired && !referencedBefore.has(input.sessionKey) && scanBefore.integrityCount === 0 && auxiliaryBefore.integrityCount === 0) {
         unlinkStateFile(baselinePath, paths.root);
-        const claimPath = join18(paths.claims, `${input.sessionKey}.overview`);
+        const claimPath = join19(paths.claims, `${input.sessionKey}.overview`);
         unlinkStateFile(claimPath, paths.root, true);
-        const refusalPath = join18(paths.refusals, `${input.sessionKey}.json`);
+        const refusalPath = join19(paths.refusals, `${input.sessionKey}.json`);
         unlinkStateFile(refusalPath, paths.root, true);
         baseline = null;
       }
@@ -4214,7 +4214,7 @@ function admitCaptureReceipt(input) {
     const byteBlocked = summary.unresolved_bytes + candidate.bytes > input.limits.unresolved_receipt_max_bytes;
     if (countBlocked || byteBlocked) {
       const actions = recoveryActions(receiptId, input.repoPath);
-      const refusalPath = join18(paths.refusals, `${input.sessionKey}.json`);
+      const refusalPath = join19(paths.refusals, `${input.sessionKey}.json`);
       const oldRead = existsSync13(refusalPath) ? safeReadJson(refusalPath, input.limits.receipt_max_bytes) : void 0;
       const old = oldRead?.value === void 0 ? null : parseRefusal(oldRead.value);
       const marker = {
@@ -4283,7 +4283,7 @@ function listCaptureReceipts(root, projectSlug, limits, state) {
 function readCaptureReceipt(root, projectSlug, receiptId, limits) {
   if (!RECEIPT_ID_RE.test(receiptId)) throw new NotebookError("INVALID_INPUT", "Invalid receipt ID");
   const paths = notebookStatePaths(root, projectSlug);
-  const path = join18(paths.receipts, `${receiptId}.json`);
+  const path = join19(paths.receipts, `${receiptId}.json`);
   if (!existsSync13(path)) throw new NotebookError("NOT_FOUND", `Capture receipt not found: ${receiptId}`);
   const read = safeReadJson(path, limits.receipt_max_bytes);
   const receipt = read.value === void 0 ? null : parseReceipt(read.value);
@@ -4296,7 +4296,7 @@ function writeReceipt(paths, receipt, limit) {
     const bytes = Buffer.byteLength(text2, "utf8");
     if (bytes > limit) throw new NotebookError("CONFLICT", "Receipt transition exceeds its per-receipt ceiling");
     if (receipt.serialized_bytes === bytes) {
-      atomicWriteJson(join18(paths.receipts, `${receipt.receipt_id}.json`), receipt, paths.root);
+      atomicWriteJson(join19(paths.receipts, `${receipt.receipt_id}.json`), receipt, paths.root);
       return receipt;
     }
     receipt.serialized_bytes = bytes;
@@ -4435,25 +4435,25 @@ function pruneNotebookState(root, projectSlug, limits, now = /* @__PURE__ */ new
     const successCutoff = now.getTime() - limits.receipt_succeeded_retention_days * 864e5;
     for (const receipt of scan.receipts) {
       if (receipt.state !== "succeeded" || Date.parse(receipt.updated_at) > successCutoff) continue;
-      const path = join18(paths.receipts, `${receipt.receipt_id}.json`);
+      const path = join19(paths.receipts, `${receipt.receipt_id}.json`);
       unlinkStateFile(path, paths.root);
-      removed.push(safeEntryId("receipts", basename9(path)));
+      removed.push(safeEntryId("receipts", basename10(path)));
     }
     const remaining = scanReceipts(paths, limits);
     const remainingAuxiliary = scanAuxiliaryState(paths, limits);
     const referenced = /* @__PURE__ */ new Set([...remaining.referencedSessions, ...remainingAuxiliary.referencedSessions]);
     for (const entry of readStateDirectory(paths.baselines, paths.root)) {
       if (!entry.isFile() || !entry.name.endsWith(".json")) continue;
-      const path = join18(paths.baselines, entry.name);
+      const path = join19(paths.baselines, entry.name);
       const baseline = readBaseline(path, baselineReceiptByteCeiling(limits));
       if (!baseline || referenced.has(baseline.session_key)) continue;
       if (now.getTime() < Date.parse(baseline.created_at) + limits.receiptless_session_retention_seconds * 1e3) continue;
       unlinkStateFile(path, paths.root);
       removed.push(safeEntryId("baselines", entry.name));
-      const claim = join18(paths.claims, `${baseline.session_key}.overview`);
-      if (unlinkStateFile(claim, paths.root, true)) removed.push(safeEntryId("claims", basename9(claim)));
-      const refusal = join18(paths.refusals, `${baseline.session_key}.json`);
-      if (unlinkStateFile(refusal, paths.root, true)) removed.push(safeEntryId("refusals", basename9(refusal)));
+      const claim = join19(paths.claims, `${baseline.session_key}.overview`);
+      if (unlinkStateFile(claim, paths.root, true)) removed.push(safeEntryId("claims", basename10(claim)));
+      const refusal = join19(paths.refusals, `${baseline.session_key}.json`);
+      if (unlinkStateFile(refusal, paths.root, true)) removed.push(safeEntryId("refusals", basename10(refusal)));
     }
     fsyncDirectory2(paths.project);
     return removed;
@@ -4476,7 +4476,7 @@ function currentRetentionPressure(summary) {
 }
 function statePathForReceipt(root, projectSlug, receiptId) {
   if (!RECEIPT_ID_RE.test(receiptId)) throw new NotebookError("INVALID_INPUT", "Invalid receipt ID");
-  return join18(projectStateDir(root, projectSlug), "receipts", `${receiptId}.json`);
+  return join19(projectStateDir(root, projectSlug), "receipts", `${receiptId}.json`);
 }
 var NOTEBOOK_STATE_VERSION, SESSION_KEY_RE, RECEIPT_ID_RE, GIT_OBJECT_RE, NOTEBOOK_ERROR_CODES, DIRECTORY_OPEN_FLAGS;
 var init_state = __esm({
@@ -4503,7 +4503,7 @@ var init_state = __esm({
       "REMOTE_PROTOCOL_ERROR",
       "INTERNAL_ERROR"
     ]);
-    DIRECTORY_OPEN_FLAGS = constants3.O_RDONLY | (constants3.O_DIRECTORY ?? 0) | (constants3.O_NOFOLLOW ?? 0);
+    DIRECTORY_OPEN_FLAGS = constants4.O_RDONLY | (constants4.O_DIRECTORY ?? 0) | (constants4.O_NOFOLLOW ?? 0);
   }
 });
 
@@ -4842,8 +4842,8 @@ var init_open_notebook_client = __esm({
 
 // src/notebook/git-evidence.ts
 import { spawnSync as spawnSync9 } from "node:child_process";
-import { closeSync as closeSync5, constants as constants4, fstatSync as fstatSync2, lstatSync as lstatSync14, openSync as openSync5, readSync as readSync2, realpathSync as realpathSync8 } from "node:fs";
-import { extname, join as join20, relative as relative13, resolve as resolve14, sep as sep5 } from "node:path";
+import { closeSync as closeSync6, constants as constants5, fstatSync as fstatSync3, lstatSync as lstatSync15, openSync as openSync6, readSync as readSync2, realpathSync as realpathSync8 } from "node:fs";
+import { extname, join as join21, relative as relative13, resolve as resolve14, sep as sep5 } from "node:path";
 function git(repo, args, maxBuffer = 4 * 1024 * 1024, timeout = 5e3) {
   const result2 = spawnSync9("git", args, { cwd: repo, encoding: "utf8", maxBuffer, timeout, shell: false });
   return { ok: result2.status === 0, stdout: result2.stdout ?? "" };
@@ -4921,9 +4921,9 @@ function hasSymlinkComponent(root, candidate) {
   const rel = relative13(root, candidate);
   let cursor = root;
   for (const part of rel.split(sep5).filter(Boolean)) {
-    cursor = join20(cursor, part);
+    cursor = join21(cursor, part);
     try {
-      if (lstatSync14(cursor).isSymbolicLink()) return true;
+      if (lstatSync15(cursor).isSymbolicLink()) return true;
     } catch {
       return true;
     }
@@ -4935,12 +4935,12 @@ function readSafeEvidenceText(repoPath, relativePath2, maxBytes) {
   if (!safe || hasSymlinkComponent(safe.root, safe.candidate)) return { status: "excluded", reason: "unsafe-path" };
   let fd;
   try {
-    fd = openSync5(safe.candidate, constants4.O_RDONLY | (constants4.O_NOFOLLOW ?? 0));
+    fd = openSync6(safe.candidate, constants5.O_RDONLY | (constants5.O_NOFOLLOW ?? 0));
   } catch {
     return { status: "excluded", reason: "not-regular" };
   }
   try {
-    const before = fstatSync2(fd);
+    const before = fstatSync3(fd);
     if (!before.isFile()) return { status: "excluded", reason: "not-regular" };
     if (before.size > maxBytes) return { status: "excluded", reason: "oversize" };
     let physical;
@@ -4961,7 +4961,7 @@ function readSafeEvidenceText(repoPath, relativePath2, maxBytes) {
       if (total > maxBytes) return { status: "excluded", reason: "oversize" };
       chunks.push(chunk.subarray(0, count));
     }
-    const after = fstatSync2(fd);
+    const after = fstatSync3(fd);
     if (after.dev !== before.dev || after.ino !== before.ino || after.size !== before.size || total !== before.size) return { status: "excluded", reason: "changed-during-read" };
     const bytes = Buffer.concat(chunks, total);
     if (bytes.includes(0)) return { status: "excluded", reason: "binary" };
@@ -4974,7 +4974,7 @@ function readSafeEvidenceText(repoPath, relativePath2, maxBytes) {
     if (looksSecret(relativePath2, content)) return { status: "excluded", reason: "secret-like" };
     return { status: "present", content, content_sha256: sha256Hex(bytes), bytes: total };
   } finally {
-    closeSync5(fd);
+    closeSync6(fd);
   }
 }
 function looksGenerated(path) {
@@ -5064,10 +5064,10 @@ var init_git_evidence = __esm({
 
 // src/notebook/remote-mutation-journal.ts
 import { randomUUID as randomUUID4 } from "node:crypto";
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function journalPath(root, projectSlug, operationId) {
   if (!/^[a-f0-9-]{16,64}$/iu.test(operationId)) throw new NotebookError("INVALID_INPUT", "Invalid remote mutation operation ID");
-  return join21(ensureNotebookState(root, projectSlug).journals, `${operationId}.json`);
+  return join22(ensureNotebookState(root, projectSlug).journals, `${operationId}.json`);
 }
 function remoteMutationJournalPath(root, projectSlug, operationId) {
   return journalPath(root, projectSlug, operationId);
@@ -5087,7 +5087,7 @@ function listRemoteMutationJournals(root, projectSlug) {
     if (!entry.isFile() || entry.isSymbolicLink() || !/^[a-f0-9-]{16,64}\.json$/iu.test(entry.name)) {
       throw new NotebookError("CONFLICT", `Remote mutation journal state-integrity finding: journals/${entry.name}`);
     }
-    const read = readNotebookStateJson(join21(paths.journals, entry.name), paths.root, 65536);
+    const read = readNotebookStateJson(join22(paths.journals, entry.name), paths.root, 65536);
     const journal = read.value === void 0 ? null : parseRemoteMutationJournal(read.value);
     if (!journal || `${journal.operation_id}.json` !== entry.name) {
       throw new NotebookError("CONFLICT", `Remote mutation journal state-integrity finding: journals/${entry.name}`);
@@ -5441,7 +5441,7 @@ var init_reconcile = __esm({
 
 // src/notebook/entropy.ts
 import { existsSync as existsSync16 } from "node:fs";
-import { createHash as createHash13 } from "node:crypto";
+import { createHash as createHash14 } from "node:crypto";
 import { resolve as resolve17 } from "node:path";
 import { spawnSync as spawnSync12 } from "node:child_process";
 function listAllTrackedDocuments(config) {
@@ -5496,7 +5496,7 @@ async function compactSessionCaptures(input) {
   const toCompact = sessionHeaders.slice(maxRecent);
   const notesToCompact = typeof input.client.hydrateNotes === "function" ? await input.client.hydrateNotes(toCompact) : toCompact;
   const archiveTitle = "Session Captures Archive (Prior Sessions)";
-  const slugHash = createHash13("sha256").update(`session-capture-archive:${input.projectSlug}`).digest("hex").slice(0, 32);
+  const slugHash = createHash14("sha256").update(`session-capture-archive:${input.projectSlug}`).digest("hex").slice(0, 32);
   const archiveLogicalId = `user-note:v1:${slugHash}`;
   let existingArchiveContent = "";
   let existingArchiveId = null;
@@ -6064,8 +6064,8 @@ var init_capture = __esm({
 
 // src/index.ts
 import { spawnSync as spawnSync18 } from "node:child_process";
-import { existsSync as existsSync26, readdirSync as readdirSync14, readFileSync as readFileSync32, statSync as statSync9 } from "node:fs";
-import { basename as basename12, join as join37, resolve as resolve25 } from "node:path";
+import { existsSync as existsSync26, readdirSync as readdirSync15, readFileSync as readFileSync33, statSync as statSync9 } from "node:fs";
+import { basename as basename13, join as join38, resolve as resolve25 } from "node:path";
 import { Command as Command3, CommanderError, Option } from "commander";
 
 // src/recipes/Recipe.ts
@@ -8042,20 +8042,20 @@ function planSkillRoots(repoRoot, options = {}) {
     for (const name of readdirSync6(real).sort()) {
       const path = join7(real, name);
       const label = `${alias}/${name}`;
-      const entryStat = lstatSync6(path);
+      const entryStat2 = lstatSync6(path);
       const rows = tracked.get(name) ?? [];
-      const candidate = { alias, name, path, label, kind: entryStat.isSymbolicLink() ? "link" : entryStat.isDirectory() ? "directory" : "file", tracked: rows.map((row) => row.path) };
+      const candidate = { alias, name, path, label, kind: entryStat2.isSymbolicLink() ? "link" : entryStat2.isDirectory() ? "directory" : "file", tracked: rows.map((row) => row.path) };
       if (name === ".git") {
         candidate.staticBlock = `${label} is git metadata; refusing to relocate another repository's work tree`;
-      } else if (entryStat.isSymbolicLink()) {
+      } else if (entryStat2.isSymbolicLink()) {
         candidate.text = readlinkSync5(path);
         candidate.resolution = resolveIn(diskLayout, path);
         if (rows.length) candidate.staticBlock = `${label} -> ${candidate.text} is tracked in git; a tracked link cannot be attested BMAD installer output, so it is never untracked, moved or dropped`;
-      } else if (!entryStat.isDirectory() && !entryStat.isFile()) {
+      } else if (!entryStat2.isDirectory() && !entryStat2.isFile()) {
         candidate.staticBlock = `${label} is a special file; refusing to relocate it`;
       } else {
         candidate.staticBlock = entryHazard(path, label);
-        if (!candidate.staticBlock && rootDevice !== void 0 && entryStat.dev !== rootDevice) candidate.staticBlock = `${label} is on a different filesystem than .agents/skills; refusing a copying move`;
+        if (!candidate.staticBlock && rootDevice !== void 0 && entryStat2.dev !== rootDevice) candidate.staticBlock = `${label} is on a different filesystem than .agents/skills; refusing a copying move`;
         const linkRow = rows.find((row) => row.mode === "120000");
         const gitlink = rows.find((row) => row.mode === "160000");
         if (!candidate.staticBlock && gitlink) candidate.staticBlock = `${label} holds a tracked submodule (${gitlink.path}); refusing to relocate it`;
@@ -10031,14 +10031,324 @@ function createG33CompanionCheck() {
 }
 
 // src/parity/rules.ts
-import { existsSync as existsSync8, lstatSync as lstatSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync11, readlinkSync as readlinkSync8, readdirSync as readdirSync7, realpathSync as realpathSync4, renameSync as renameSync4, symlinkSync as symlinkSync3, unlinkSync as unlinkSync5, writeFileSync as writeFileSync8, chmodSync as chmodSync3, copyFileSync, rmSync as rmSync5 } from "node:fs";
-import { basename as basename4, dirname as dirname9, join as join11, relative as relative9, resolve as resolve7 } from "node:path";
+import { existsSync as existsSync8, lstatSync as lstatSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync12, readlinkSync as readlinkSync8, readdirSync as readdirSync8, realpathSync as realpathSync4, renameSync as renameSync4, symlinkSync as symlinkSync3, unlinkSync as unlinkSync6, writeFileSync as writeFileSync9, chmodSync as chmodSync3, copyFileSync, rmSync as rmSync5 } from "node:fs";
+
+// src/bmad/setup-scripts.ts
+import { createHash as createHash8 } from "node:crypto";
+import { closeSync as closeSync2, fchmodSync, fstatSync, linkSync, lstatSync as lstatSync9, mkdirSync as mkdirSync6, mkdtempSync as mkdtempSync2, openSync as openSync2, readFileSync as readFileSync10, readdirSync as readdirSync7, rmdirSync as rmdirSync3, unlinkSync as unlinkSync5, writeFileSync as writeFileSync7, constants as constants2 } from "node:fs";
+import { basename as basename4, join as join10 } from "node:path";
+function entryStat(path) {
+  try {
+    return lstatSync9(path);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+var RUNTIME_SCRIPTS = ["config_utils.py", "memlog.py", "render_skill.py", "resolve_config.py", "resolve_customization.py"];
+function manifestRows(text2) {
+  const rows = [];
+  let row = [], field2 = "", quoted = false, closed = false, inQuotes = false;
+  for (let i = 0; i < text2.length; i++) {
+    const c = text2[i];
+    if (inQuotes) {
+      if (c === '"' && text2[i + 1] === '"') {
+        field2 += '"';
+        i++;
+      } else if (c === '"') {
+        inQuotes = false;
+        closed = true;
+      } else field2 += c;
+    } else if (c === '"' && !field2 && !closed) {
+      inQuotes = true;
+      quoted = true;
+    } else if (c === ",") {
+      row.push(field2);
+      field2 = "";
+      quoted = closed = false;
+    } else if (c === "\n" || c === "\r") {
+      if (c === "\r" && text2[i + 1] === "\n") i++;
+      row.push(field2);
+      if (row.length !== 1 || row[0]) rows.push(row);
+      row = [];
+      field2 = "";
+      quoted = closed = false;
+    } else if (closed || c === '"' || quoted && c === "\r") throw new Error("Malformed BMAD file manifest CSV");
+    else field2 += c;
+  }
+  if (inQuotes) throw new Error("Unterminated BMAD file manifest CSV field");
+  if (row.length || field2 || closed) {
+    row.push(field2);
+    rows.push(row);
+  }
+  if (rows.some((r) => r.length !== 5) || rows[0]?.join("\0") !== "type\0name\0module\0path\0hash") {
+    throw new Error("Invalid BMAD file manifest columns");
+  }
+  return rows.slice(1);
+}
+function sameIdentity(a, b) {
+  return !!a && a.dev === b.dev && a.ino === b.ino && a.isDirectory() && !a.isSymbolicLink();
+}
+var DeclinableError = class extends Error {
+  constructor(message2, kind) {
+    super(message2);
+    this.kind = kind;
+  }
+};
+var FIELD_SEP = String.fromCharCode(0);
+var MANIFEST_UNUSABLE = "Installed BMAD file manifest is missing or not a real file; cannot attest recovered scripts";
+function inspectBmadSetupScripts(repoRoot, version, installedVersion) {
+  const bmadDir = join10(repoRoot, "_bmad");
+  const dest = join10(bmadDir, "scripts");
+  try {
+    const bmad = entryStat(bmadDir);
+    if (!bmad) return { state: "decline", why: "_bmad is absent", missing: [...RUNTIME_SCRIPTS] };
+    if (!bmad.isDirectory() || bmad.isSymbolicLink()) return { state: "unsafe", error: "_bmad is not a real directory" };
+    const destStat = entryStat(dest);
+    if (destStat && (!destStat.isDirectory() || destStat.isSymbolicLink())) return { state: "unsafe", error: "_bmad/scripts is not a real directory" };
+    const missing = [];
+    for (const name of RUNTIME_SCRIPTS) {
+      const existing = destStat ? entryStat(join10(dest, name)) : void 0;
+      if (!existing) missing.push(name);
+      else if (!existing.isFile() || existing.isSymbolicLink()) return { state: "unsafe", error: `Existing _bmad/scripts/${name} is not a regular file; refusing overwrite` };
+    }
+    if (!missing.length) return { state: "present" };
+    const configDir = entryStat(join10(bmadDir, "_config"));
+    if (configDir && (!configDir.isDirectory() || configDir.isSymbolicLink())) return { state: "unsafe", error: MANIFEST_UNUSABLE };
+    const manifestPath = join10(bmadDir, "_config", "files-manifest.csv");
+    const manifestFile = configDir ? entryStat(manifestPath) : void 0;
+    if (!manifestFile) return { state: "decline", why: "_bmad/_config/files-manifest.csv is absent, so recovered scripts cannot be attested", missing };
+    if (!manifestFile.isFile() || manifestFile.isSymbolicLink()) return { state: "unsafe", error: MANIFEST_UNUSABLE };
+    const installed = installedVersion?.();
+    if (installed && installed !== version) {
+      return { state: "decline", why: `this install is bmad-method ${installed}, not the pinned ${version} that recovery restores from`, missing };
+    }
+    const rows = manifestRows(readFileSync10(manifestPath, "utf8"));
+    const unattested = missing.filter((name) => !rows.some((row) => row[3] === `scripts/${name}`));
+    if (unattested.length) {
+      return { state: "decline", why: `_bmad/_config/files-manifest.csv has no row for ${unattested.map((name) => `scripts/${name}`).join(", ")}, so recovered scripts cannot be attested`, missing };
+    }
+    return { state: "missing", missing };
+  } catch (error) {
+    return { state: "unsafe", error: error instanceof Error ? error.message : String(error) };
+  }
+}
+function planBmadSetupScripts(repoRoot, pkg, version) {
+  const dest = join10(repoRoot, "_bmad", "scripts");
+  if (!pkg.root || !pkg.entry || pkg.version !== version) return { files: [], declinable: "package", error: `Pinned bmad-method@${version} package could not be resolved: ${pkg.reason ?? "version mismatch"}` };
+  let fingerprint2;
+  try {
+    fingerprint2 = installerFingerprint(pkg.root);
+  } catch (error) {
+    return { files: [], declinable: "package", error: `Could not fingerprint pinned BMAD installer: ${String(error)}` };
+  }
+  if (VERIFIED_BMAD_INSTALLERS[fingerprint2] !== version) return { files: [], declinable: "package", error: `Unverified BMAD installer fingerprint ${fingerprint2}; refusing script recovery` };
+  const source = join10(pkg.root, "src", "scripts");
+  try {
+    const bmad = lstatSync9(join10(repoRoot, "_bmad"));
+    if (!bmad.isDirectory() || bmad.isSymbolicLink()) throw new Error("_bmad is not a real directory");
+    const destStat = entryStat(dest);
+    if (destStat && (!destStat.isDirectory() || destStat.isSymbolicLink())) throw new Error("_bmad/scripts is not a real directory");
+    const names = readdirSync7(source).filter((name) => !name.startsWith(".") && !name.endsWith(".pyc") && name !== "tests" && name !== "__pycache__" && name !== ".pytest_cache").sort();
+    if (names.join(FIELD_SEP) !== [...RUNTIME_SCRIPTS].sort().join(FIELD_SEP)) throw new DeclinableError("Pinned installer script inventory changed; refusing recovery", "package");
+    const missing = [];
+    for (const name of names) {
+      const existing = entryStat(join10(dest, name));
+      if (!existing) missing.push(name);
+      else if (!existing.isFile() || existing.isSymbolicLink()) throw new Error(`Existing _bmad/scripts/${name} is not a regular file; refusing overwrite`);
+    }
+    const files = [];
+    if (!missing.length) return { files, source };
+    const manifestPath = join10(repoRoot, "_bmad", "_config", "files-manifest.csv");
+    const manifestDir = entryStat(join10(repoRoot, "_bmad", "_config"));
+    const manifestFile = entryStat(manifestPath);
+    if (!manifestDir?.isDirectory() || manifestDir.isSymbolicLink() || !manifestFile?.isFile() || manifestFile.isSymbolicLink()) {
+      throw new Error(MANIFEST_UNUSABLE);
+    }
+    const rows = manifestRows(readFileSync10(manifestPath, "utf8"));
+    for (const name of missing) {
+      const src = join10(source, name);
+      if (!lstatSync9(src).isFile() || lstatSync9(src).isSymbolicLink()) throw new DeclinableError(`Installer script is not a regular file: ${name}`, "package");
+      const matching = rows.filter((row) => row[3] === `scripts/${name}`);
+      const expectedHash = createHash8("sha256").update(readFileSync10(src)).digest("hex");
+      if (matching.length !== 1 || matching[0].join(FIELD_SEP) !== ["py", name.slice(0, -3), "scripts", `scripts/${name}`, expectedHash].join(FIELD_SEP)) {
+        throw new DeclinableError(`Installed file manifest does not attest pinned script ${name}`, "attest");
+      }
+      files.push(join10(dest, name));
+    }
+    return { files, source };
+  } catch (error) {
+    return { files: [], ...error instanceof DeclinableError ? { declinable: error.kind } : {}, error: `BMAD script recovery refused: ${error instanceof Error ? error.message : String(error)}` };
+  }
+}
+function applyBmadSetupScripts(repoRoot, pkg, version, afterPublish) {
+  const plan = planBmadSetupScripts(repoRoot, pkg, version);
+  if (plan.error || !plan.files.length) return { files: [], ...plan.error ? { error: plan.error } : {} };
+  const parent = join10(repoRoot, "_bmad");
+  const dest = join10(parent, "scripts");
+  const expectedParent = entryStat(parent);
+  const expectedDir = entryStat(dest);
+  let stage;
+  let stageFd;
+  let parentFd;
+  const created = [];
+  const stagedIdentities = /* @__PURE__ */ new Map();
+  const published = /* @__PURE__ */ new Map();
+  let ambiguousPublication;
+  const matchesPayload = (path, owned) => {
+    const stat = entryStat(path);
+    return !!stat?.isFile() && !stat.isSymbolicLink() && stat.dev === owned.dev && stat.ino === owned.ino && (stat.mode & 4095) === owned.mode && readFileSync10(path).equals(owned.bytes);
+  };
+  let madeDir = false;
+  let dirFd;
+  let result2 = { files: [] };
+  try {
+    parentFd = openSync2(parent, constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW);
+    const pinnedParent = fstatSync(parentFd);
+    if (!sameIdentity(expectedParent, pinnedParent) || !sameIdentity(entryStat(parent), pinnedParent)) throw new Error("BMAD parent directory changed before staging");
+    const anchoredParent = `/proc/self/fd/${parentFd}`;
+    stage = mkdtempSync2(join10(anchoredParent, ".scripts-stage-"));
+    stageFd = openSync2(stage, constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW);
+    const pinnedStage = fstatSync(stageFd);
+    const stageName = basename4(stage);
+    const anchoredStage = `/proc/self/fd/${stageFd}`;
+    if (!sameIdentity(entryStat(join10(anchoredParent, stageName)), pinnedStage)) throw new Error("Staging directory changed during creation");
+    for (const path of plan.files) {
+      const name = basename4(path);
+      const src = join10(plan.source, name);
+      const staged = join10(anchoredStage, name);
+      const fileFd = openSync2(staged, constants2.O_WRONLY | constants2.O_CREAT | constants2.O_EXCL | constants2.O_NOFOLLOW, 384);
+      try {
+        const stat = fstatSync(fileFd);
+        const bytes = readFileSync10(src);
+        const mode = lstatSync9(src).mode & 4095;
+        stagedIdentities.set(name, { dev: stat.dev, ino: stat.ino, bytes, mode });
+        writeFileSync7(fileFd, bytes);
+        fchmodSync(fileFd, mode);
+      } finally {
+        closeSync2(fileFd);
+      }
+    }
+    if (!sameIdentity(entryStat(parent), pinnedParent)) throw new Error("BMAD parent directory changed while staging");
+    const current = planBmadSetupScripts(repoRoot, pkg, version);
+    if (current.error || current.files.join("\0") !== plan.files.join("\0")) throw new Error(current.error ?? "Script destination changed while staging");
+    const anchoredDest = join10(anchoredParent, "scripts");
+    if (!entryStat(anchoredDest)) {
+      mkdirSync6(anchoredDest);
+      madeDir = true;
+    }
+    dirFd = openSync2(anchoredDest, constants2.O_RDONLY | constants2.O_DIRECTORY | constants2.O_NOFOLLOW);
+    const pinned = fstatSync(dirFd);
+    if (expectedDir && !sameIdentity(expectedDir, pinned)) throw new Error("Script directory changed while staging");
+    if (!sameIdentity(entryStat(parent), pinnedParent) || !sameIdentity(entryStat(dest), pinned)) throw new Error("Script or parent directory changed during publication");
+    const anchored = `/proc/self/fd/${dirFd}`;
+    for (const path of plan.files) {
+      const name = basename4(path);
+      const staged = join10(anchoredStage, name);
+      const output = join10(anchored, name);
+      const owned = stagedIdentities.get(name);
+      if (!sameIdentity(entryStat(parent), pinnedParent) || !sameIdentity(entryStat(dest), pinned)) throw new Error("Script or parent directory changed during publication");
+      if (!matchesPayload(staged, owned)) throw new Error(`Staged script changed before publication: ${name}`);
+      if (entryStat(output)) {
+        ambiguousPublication = path;
+        throw new Error(`Script destination appeared before publication: ${name}`);
+      }
+      try {
+        linkSync(staged, output);
+      } catch (error) {
+        if (entryStat(output)) ambiguousPublication = path;
+        throw error;
+      }
+      published.set(path, owned);
+      created.push(path);
+      if (!matchesPayload(output, owned)) throw new Error(`Published script changed during publication: ${name}`);
+      afterPublish?.(created.length);
+    }
+    if (!sameIdentity(entryStat(parent), pinnedParent) || !sameIdentity(entryStat(dest), pinned)) throw new Error("Script or parent directory changed during publication");
+    for (const path of created) {
+      if (!matchesPayload(join10(anchored, basename4(path)), stagedIdentities.get(basename4(path)))) throw new Error(`Published script changed before completion: ${basename4(path)}`);
+    }
+    result2 = { files: created };
+  } catch (error) {
+    const recoveryErrors = [];
+    for (const [path, owned] of [...published].reverse()) {
+      try {
+        const anchoredPath = join10(`/proc/self/fd/${dirFd}`, basename4(path));
+        const stat = entryStat(anchoredPath);
+        if (matchesPayload(anchoredPath, owned)) unlinkSync5(anchoredPath);
+        else if (stat) recoveryErrors.push(`Concurrent replacement or mutation retained: ${path}`);
+        else recoveryErrors.push(`Published file absent from pinned directory; ownership unresolved: ${path}`);
+      } catch (recoveryError) {
+        recoveryErrors.push(`Could not restore ${path}: ${String(recoveryError)}`);
+      }
+    }
+    if (ambiguousPublication) recoveryErrors.push(`Publication not confirmed; destination retained or ownership unresolved: ${ambiguousPublication}`);
+    if (madeDir && dirFd !== void 0 && parentFd !== void 0) {
+      try {
+        const pinned = fstatSync(dirFd);
+        const anchoredDest = join10(`/proc/self/fd/${parentFd}`, "scripts");
+        if (sameIdentity(entryStat(anchoredDest), pinned) && readdirSync7(anchoredDest).length === 0) rmdirSync3(anchoredDest);
+        else recoveryErrors.push(`Created script directory moved or retained: ${dest}`);
+      } catch (recoveryError) {
+        recoveryErrors.push(`Could not remove empty script directory: ${String(recoveryError)}`);
+      }
+    }
+    result2 = { files: [], error: `BMAD script recovery failed: ${error instanceof Error ? error.message : String(error)}${recoveryErrors.length ? `; recovery incomplete: ${recoveryErrors.join("; ")}` : ""}` };
+  } finally {
+    const cleanupErrors = [];
+    if (stageFd !== void 0) {
+      try {
+        const pinnedStage = fstatSync(stageFd);
+        const anchoredStage = `/proc/self/fd/${stageFd}`;
+        for (const [name, owned] of stagedIdentities) {
+          const staged = join10(anchoredStage, name);
+          const stat = entryStat(staged);
+          if (stat?.isFile() && !stat.isSymbolicLink() && stat.dev === owned.dev && stat.ino === owned.ino) unlinkSync5(staged);
+          else cleanupErrors.push(`Staged file replaced, modified or absent: ${name}`);
+        }
+        const stagePath = join10(`/proc/self/fd/${parentFd}`, basename4(stage));
+        if (sameIdentity(entryStat(stagePath), pinnedStage) && readdirSync7(anchoredStage).length === 0) rmdirSync3(stagePath);
+        else cleanupErrors.push(`Staging directory moved or contains foreign entries: ${join10(parent, basename4(stage))}`);
+      } catch (cleanupError) {
+        cleanupErrors.push(`Could not clean owned staging directory: ${String(cleanupError)}`);
+      }
+      closeSync2(stageFd);
+    } else if (stage) cleanupErrors.push(`Staging directory identity unavailable: ${join10(parent, basename4(stage))}`);
+    if (cleanupErrors.length && result2.files.length) {
+      for (const [path, owned] of [...published].reverse()) {
+        try {
+          const output = join10(`/proc/self/fd/${dirFd}`, basename4(path));
+          if (matchesPayload(output, owned)) unlinkSync5(output);
+          else cleanupErrors.push(`Concurrent replacement or mutation retained: ${path}`);
+        } catch (error) {
+          cleanupErrors.push(`Could not restore ${path}: ${String(error)}`);
+        }
+      }
+      if (madeDir && dirFd !== void 0 && parentFd !== void 0) {
+        try {
+          const anchoredDest = join10(`/proc/self/fd/${parentFd}`, "scripts");
+          if (sameIdentity(entryStat(anchoredDest), fstatSync(dirFd)) && readdirSync7(anchoredDest).length === 0) rmdirSync3(anchoredDest);
+          else cleanupErrors.push(`Created script directory moved or retained: ${dest}`);
+        } catch (error) {
+          cleanupErrors.push(`Could not remove empty script directory: ${String(error)}`);
+        }
+      }
+    }
+    if (dirFd !== void 0) closeSync2(dirFd);
+    if (parentFd !== void 0) closeSync2(parentFd);
+    if (cleanupErrors.length) result2 = { files: [], error: `${result2.error ? `${result2.error}; ` : "BMAD script staging cleanup incomplete: "}recovery incomplete: ${cleanupErrors.join("; ")}` };
+  }
+  return result2;
+}
+
+// src/parity/rules.ts
+import { basename as basename5, dirname as dirname9, join as join12, relative as relative9, resolve as resolve7 } from "node:path";
 import { spawnSync as spawnSync5 } from "node:child_process";
 import YAML4 from "yaml";
 
 // src/bmad/reserved-modules.ts
-import { existsSync as existsSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join10 } from "node:path";
+import { existsSync as existsSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync8 } from "node:fs";
+import { join as join11 } from "node:path";
 import YAML3 from "yaml";
 var BMAD_RESERVED_DIR_NAMES = ["custom", "scripts", "_config", "_memory", "memory", "render"];
 var indentOf = (line) => line.length - line.trimStart().length;
@@ -10095,19 +10405,19 @@ function stripReservedModuleEntries(raw) {
   return { text: lines.filter((_, index) => !drop.has(index)).join(""), evicted };
 }
 function evictReservedModuleEntries(repoRoot, dryRun) {
-  const manifestPath = join10(repoRoot, "_bmad", "_config", "manifest.yaml");
+  const manifestPath = join11(repoRoot, "_bmad", "_config", "manifest.yaml");
   const none = { evicted: [], changedFiles: [], details: [] };
   if (!existsSync7(manifestPath)) return none;
   let original;
   try {
-    original = readFileSync10(manifestPath, "utf8");
+    original = readFileSync11(manifestPath, "utf8");
   } catch {
     return none;
   }
   const stripped = stripReservedModuleEntries(original);
   if (!stripped) return none;
   const names = stripped.evicted.map((name) => `"${name}"`).join(", ");
-  if (!dryRun) writeFileSync7(manifestPath, stripped.text, "utf8");
+  if (!dryRun) writeFileSync8(manifestPath, stripped.text, "utf8");
   return {
     evicted: stripped.evicted,
     changedFiles: [manifestPath],
@@ -10821,17 +11131,17 @@ function normalizeNewlines(value) {
   return value.replace(/\r\n/g, "\n");
 }
 function readText(path) {
-  return normalizeNewlines(readFileSync11(path, "utf8"));
+  return normalizeNewlines(readFileSync12(path, "utf8"));
 }
 function safeReadText2(path) {
   return existsSync8(path) ? readText(path) : null;
 }
 function ensureParent(path) {
-  mkdirSync6(dirname9(path), { recursive: true });
+  mkdirSync7(dirname9(path), { recursive: true });
 }
 function writeText(path, content) {
   ensureParent(path);
-  writeFileSync8(path, content);
+  writeFileSync9(path, content);
 }
 function tryParseJson(text2) {
   if (!text2) return null;
@@ -10857,12 +11167,12 @@ function readSymlinkTarget(path) {
 }
 function ensureSymlink(path, target, dryRun) {
   if (existsSync8(path)) {
-    const stat = lstatSync9(path);
+    const stat = lstatSync10(path);
     if (stat.isSymbolicLink()) {
       const current = readSymlinkTarget(path);
       if (current === target) return { changed: false };
       if (!dryRun) {
-        unlinkSync5(path);
+        unlinkSync6(path);
         symlinkSync3(target, path);
       }
       return { changed: true };
@@ -10873,12 +11183,12 @@ function ensureSymlink(path, target, dryRun) {
   return { changed: true };
 }
 function bootstrapAgentsFile(repoRoot, dryRun) {
-  const agentsPath = join11(repoRoot, "AGENTS.md");
+  const agentsPath = join12(repoRoot, "AGENTS.md");
   if (existsSync8(agentsPath)) return { changedFiles: [], details: [] };
   for (const file of ["CLAUDE.md", "GEMINI.md"]) {
-    const source = join11(repoRoot, file);
+    const source = join12(repoRoot, file);
     if (!existsSync8(source)) continue;
-    const stat = lstatSync9(source);
+    const stat = lstatSync10(source);
     if (stat.isSymbolicLink()) continue;
     if (stat.isFile()) {
       if (!dryRun) renameSync4(source, agentsPath);
@@ -10886,9 +11196,9 @@ function bootstrapAgentsFile(repoRoot, dryRun) {
     }
     return { changedFiles: [], details: [], blocked: `${file} exists but is not a regular file; cannot promote to AGENTS.md` };
   }
-  const readmePath = join11(repoRoot, "README.md");
+  const readmePath = join12(repoRoot, "README.md");
   if (existsSync8(readmePath)) {
-    const stat = lstatSync9(readmePath);
+    const stat = lstatSync10(readmePath);
     if (!stat.isFile()) return { changedFiles: [], details: [], blocked: "README.md exists but is not a regular file; cannot copy to AGENTS.md" };
     if (!dryRun) copyFileSync(readmePath, agentsPath);
     return { changedFiles: [agentsPath], details: ["Copied README.md to AGENTS.md before wiring agent-file symlinks"] };
@@ -10926,11 +11236,11 @@ function yamlGet(text2, keyPath) {
   return "";
 }
 function discoverRoles(repoRoot) {
-  const rolesDir = join11(repoRoot, "agents", "hermes");
+  const rolesDir = join12(repoRoot, "agents", "hermes");
   if (!existsSync8(rolesDir)) return [];
-  return readdirSync7(rolesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => {
-    const roleDir = join11(rolesDir, entry.name);
-    const roleYamlPath = join11(roleDir, "role.yaml");
+  return readdirSync8(rolesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => {
+    const roleDir = join12(rolesDir, entry.name);
+    const roleYamlPath = join12(roleDir, "role.yaml");
     if (!existsSync8(roleYamlPath)) return null;
     const text2 = readText(roleYamlPath);
     const runtimeRepoRaw = yamlGet(text2, "runtime.github_repo");
@@ -10963,26 +11273,26 @@ function discoverRoles(repoRoot) {
   }).filter((value) => Boolean(value));
 }
 function templateScript(ctx, name) {
-  const source = join11(ctx.pjanglerRoot, ".mise", "scripts", name);
+  const source = join12(ctx.pjanglerRoot, ".mise", "scripts", name);
   return existsSync8(source) ? readText(source) : void 0;
 }
 function templateVersioningScript(ctx) {
   return templateScript(ctx, "versioning.sh");
 }
 function templateLinkAgentfilesScript(ctx) {
-  const source = join11(ctx.pjanglerRoot, "templates", "commonproject", "template", ".mise", "scripts", "link-agentfiles.sh");
+  const source = join12(ctx.pjanglerRoot, "templates", "commonproject", "template", ".mise", "scripts", "link-agentfiles.sh");
   return existsSync8(source) ? readText(source) : templateScript(ctx, "link-agentfiles.sh");
 }
 function templateMaterializeEnvScript(ctx) {
-  const source = join11(ctx.pjanglerRoot, "templates", "commonproject", "template", MATERIALIZE_ENV_SCRIPT_REL);
+  const source = join12(ctx.pjanglerRoot, "templates", "commonproject", "template", MATERIALIZE_ENV_SCRIPT_REL);
   return existsSync8(source) ? readText(source) : void 0;
 }
 function resolveAgentHooksLayer(ctx) {
   const override = process.env.PJ_AGENT_HOOKS_LAYER;
   if (override === "0" || override === "false") return false;
   if (override === "1" || override === "true") return true;
-  if (existsSync8(join11(ctx.repoRoot, ".agents", "hooks", "sync.py"))) return true;
-  return !existsSync8(join11(ctx.homeDir, ".agents", "hooks"));
+  if (existsSync8(join12(ctx.repoRoot, ".agents", "hooks", "sync.py"))) return true;
+  return !existsSync8(join12(ctx.homeDir, ".agents", "hooks"));
 }
 function evaluateMiseConditionals(template, agentHooksLayer) {
   const out = [];
@@ -11008,13 +11318,13 @@ function evaluateMiseConditionals(template, agentHooksLayer) {
 }
 function renderGeneratedProjectMiseToml(ctx, template) {
   const project = readProjectJson(ctx);
-  const projectName = String(project?.project_name ?? basename4(ctx.repoRoot) ?? "project");
+  const projectName = String(project?.project_name ?? basename5(ctx.repoRoot) ?? "project");
   return evaluateMiseConditionals(template, resolveAgentHooksLayer(ctx)).replace(/\{%\s*raw\s*%\}([\s\S]*?)\{%\s*endraw\s*%\}/g, "$1").replace(/\{\{\s*project_name\s*\}\}/g, projectName);
 }
 function ensureMiseTomlFromTemplate(ctx, changedFiles) {
-  const targetPath = join11(ctx.repoRoot, "mise.toml");
+  const targetPath = join12(ctx.repoRoot, "mise.toml");
   if (existsSync8(targetPath)) return null;
-  const sourcePath = join11(ctx.pjanglerRoot, "templates", "commonproject", "template", "mise.toml.jinja");
+  const sourcePath = join12(ctx.pjanglerRoot, "templates", "commonproject", "template", "mise.toml.jinja");
   if (!existsSync8(sourcePath)) return null;
   const rendered = renderGeneratedProjectMiseToml(ctx, readText(sourcePath));
   changedFiles.push(targetPath);
@@ -11022,12 +11332,12 @@ function ensureMiseTomlFromTemplate(ctx, changedFiles) {
   return rendered;
 }
 function templateCommonProjectText(ctx, rel) {
-  const path = join11(ctx.pjanglerRoot, "templates", "commonproject", "template", rel);
+  const path = join12(ctx.pjanglerRoot, "templates", "commonproject", "template", rel);
   return existsSync8(path) ? readText(path) : void 0;
 }
 function lstatIfPresent(path) {
   try {
-    return lstatSync9(path);
+    return lstatSync10(path);
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw error;
@@ -11035,7 +11345,7 @@ function lstatIfPresent(path) {
 }
 function templateVersionFilesConf(ctx, repoRoot) {
   if (isObsidianPluginRepo(ctx, repoRoot)) return OBSIDIAN_VERSION_FILES_CONF;
-  const packageJson = join11(repoRoot, "package.json");
+  const packageJson = join12(repoRoot, "package.json");
   return existsSync8(packageJson) ? "# mise-versioning manifest: <type> <path>\n# types: json toml cargo csproj gradle plain gittag\njson package.json\ngittag .\n" : "# mise-versioning manifest: <type> <path>\n# types: json toml cargo csproj gradle plain gittag\ngittag .\n";
 }
 var OBSIDIAN_VERSION_FILES_CONF = "# mise-versioning manifest: <type> <path>\n# types: json toml cargo csproj gradle plain gittag obsidian\n# Obsidian plugin: bump with `mise run version:bump`, release with `npm version` (bare X.Y.Z tag).\njson package.json\nobsidian manifest.json\n";
@@ -11045,7 +11355,7 @@ function recordedProjectType(ctx) {
 function isObsidianPluginRepo(ctx, repoRoot) {
   const recorded = recordedProjectType(ctx);
   if (recorded !== void 0) return recorded === "obsidian-plugin";
-  const manifest = record2(tryParseJson(safeReadText2(join11(repoRoot, "manifest.json"))));
+  const manifest = record2(tryParseJson(safeReadText2(join12(repoRoot, "manifest.json"))));
   return typeof manifest.id === "string" && typeof manifest.minAppVersion === "string";
 }
 function unsupportedVersionTypes(conf, script) {
@@ -11506,7 +11816,7 @@ function describeRewrite(before, after) {
   return difference ? `migrate would still rewrite ${difference} in mise.toml` : "migrate would still re-lay out mise.toml (its meaning is unchanged)";
 }
 function readProjectJson(ctx) {
-  return tryParseJson(safeReadText2(join11(ctx.repoRoot, ".project.json")));
+  return tryParseJson(safeReadText2(join12(ctx.repoRoot, ".project.json")));
 }
 function readDeclaredAgents(ctx) {
   const project = readProjectJson(ctx);
@@ -11523,7 +11833,7 @@ function readDeclaredAgents(ctx) {
   });
 }
 function readRoleYamlAt(roleDir) {
-  const roleYamlPath = join11(roleDir, "role.yaml");
+  const roleYamlPath = join12(roleDir, "role.yaml");
   if (!existsSync8(roleYamlPath)) return null;
   const text2 = readText(roleYamlPath);
   return {
@@ -11535,7 +11845,7 @@ function readRoleYamlAt(roleDir) {
 }
 function declaredRoleIsUnprovisioned(repoRoot, roleDir) {
   if (!roleDir) return true;
-  return !existsSync8(join11(resolve7(repoRoot, roleDir), "role.yaml"));
+  return !existsSync8(join12(resolve7(repoRoot, roleDir), "role.yaml"));
 }
 function validateDeclaredAgent(ctx, declared) {
   const details = [];
@@ -11560,11 +11870,11 @@ function validateDeclaredAgent(ctx, declared) {
     details.push(`agents.${declared.agentId} should map to agent_id ${roleYaml.agentId}`);
   }
   if (roleYaml.providerName) {
-    const dispatcher = join11(roleDir, ".scripts", "lib", "ticket-provider.sh");
+    const dispatcher = join12(roleDir, ".scripts", "lib", "ticket-provider.sh");
     if (!existsSync8(dispatcher)) {
       details.push(`agents.${declared.agentId} provider dispatcher ${relative9(ctx.repoRoot, dispatcher)} missing`);
     }
-    const provider = join11(roleDir, ".scripts", "providers", `${roleYaml.providerName}.sh`);
+    const provider = join12(roleDir, ".scripts", "providers", `${roleYaml.providerName}.sh`);
     if (!existsSync8(provider)) {
       details.push(`agents.${declared.agentId} provider script ${relative9(ctx.repoRoot, provider)} missing`);
     }
@@ -11580,7 +11890,7 @@ function repoPathNamesRoot(value, repoRoot, homeDir) {
 function canonicalProjectJson(ctx) {
   const roles = discoverRoles(ctx.repoRoot);
   const existing = readProjectJson(ctx) ?? {};
-  const slug = normalizeProjectId(existing.project_id ?? existing.project_slug ?? slugifyRepoName(basename4(ctx.repoRoot)));
+  const slug = normalizeProjectId(existing.project_id ?? existing.project_slug ?? slugifyRepoName(basename5(ctx.repoRoot)));
   const firstRole = roles[0];
   const ticketProvider = {
     ...existing.ticket_provider,
@@ -11650,8 +11960,8 @@ function canonicalProjectJson(ctx) {
   };
 }
 function projectJsonFinding(ctx) {
-  const projectPath = join11(ctx.repoRoot, ".project.json");
-  const planeJsonPath = join11(ctx.repoRoot, ".plane.json");
+  const projectPath = join12(ctx.repoRoot, ".project.json");
+  const planeJsonPath = join12(ctx.repoRoot, ".plane.json");
   const details = [];
   const data = readProjectJson(ctx);
   const roles = discoverRoles(ctx.repoRoot);
@@ -11722,7 +12032,7 @@ var BMAD_DIST_TAGS_TTL_MS = 60 * 60 * 1e3;
 var DEFAULT_BMAD_MODULES = ["bmm", "bmb", "cis"];
 var BMAD_INSTALL_TOOLS = SUPPORTED_BMAD_TOOLS;
 function manifestBmadModules(repoRoot) {
-  const manifestPath = join11(repoRoot, "_bmad", "_config", "manifest.yaml");
+  const manifestPath = join12(repoRoot, "_bmad", "_config", "manifest.yaml");
   const raw = safeReadText2(manifestPath);
   if (raw === null) return { status: "absent" };
   try {
@@ -11750,7 +12060,7 @@ function manifestBmadModules(repoRoot) {
   }
 }
 function configuredBmadModuleSelection(repoRoot) {
-  const raw = safeReadText2(join11(repoRoot, "_bmad", "config.toml"));
+  const raw = safeReadText2(join12(repoRoot, "_bmad", "config.toml"));
   if (raw === null) return void 0;
   const modules = [...raw.matchAll(/^\[modules\.([A-Za-z0-9][A-Za-z0-9_-]*)\]\s*$/gm)].map((match) => match[1]);
   return { modules: Array.from(new Set(modules)).filter((name) => name !== "g33"), hasG33: modules.includes("g33") };
@@ -11761,24 +12071,60 @@ function selectedBmadModules(repoRoot) {
   if (manifest.status === "invalid") throw new Error(manifest.error);
   return configuredBmadModuleSelection(repoRoot)?.modules ?? [...DEFAULT_BMAD_MODULES];
 }
-function requiredBmadSentinels(repoRoot, modules = selectedBmadModules(repoRoot)) {
-  return [
-    join11("core", "config.yaml"),
-    join11("config.toml"),
-    join11("_config", "manifest.yaml"),
-    ...modules.map((module) => join11(module, "config.yaml"))
-  ];
+var BMAD_RUNTIME_SCRIPT_SENTINELS = ["resolve_config.py", "config_utils.py"];
+function consolidatedBmadConfig(repoRoot) {
+  const path = join12(repoRoot, "_bmad", "config.yaml");
+  if (!existsSync8(path)) return { status: "absent" };
+  let parsed;
+  try {
+    parsed = YAML4.parse(readText(path));
+  } catch (error) {
+    return { status: "unusable", reason: `could not be parsed: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}` };
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return { status: "unusable", reason: "is not a YAML mapping" };
+  }
+  return { status: "mapping", sections: new Set(Object.keys(parsed)) };
+}
+function bmadSentinelGaps(repoRoot, modules = selectedBmadModules(repoRoot)) {
+  const bmad = join12(repoRoot, "_bmad");
+  const gaps = [];
+  const absent = (...segments) => !existsSync8(join12(bmad, ...segments));
+  if (absent("config.toml")) gaps.push({ path: "config.toml", detail: "_bmad/config.toml" });
+  for (const script of BMAD_RUNTIME_SCRIPT_SENTINELS) {
+    if (absent("scripts", script)) gaps.push({ path: join12("scripts", script), detail: `_bmad/scripts/${script}` });
+  }
+  if (absent("_config", "manifest.yaml")) {
+    gaps.push({
+      path: join12("_config", "manifest.yaml"),
+      detail: existsSync8(bmad) ? "_bmad/_config/manifest.yaml (the installer's install record). BMB setup's `--also-remove _config` cleanup is the likely cause: it deletes all of _bmad/_config. Restore it with: pj migrate bmad.scaffold" : "_bmad/_config/manifest.yaml"
+    });
+  }
+  let consolidated;
+  for (const module of modules) {
+    if (!absent(module, "config.yaml")) continue;
+    consolidated ??= consolidatedBmadConfig(repoRoot);
+    if (consolidated.status === "mapping" && consolidated.sections.has(module)) continue;
+    const why = consolidated.status === "absent" ? "" : consolidated.status === "unusable" ? ` (and _bmad/config.yaml ${consolidated.reason}, so it cannot supply a ${module} section)` : ` (and _bmad/config.yaml has no ${module} section)`;
+    gaps.push({ path: join12(module, "config.yaml"), detail: `_bmad/${module}/config.yaml${why}` });
+  }
+  return gaps;
+}
+function bmadScaffoldIssues(repoRoot, modules) {
+  const gaps = bmadSentinelGaps(repoRoot, modules);
+  const nameIssues = bmadProjectNameIssues(repoRoot);
+  return { gaps, nameIssues, details: [...gaps.map((gap) => gap.detail), ...nameIssues.details] };
 }
 function canonicalBmadProjectName(repoRoot) {
   const project = readProjectJson({ repoRoot });
   const declared = typeof project?.project_name === "string" ? project.project_name.trim() : "";
-  return declared || basename4(repoRoot);
+  return declared || basename5(repoRoot);
 }
 function bmadProjectNameIssues(repoRoot) {
   const expected = canonicalBmadProjectName(repoRoot);
   const paths = [];
   const details = [];
-  const configToml = join11(repoRoot, "_bmad", "config.toml");
+  const configToml = join12(repoRoot, "_bmad", "config.toml");
   const tomlText = safeReadText2(configToml);
   const tomlMatch = tomlText?.match(/^project_name\s*=\s*"((?:\\.|[^"\\])*)"\s*$/m);
   let tomlName;
@@ -11793,16 +12139,16 @@ function bmadProjectNameIssues(repoRoot) {
     paths.push(configToml);
     details.push(`_bmad/config.toml project_name must be ${JSON.stringify(expected)}`);
   }
-  const bmadRoot = join11(repoRoot, "_bmad");
+  const bmadRoot = join12(repoRoot, "_bmad");
   if (existsSync8(bmadRoot)) {
     let declared;
     try {
       declared = selectedBmadModules(repoRoot);
     } catch {
-      declared = readdirSync7(bmadRoot);
+      declared = readdirSync8(bmadRoot);
     }
     for (const name of new Set(declared)) {
-      const configPath = join11(bmadRoot, name, "config.yaml");
+      const configPath = join12(bmadRoot, name, "config.yaml");
       const raw = safeReadText2(configPath);
       if (raw === null) continue;
       let actual;
@@ -11822,7 +12168,7 @@ function bmadProjectNameIssues(repoRoot) {
 function isCurrentActivation(path, activations) {
   if (activations.owned.has(path)) return true;
   try {
-    if (activations.owned.has(join11(realpathSync4(dirname9(path)), basename4(path)))) return true;
+    if (activations.owned.has(join12(realpathSync4(dirname9(path)), basename5(path)))) return true;
     return activations.targets.has(realpathSync4(path));
   } catch {
     return false;
@@ -11835,26 +12181,26 @@ async function skillActivations(ctx) {
 function evictLegacyBmadPackState(ctx, changedFiles, activations) {
   const details = [];
   const skillDirs = [
-    join11(ctx.repoRoot, ".agents", "skills"),
-    ...SUPPORTED_CLI_ROOTS.map((root) => join11(ctx.repoRoot, root, "skills"))
+    join12(ctx.repoRoot, ".agents", "skills"),
+    ...SUPPORTED_CLI_ROOTS.map((root) => join12(ctx.repoRoot, root, "skills"))
   ];
   for (const dir of skillDirs) {
     const dirStat = lstatIfPresent(dir);
     if (!dirStat || dirStat.isSymbolicLink() || !dirStat.isDirectory()) continue;
     let names;
     try {
-      names = readdirSync7(dir);
+      names = readdirSync8(dir);
     } catch {
       continue;
     }
     for (const name of names) {
       if (!name.startsWith(BMAD_SKILL_NAME_PREFIX)) continue;
-      const path = join11(dir, name);
+      const path = join12(dir, name);
       if (!lstatIfPresent(path)?.isSymbolicLink()) continue;
       if (isCurrentActivation(path, activations)) continue;
       changedFiles.push(path);
       details.push(`removed retired BMAD pack symlink ${relative9(ctx.repoRoot, path)}`);
-      if (!ctx.dryRun) unlinkSync5(path);
+      if (!ctx.dryRun) unlinkSync6(path);
     }
   }
   return details;
@@ -11867,10 +12213,11 @@ function bmadInstallerInvocation(version = BMAD_INSTALLER_VERSION) {
     prefixArgs: ["-y", `${BMAD_NPM_PACKAGE}@${version}`]
   };
 }
-function resolveBmadInstallerPackage(version = BMAD_INSTALLER_VERSION) {
+function resolveBmadInstallerPackage(version = BMAD_INSTALLER_VERSION, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 18e4;
   const packageAt = (dir) => {
     try {
-      const parsed = JSON.parse(readFileSync11(join11(dir, "package.json"), "utf8"));
+      const parsed = JSON.parse(readFileSync12(join12(dir, "package.json"), "utf8"));
       return parsed.name === BMAD_NPM_PACKAGE ? typeof parsed.version === "string" ? parsed.version : "unknown" : void 0;
     } catch {
       return void 0;
@@ -11902,12 +12249,13 @@ function resolveBmadInstallerPackage(version = BMAD_INSTALLER_VERSION) {
     `node -e "process.stdout.write(require('fs').realpathSync(process.argv[1]))" "$(command -v ${BMAD_NPM_PACKAGE})"`
   ], {
     encoding: "utf8",
-    timeout: 18e4,
+    timeout: timeoutMs,
     env: { ...process.env, npm_config_update_notifier: "false", npm_config_fund: "false" }
   });
   const entry = probe.stdout?.trim().split("\n").pop()?.trim();
   if (probe.status !== 0 || !entry) {
-    const detail = String(probe.stderr || probe.error?.message || `exit ${probe.status}`).split("\n").filter((line) => line.trim() && !line.startsWith("npm notice")).slice(-3).join(" ");
+    const timedOut = probe.error?.code === "ETIMEDOUT";
+    const detail = timedOut ? `timed out after ${Math.round(timeoutMs / 1e3)}s` : String(probe.stderr || probe.error?.message || `exit ${probe.status}`).split("\n").filter((line) => line.trim() && !line.startsWith("npm notice")).slice(-3).join(" ");
     return { reason: `could not resolve ${BMAD_NPM_PACKAGE}@${version}: ${detail || "no installer path reported"}` };
   }
   const root = dirname9(dirname9(dirname9(entry)));
@@ -11915,6 +12263,34 @@ function resolveBmadInstallerPackage(version = BMAD_INSTALLER_VERSION) {
   if (!found) return { reason: `${entry} is not inside a ${BMAD_NPM_PACKAGE} package` };
   return { root, entry, version: found };
 }
+var BMAD_SETUP_SCRIPTS_PROBE_TIMEOUT_MS = 1e4;
+var BMAD_SETUP_SCRIPTS_REMEDY = "re-run the BMAD installer (npx bmad-method install) or upgrade via `pj migrate bmad.version`";
+function bmadSetupScriptsState(repoRoot) {
+  const inspection = inspectBmadSetupScripts(repoRoot, BMAD_INSTALLER_VERSION, () => readInstalledBmadVersion(repoRoot));
+  const decline = (why, missing, remedy2) => ({
+    kind: "decline",
+    summary: `Setup script recovery unavailable: ${why}${missing.length ? ` (missing from _bmad/scripts: ${missing.join(", ")})` : ""}; ${remedy2}`
+  });
+  switch (inspection.state) {
+    case "present":
+      return { kind: "present" };
+    case "unsafe":
+      return { kind: "refuse", error: `BMAD script recovery refused: ${inspection.error}` };
+    case "decline":
+      return decline(inspection.why, inspection.missing, BMAD_SETUP_SCRIPTS_REMEDY);
+    case "missing":
+      break;
+  }
+  const override = Boolean(process.env.PJ_BMAD_INSTALLER?.trim());
+  const remedy = override ? "unset PJ_BMAD_INSTALLER to enable recovery from the pinned package" : `retry when npm is reachable, or ${BMAD_SETUP_SCRIPTS_REMEDY}`;
+  const pkg = resolveBmadInstallerPackage(BMAD_INSTALLER_VERSION, { timeoutMs: BMAD_SETUP_SCRIPTS_PROBE_TIMEOUT_MS });
+  if (!pkg.root) return decline(pkg.reason ?? "installer is not a bmad-method package", inspection.missing, remedy);
+  const plan = planBmadSetupScripts(repoRoot, pkg, BMAD_INSTALLER_VERSION);
+  if (plan.error) {
+    return plan.declinable ? decline(plan.error.replace(/^BMAD script recovery refused: /, ""), inspection.missing, plan.declinable === "attest" ? BMAD_SETUP_SCRIPTS_REMEDY : remedy) : { kind: "refuse", error: plan.error };
+  }
+  return plan.files.length ? { kind: "missing", pkg, files: plan.files } : { kind: "present" };
+}
 function bmadInstallerArgs(repoRoot, modules = selectedBmadModules(repoRoot), extraArgs = []) {
   const installerModules = modules.length ? modules.join(",") : "core";
   return [
@@ -11933,7 +12309,7 @@ function bmadInstallerArgs(repoRoot, modules = selectedBmadModules(repoRoot), ex
 }
 function bmadUpgradeChannelArgs(repoRoot, version) {
   if (!/^\d+\.\d+\.\d+$/.test(version)) return [];
-  const raw = safeReadText2(join11(repoRoot, "_bmad", "_config", "manifest.yaml"));
+  const raw = safeReadText2(join12(repoRoot, "_bmad", "_config", "manifest.yaml"));
   if (!raw) return [];
   let modules;
   try {
@@ -12003,7 +12379,7 @@ function bmadChannelTarget(distTags) {
   return next ? { version: next, channel: BMAD_TARGET_CHANNEL } : void 0;
 }
 function readInstalledBmadVersion(repoRoot) {
-  const raw = safeReadText2(join11(repoRoot, "_bmad", "_config", "manifest.yaml"));
+  const raw = safeReadText2(join12(repoRoot, "_bmad", "_config", "manifest.yaml"));
   if (!raw) return void 0;
   try {
     const parsed = YAML4.parse(raw);
@@ -12014,8 +12390,8 @@ function readInstalledBmadVersion(repoRoot) {
   }
 }
 function bmadCachePath(homeDir) {
-  const cacheRoot = process.env.XDG_CACHE_HOME?.trim() || join11(homeDir, ".cache");
-  return join11(cacheRoot, "pjangler", "bmad-dist-tags.json");
+  const cacheRoot = process.env.XDG_CACHE_HOME?.trim() || join12(homeDir, ".cache");
+  return join12(cacheRoot, "pjangler", "bmad-dist-tags.json");
 }
 function readBmadDistTagsCache(homeDir) {
   const raw = safeReadText2(bmadCachePath(homeDir));
@@ -12057,8 +12433,8 @@ function resolveBmadDistTags(homeDir) {
   if (fetched) {
     try {
       const path = bmadCachePath(homeDir);
-      mkdirSync6(dirname9(path), { recursive: true });
-      writeFileSync8(path, JSON.stringify({ fetchedAt: Date.now(), distTags: fetched }, null, 2));
+      mkdirSync7(dirname9(path), { recursive: true });
+      writeFileSync9(path, JSON.stringify({ fetchedAt: Date.now(), distTags: fetched }, null, 2));
     } catch {
     }
     return { distTags: fetched, stale: false };
@@ -12101,27 +12477,27 @@ function compareBmadVersions(a, b) {
 function discoverMomoProviderCandidates(repoRoot) {
   const candidates = [];
   const roleDirs = [];
-  const hermesDir = join11(repoRoot, "agents", "hermes");
+  const hermesDir = join12(repoRoot, "agents", "hermes");
   if (existsSync8(hermesDir)) {
-    for (const entry of readdirSync7(hermesDir, { withFileTypes: true })) {
-      if (entry.isDirectory()) roleDirs.push(join11(hermesDir, entry.name));
+    for (const entry of readdirSync8(hermesDir, { withFileTypes: true })) {
+      if (entry.isDirectory()) roleDirs.push(join12(hermesDir, entry.name));
     }
   }
   for (const roleDir of roleDirs) {
     for (const name of ["momo", "provider", "momo-provider"]) {
-      const path = join11(roleDir, name);
+      const path = join12(roleDir, name);
       if (existsSync8(path)) {
         const kind = path.endsWith(".py") ? "python" : "shell";
         candidates.push({ path, kind });
       }
     }
     if (existsSync8(roleDir)) {
-      for (const entry of readdirSync7(roleDir, { withFileTypes: true })) {
+      for (const entry of readdirSync8(roleDir, { withFileTypes: true })) {
         if (!entry.isFile()) continue;
         if (!entry.name.startsWith("momo")) continue;
-        const path = join11(roleDir, entry.name);
+        const path = join12(roleDir, entry.name);
         try {
-          if (lstatSync9(path).mode & 73) {
+          if (lstatSync10(path).mode & 73) {
             const kind = entry.name.endsWith(".py") ? "python" : "shell";
             if (!candidates.some((c) => c.path === path)) candidates.push({ path, kind });
           }
@@ -12131,7 +12507,7 @@ function discoverMomoProviderCandidates(repoRoot) {
     }
   }
   for (const rel of [".mise/scripts/momo-provider.sh", ".scripts/momo-provider.sh", "momo"]) {
-    const path = join11(repoRoot, rel);
+    const path = join12(repoRoot, rel);
     if (existsSync8(path)) {
       const kind = path.endsWith(".py") ? "python" : "shell";
       if (!candidates.some((c) => c.path === path)) candidates.push({ path, kind });
@@ -12167,7 +12543,7 @@ function runProviderLocalSmoke(repoRoot, candidate) {
   return { ok: true };
 }
 function attemptPlaneStateMapping(repoRoot) {
-  const project = tryParseJson(safeReadText2(join11(repoRoot, ".project.json")));
+  const project = tryParseJson(safeReadText2(join12(repoRoot, ".project.json")));
   const tp = project?.ticket_provider ?? {};
   if (!tp.board_id) return { ok: false, detail: "ticket_provider.board_id missing; cannot map Plane states" };
   return { ok: false, detail: `Plane state mapping attempted for board ${tp.board_id} (credentials required for full mapping)` };
@@ -12184,7 +12560,7 @@ function momoLifecycleFinding(section2, status, summary, details = []) {
 }
 function auditManifestRoleConsistency(repoRoot) {
   const details = [];
-  const projectPath = join11(repoRoot, ".project.json");
+  const projectPath = join12(repoRoot, ".project.json");
   if (!existsSync8(projectPath)) {
     return momoLifecycleFinding("manifest-role-consistency", "fail", ".project.json missing", [".project.json missing"]);
   }
@@ -12206,7 +12582,7 @@ function auditManifestRoleConsistency(repoRoot) {
       details.push(`agents.${agentId}.role_dir does not exist: ${agent.role_dir}`);
       continue;
     }
-    const roleYaml = join11(roleDir, "role.yaml");
+    const roleYaml = join12(roleDir, "role.yaml");
     if (!existsSync8(roleYaml)) {
       details.push(`agents.${agentId} role.yaml missing at ${agent.role_dir}/role.yaml`);
       continue;
@@ -12249,26 +12625,26 @@ function hasAnyLifecycleScript(repoRoot) {
   for (const pattern of patterns) {
     if (pattern.includes("*")) {
       const [prefix, suffix] = pattern.split("*");
-      const base = join11(repoRoot, prefix);
+      const base = join12(repoRoot, prefix);
       if (!existsSync8(base)) continue;
-      for (const entry of readdirSync7(base, { withFileTypes: true })) {
+      for (const entry of readdirSync8(base, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const candidate = join11(base, entry.name, suffix);
+        const candidate = join12(base, entry.name, suffix);
         if (existsSync8(candidate)) return true;
         const parent = dirname9(candidate);
-        const stem = basename4(candidate);
+        const stem = basename5(candidate);
         if (!existsSync8(parent)) continue;
-        for (const sibling of readdirSync7(parent, { withFileTypes: true })) {
+        for (const sibling of readdirSync8(parent, { withFileTypes: true })) {
           if (sibling.isFile() && sibling.name.startsWith(stem)) return true;
         }
       }
     } else {
-      const base = join11(repoRoot, pattern);
+      const base = join12(repoRoot, pattern);
       if (existsSync8(base)) return true;
       const parent = dirname9(base);
-      const prefix = basename4(base);
+      const prefix = basename5(base);
       if (existsSync8(parent)) {
-        for (const entry of readdirSync7(parent, { withFileTypes: true })) {
+        for (const entry of readdirSync8(parent, { withFileTypes: true })) {
           if (entry.name.startsWith(prefix)) return true;
         }
       }
@@ -12298,26 +12674,26 @@ function hasAnySentinelScript(repoRoot) {
   for (const pattern of patterns) {
     if (pattern.includes("*")) {
       const [prefix, suffix] = pattern.split("*");
-      const base = join11(repoRoot, prefix);
+      const base = join12(repoRoot, prefix);
       if (!existsSync8(base)) continue;
-      for (const entry of readdirSync7(base, { withFileTypes: true })) {
+      for (const entry of readdirSync8(base, { withFileTypes: true })) {
         if (!entry.isDirectory()) continue;
-        const candidate = join11(base, entry.name, suffix);
+        const candidate = join12(base, entry.name, suffix);
         if (existsSync8(candidate)) return true;
         const parent = dirname9(candidate);
-        const stem = basename4(candidate);
+        const stem = basename5(candidate);
         if (!existsSync8(parent)) continue;
-        for (const sibling of readdirSync7(parent, { withFileTypes: true })) {
+        for (const sibling of readdirSync8(parent, { withFileTypes: true })) {
           if (sibling.isFile() && sibling.name.startsWith(stem)) return true;
         }
       }
     } else {
-      const base = join11(repoRoot, pattern);
+      const base = join12(repoRoot, pattern);
       if (existsSync8(base)) return true;
       const parent = dirname9(base);
-      const prefix = basename4(base);
+      const prefix = basename5(base);
       if (existsSync8(parent)) {
-        for (const entry of readdirSync7(parent, { withFileTypes: true })) {
+        for (const entry of readdirSync8(parent, { withFileTypes: true })) {
           if (entry.name.startsWith(prefix)) return true;
         }
       }
@@ -12362,7 +12738,7 @@ function auditProviderSyntax(repoRoot) {
 }
 function auditPlaneBinding(repoRoot) {
   const details = [];
-  const project = tryParseJson(safeReadText2(join11(repoRoot, ".project.json")));
+  const project = tryParseJson(safeReadText2(join12(repoRoot, ".project.json")));
   const tp = project?.ticket_provider ?? {};
   for (const key of ["type", "workspace", "identifier", "board_id"]) {
     if (!tp[key]) details.push(`ticket_provider.${key} missing`);
@@ -12534,8 +12910,8 @@ var UNSUPPORTED_BMAD_ROOTS = {
   ".zencoder": "zencoder"
 };
 function unsupportedRootAttestation(repoRoot, rootName) {
-  const root = join11(repoRoot, rootName);
-  const stat = lstatSync9(root);
+  const root = join12(repoRoot, rootName);
+  const stat = lstatSync10(root);
   if (!stat.isDirectory() || stat.isSymbolicLink()) return { safe: false, reason: `${rootName} is not a regular generated directory` };
   const installerTool = UNSUPPORTED_BMAD_ROOTS[rootName];
   if (!installedBmadTools(repoRoot).has(installerTool)) {
@@ -12554,7 +12930,7 @@ var OPTIONAL_TEMPLATE_SCRIPTS = [
 function optionalTemplateScriptIssues(ctx) {
   const issues = [];
   for (const rel of OPTIONAL_TEMPLATE_SCRIPTS) {
-    const path = join11(ctx.repoRoot, rel);
+    const path = join12(ctx.repoRoot, rel);
     if (!existsSync8(path)) continue;
     const expected = templateCommonProjectText(ctx, rel);
     if (expected === void 0) continue;
@@ -12565,7 +12941,7 @@ function optionalTemplateScriptIssues(ctx) {
 function refreshOptionalTemplateScripts(ctx) {
   const changed = [];
   for (const rel of OPTIONAL_TEMPLATE_SCRIPTS) {
-    const path = join11(ctx.repoRoot, rel);
+    const path = join12(ctx.repoRoot, rel);
     if (!existsSync8(path)) continue;
     const expected = templateCommonProjectText(ctx, rel);
     if (expected === void 0 || safeReadText2(path) === expected) continue;
@@ -12583,13 +12959,13 @@ function createMiseChecks() {
       id: "mise.config-root",
       title: "mise config_root + AGENTS link hooks",
       audit: (ctx) => {
-        const misePath = join11(ctx.repoRoot, "mise.toml");
+        const misePath = join12(ctx.repoRoot, "mise.toml");
         if (!existsSync8(misePath)) {
           return { id: "mise.config-root", title: "mise config_root + AGENTS link hooks", status: "fail", summary: "mise.toml missing", details: [], fixable: true };
         }
         const text2 = readText(misePath);
         const details = [];
-        const linkAgentfilesPath = join11(ctx.repoRoot, ".mise", "scripts", "link-agentfiles.sh");
+        const linkAgentfilesPath = join12(ctx.repoRoot, ".mise", "scripts", "link-agentfiles.sh");
         if (!existsSync8(linkAgentfilesPath)) details.push(".mise/scripts/link-agentfiles.sh missing");
         const toml = [];
         const manual = [];
@@ -12637,7 +13013,7 @@ function createMiseChecks() {
         };
       },
       migrate: (ctx, finding2) => {
-        const path = join11(ctx.repoRoot, "mise.toml");
+        const path = join12(ctx.repoRoot, "mise.toml");
         const changedFiles = [];
         const details = [];
         if (!existsSync8(path)) {
@@ -12656,7 +13032,7 @@ function createMiseChecks() {
           if (!ctx.dryRun) writeText(path, plan.text);
           text2 = plan.text;
         }
-        const linkAgentfilesPath = join11(ctx.repoRoot, ".mise", "scripts", "link-agentfiles.sh");
+        const linkAgentfilesPath = join12(ctx.repoRoot, ".mise", "scripts", "link-agentfiles.sh");
         const expectedScript = templateLinkAgentfilesScript(ctx);
         if (expectedScript === void 0) {
           return { id: finding2.id, title: finding2.title, status: "blocked", summary: "pjangler install is missing .mise/scripts/link-agentfiles.sh \u2014 update @delorenj/pjangler (broken package)", changedFiles, details: [] };
@@ -12694,9 +13070,9 @@ function createMiseChecks() {
       title: "managed mise versioning block",
       audit: (ctx) => {
         const details = [];
-        const misePath = join11(ctx.repoRoot, "mise.toml");
-        const versioningPath = join11(ctx.repoRoot, ".mise", "scripts", "versioning.sh");
-        const manifestPath = join11(ctx.repoRoot, ".mise", "version-files.conf");
+        const misePath = join12(ctx.repoRoot, "mise.toml");
+        const versioningPath = join12(ctx.repoRoot, ".mise", "scripts", "versioning.sh");
+        const manifestPath = join12(ctx.repoRoot, ".mise", "version-files.conf");
         const text2 = safeReadText2(misePath);
         if (!text2?.includes("# >>> mise-versioning >>>")) details.push("mise versioning managed block missing");
         if (!existsSync8(versioningPath)) details.push(".mise/scripts/versioning.sh missing");
@@ -12722,7 +13098,7 @@ function createMiseChecks() {
       migrate: (ctx, finding2) => {
         const changedFiles = [];
         const details = [];
-        const misePath = join11(ctx.repoRoot, "mise.toml");
+        const misePath = join12(ctx.repoRoot, "mise.toml");
         if (!existsSync8(misePath)) {
           if (ensureMiseTomlFromTemplate(ctx, changedFiles) === null) {
             return { id: finding2.id, title: finding2.title, status: "blocked", summary: "mise.toml missing and no generated-project mise template available to initialize from", changedFiles, details: [] };
@@ -12740,7 +13116,7 @@ function createMiseChecks() {
           if (!changedFiles.includes(misePath)) changedFiles.push(misePath);
           if (!ctx.dryRun) writeText(misePath, versioningPlan.text);
         }
-        const versioningPath = join11(ctx.repoRoot, ".mise", "scripts", "versioning.sh");
+        const versioningPath = join12(ctx.repoRoot, ".mise", "scripts", "versioning.sh");
         const expectedScript = templateVersioningScript(ctx);
         if (expectedScript === void 0) {
           return { id: finding2.id, title: finding2.title, status: "blocked", summary: "pjangler install is missing .mise/scripts/versioning.sh \u2014 update @delorenj/pjangler (broken package)", changedFiles, details: [] };
@@ -12752,7 +13128,7 @@ function createMiseChecks() {
             chmodSync3(versioningPath, 493);
           }
         }
-        const manifestPath = join11(ctx.repoRoot, ".mise", "version-files.conf");
+        const manifestPath = join12(ctx.repoRoot, ".mise", "version-files.conf");
         const expectedManifest = templateVersionFilesConf(ctx, ctx.repoRoot);
         if (safeReadText2(manifestPath) !== expectedManifest) {
           changedFiles.push(manifestPath);
@@ -12814,7 +13190,7 @@ var RETIRED_SKILL_SCRIPTS = [
   ".mise/scripts/unlink-project-skills-from-clis.sh"
 ];
 function retiredSkillsScripts(ctx) {
-  return RETIRED_SKILL_SCRIPTS.map((path) => join11(ctx.repoRoot, path)).filter((path) => Boolean(lstatIfPresent(path)));
+  return RETIRED_SKILL_SCRIPTS.map((path) => join12(ctx.repoRoot, path)).filter((path) => Boolean(lstatIfPresent(path)));
 }
 function skillsWiringFindings(text2) {
   if (text2 === null) return { fixable: [], manual: [] };
@@ -12865,7 +13241,7 @@ function createAgentHooksChecks() {
       title: "Skillex project skills",
       audit: async (ctx) => {
         const finding2 = await auditProjectSkills(ctx);
-        const mise = safeReadText2(join11(ctx.repoRoot, "mise.toml"));
+        const mise = safeReadText2(join12(ctx.repoRoot, "mise.toml"));
         const registryField = await legacyRegistryField(ctx);
         const registryDrop = registryField ? await dropLegacyRegistryField({ ...ctx, dryRun: true }) : void 0;
         const wiring = [...skillsWiringIssues(mise), ...registryField && !registryDrop?.blocked ? [`Drop the legacy "registry" field (${JSON.stringify(registryField.value)}) from .agents/skills.json; it pins resolution to the never-fetched ~/.agents/.cache registry clone`] : []];
@@ -12886,7 +13262,7 @@ function createAgentHooksChecks() {
         const changedFiles = [];
         const details = [];
         const result2 = (status, summary) => ({ id: finding2.id, title: finding2.title, status, summary, changedFiles: [...new Set(changedFiles)], details });
-        let currentMise = safeReadText2(join11(ctx.repoRoot, "mise.toml"));
+        let currentMise = safeReadText2(join12(ctx.repoRoot, "mise.toml"));
         if (currentMise === null) {
           const template = templateCommonProjectText(ctx, "mise.toml.jinja");
           if (template === void 0) return result2("blocked", "Generated-project mise template is unavailable");
@@ -12901,9 +13277,9 @@ function createAgentHooksChecks() {
           const stat = lstatIfPresent(path);
           if (!stat || stat.isDirectory()) continue;
           changedFiles.push(path);
-          if (!ctx.dryRun) unlinkSync5(path);
+          if (!ctx.dryRun) unlinkSync6(path);
         }
-        const misePath = join11(ctx.repoRoot, "mise.toml");
+        const misePath = join12(ctx.repoRoot, "mise.toml");
         const nextMise = upsertLinkAgentfilesBlock(currentMise, ctx);
         if (safeReadText2(misePath) !== nextMise) {
           changedFiles.push(misePath);
@@ -12934,9 +13310,9 @@ function createAgentHooksChecks() {
       id: "sot.agent-symlinks",
       title: "AGENTS/CLAUDE/GEMINI symlink contract",
       audit: (ctx) => {
-        const agentsPath = join11(ctx.repoRoot, "AGENTS.md");
+        const agentsPath = join12(ctx.repoRoot, "AGENTS.md");
         if (!existsSync8(agentsPath)) {
-          const fallbackSources = ["CLAUDE.md", "GEMINI.md", "README.md"].filter((file) => existsSync8(join11(ctx.repoRoot, file)));
+          const fallbackSources = ["CLAUDE.md", "GEMINI.md", "README.md"].filter((file) => existsSync8(join12(ctx.repoRoot, file)));
           if (fallbackSources.length === 0) {
             return { id: "sot.agent-symlinks", title: "AGENTS/CLAUDE/GEMINI symlink contract", status: "skip", summary: "AGENTS.md missing; symlink contract not applicable", details: [], fixable: false };
           }
@@ -12951,7 +13327,7 @@ function createAgentHooksChecks() {
         }
         const details = [];
         for (const file of ["CLAUDE.md", "GEMINI.md"]) {
-          const full = join11(ctx.repoRoot, file);
+          const full = join12(ctx.repoRoot, file);
           const target = readSymlinkTarget(full);
           if (target !== "AGENTS.md") details.push(`${file} should be a symlink to AGENTS.md`);
         }
@@ -12975,7 +13351,7 @@ function createAgentHooksChecks() {
           return { id: finding2.id, title: finding2.title, status: "blocked", summary: "AGENTS.md missing; cannot derive canonical agent file", changedFiles, details: [bootstrap.blocked] };
         }
         for (const file of ["CLAUDE.md", "GEMINI.md"]) {
-          const full = join11(ctx.repoRoot, file);
+          const full = join12(ctx.repoRoot, file);
           const result2 = ensureSymlink(full, "AGENTS.md", ctx.dryRun);
           if (result2.blocked) blockedDetails.push(result2.blocked);
           if (result2.changed) changedFiles.push(full);
@@ -13002,7 +13378,7 @@ function createProjectJsonChecks() {
         const changedFiles = [];
         const blockedDetails = [];
         const droppedDetails = [];
-        const path = join11(ctx.repoRoot, ".project.json");
+        const path = join12(ctx.repoRoot, ".project.json");
         const existing = readProjectJson(ctx) ?? {};
         const canonical = canonicalProjectJson(ctx);
         const preservedDetails = [];
@@ -13034,7 +13410,7 @@ function createProjectJsonChecks() {
           changedFiles.push(path);
           if (!ctx.dryRun) writeText(path, expected);
         }
-        const planeJson = join11(ctx.repoRoot, ".plane.json");
+        const planeJson = join12(ctx.repoRoot, ".plane.json");
         if (existsSync8(planeJson)) {
           const backup = `${planeJson}.migrated-backup`;
           if (existsSync8(backup)) {
@@ -13066,10 +13442,10 @@ function createMiseOpInjectChecks() {
         const details = [];
         let envOpNeedsHands = false;
         const optedOut = envMaterializationOptedOut(ctx);
-        const envOpPath = join11(ctx.repoRoot, ".env.op");
+        const envOpPath = join12(ctx.repoRoot, ".env.op");
         const envOpExists = existsSync8(envOpPath);
         const envOp = envOpExists ? readText(envOpPath) : void 0;
-        const gitignore = safeReadText2(join11(ctx.repoRoot, ".gitignore"));
+        const gitignore = safeReadText2(join12(ctx.repoRoot, ".gitignore"));
         if (!envOpExists) {
           details.push(".env.op missing");
         } else if (!envOp?.trim()) {
@@ -13089,7 +13465,7 @@ function createMiseOpInjectChecks() {
         if (!gitignore?.includes(".env\n") && !gitignore?.includes(".env\r\n")) details.push(".gitignore should ignore .env");
         if (!gitignore?.includes(".env.*")) details.push(".gitignore should ignore .env.*");
         if (!gitignore?.includes("!.env.op")) details.push(".gitignore should unignore .env.op");
-        const misePath = join11(ctx.repoRoot, "mise.toml");
+        const misePath = join12(ctx.repoRoot, "mise.toml");
         const miseText = safeReadText2(misePath);
         if (!miseText) {
           details.push("mise.toml missing for .env materialization hook");
@@ -13112,7 +13488,7 @@ function createMiseOpInjectChecks() {
           else if (plan.text !== miseText && !mise.length) mise.push(describeRewrite(miseText, plan.text));
           details.push(...mise);
         }
-        const materializePath = join11(ctx.repoRoot, MATERIALIZE_ENV_SCRIPT_REL);
+        const materializePath = join12(ctx.repoRoot, MATERIALIZE_ENV_SCRIPT_REL);
         const expectedMaterializer = templateMaterializeEnvScript(ctx);
         if (optedOut) {
           if (existsSync8(materializePath)) details.push(`${MATERIALIZE_ENV_SCRIPT_REL} is present, but .project.json declares secrets.materialize_env: false`);
@@ -13120,7 +13496,7 @@ function createMiseOpInjectChecks() {
           details.push("pjangler package is missing the managed materialize-env.sh source");
         } else if (safeReadText2(materializePath) !== expectedMaterializer) {
           details.push(`${MATERIALIZE_ENV_SCRIPT_REL} missing or drifted`);
-        } else if ((lstatSync9(materializePath).mode & 73) === 0) {
+        } else if ((lstatSync10(materializePath).mode & 73) === 0) {
           details.push(`${MATERIALIZE_ENV_SCRIPT_REL} is not executable`);
         }
         return {
@@ -13136,8 +13512,8 @@ function createMiseOpInjectChecks() {
         const changedFiles = [];
         const details = [];
         let envOpNeedsHands = false;
-        const envOpPath = join11(ctx.repoRoot, ".env.op");
-        const canonicalEnvOpPath = join11(ctx.pjanglerRoot, "templates", "commonproject", "template", ".env.op");
+        const envOpPath = join12(ctx.repoRoot, ".env.op");
+        const canonicalEnvOpPath = join12(ctx.pjanglerRoot, "templates", "commonproject", "template", ".env.op");
         if (!existsSync8(canonicalEnvOpPath)) {
           return { id: finding2.id, title: finding2.title, status: "blocked", summary: "pjangler package is missing the neutral .env.op template", changedFiles: [], details: [] };
         }
@@ -13166,7 +13542,7 @@ function createMiseOpInjectChecks() {
             }
           }
         }
-        const gitignorePath = join11(ctx.repoRoot, ".gitignore");
+        const gitignorePath = join12(ctx.repoRoot, ".gitignore");
         const gitignore = safeReadText2(gitignorePath) ?? "";
         const requiredBlock = `# Secrets \u2014 .env is materialized from .env.op by \`op inject\` on mise enter,
 # staged through a mktemp file and moved into place only on success.
@@ -13179,7 +13555,7 @@ function createMiseOpInjectChecks() {
           changedFiles.push(gitignorePath);
           if (!ctx.dryRun) writeText(gitignorePath, `${gitignore.replace(/\s*$/, "")}${gitignore.trim() ? "\n\n" : ""}${requiredBlock}`);
         }
-        const misePath = join11(ctx.repoRoot, "mise.toml");
+        const misePath = join12(ctx.repoRoot, "mise.toml");
         let currentMise = safeReadText2(misePath);
         if (currentMise === null) {
           const initialized = ensureMiseTomlFromTemplate(ctx, changedFiles);
@@ -13196,7 +13572,7 @@ function createMiseOpInjectChecks() {
           if (!changedFiles.includes(misePath)) changedFiles.push(misePath);
           if (!ctx.dryRun) writeText(misePath, opPlan.text);
         }
-        const materializePath = join11(ctx.repoRoot, MATERIALIZE_ENV_SCRIPT_REL);
+        const materializePath = join12(ctx.repoRoot, MATERIALIZE_ENV_SCRIPT_REL);
         const expectedMaterializer = templateMaterializeEnvScript(ctx);
         if (optedOut) {
           if (existsSync8(materializePath)) {
@@ -13205,7 +13581,7 @@ function createMiseOpInjectChecks() {
           }
         } else if (!expectedMaterializer) {
           return { id: finding2.id, title: finding2.title, status: "blocked", summary: "pjangler package is missing materialize-env.sh", changedFiles: [], details: [] };
-        } else if (safeReadText2(materializePath) !== expectedMaterializer || existsSync8(materializePath) && (lstatSync9(materializePath).mode & 73) === 0) {
+        } else if (safeReadText2(materializePath) !== expectedMaterializer || existsSync8(materializePath) && (lstatSync10(materializePath).mode & 73) === 0) {
           changedFiles.push(materializePath);
           if (!ctx.dryRun) {
             writeText(materializePath, expectedMaterializer);
@@ -13267,7 +13643,7 @@ function createProjectProvenanceChecks() {
       title: ".copier-answers.yml provenance + drift report",
       audit: (ctx) => {
         const details = [];
-        const path = join11(ctx.repoRoot, ".copier-answers.yml");
+        const path = join12(ctx.repoRoot, ".copier-answers.yml");
         const text2 = safeReadText2(path);
         const project = readProjectJson(ctx);
         if (!text2) {
@@ -13295,11 +13671,11 @@ function createProjectProvenanceChecks() {
       migrate: (ctx, finding2) => {
         const changedFiles = [];
         const project = canonicalProjectJson(ctx);
-        const path = join11(ctx.repoRoot, ".copier-answers.yml");
+        const path = join12(ctx.repoRoot, ".copier-answers.yml");
         const current = safeReadText2(path);
         const existing = current ? YAML4.parseDocument(current) : void 0;
         const document = existing && !existing.errors.length && YAML4.isMap(existing.contents) ? existing : new YAML4.Document({});
-        document.set("_src_path", join11(ctx.pjanglerRoot, "templates", "commonproject"));
+        document.set("_src_path", join12(ctx.pjanglerRoot, "templates", "commonproject"));
         document.set("project_description", String(project.project_description));
         document.set("project_name", String(project.project_name));
         document.set("ticket_provider", String(project.ticket_provider?.type ?? "plane"));
@@ -13324,9 +13700,9 @@ ${body}`;
 }
 function supportedCliProjectionIssues(repoRoot, plan) {
   const issues = [];
-  const managedSkills = join11(repoRoot, ".agents", "skills");
+  const managedSkills = join12(repoRoot, ".agents", "skills");
   for (const rootName of SUPPORTED_CLI_ROOTS) {
-    const root = join11(repoRoot, rootName);
+    const root = join12(repoRoot, rootName);
     const rootStat = lstatIfPresent(root);
     if (!rootStat) {
       issues.push(`${rootName} missing`);
@@ -13336,7 +13712,7 @@ function supportedCliProjectionIssues(repoRoot, plan) {
       issues.push(`${rootName} must be a real configuration directory`);
       continue;
     }
-    const skills = join11(root, "skills");
+    const skills = join12(root, "skills");
     const skillsStat = lstatIfPresent(skills);
     if (!skillsStat) {
       issues.push(`${rootName}/skills missing`);
@@ -13373,9 +13749,9 @@ function supportedCliProjectionIssues(repoRoot, plan) {
       issues.push(`${rootName}/skills is not a directory`);
       continue;
     }
-    const hasGeneratedSkill = existsSync8(projectedSkills) && readdirSync7(projectedSkills).some((name) => {
-      const skillFile = join11(projectedSkills, name, "SKILL.md");
-      return existsSync8(skillFile) && lstatSync9(skillFile).isFile();
+    const hasGeneratedSkill = existsSync8(projectedSkills) && readdirSync8(projectedSkills).some((name) => {
+      const skillFile = join12(projectedSkills, name, "SKILL.md");
+      return existsSync8(skillFile) && lstatSync10(skillFile).isFile();
     });
     if (!hasGeneratedSkill) issues.push(`${rootName}/skills contains no BMAD skill configuration`);
   }
@@ -13401,7 +13777,7 @@ var LEGACY_CLI_GITIGNORE_LINES = /* @__PURE__ */ new Set([
   "# some CLIs get a real directory here and some get a symlink."
 ]);
 function supportedCliGitignoreIssues(repoRoot) {
-  const lines = (safeReadText2(join11(repoRoot, ".gitignore")) ?? "").split(/\r?\n/);
+  const lines = (safeReadText2(join12(repoRoot, ".gitignore")) ?? "").split(/\r?\n/);
   const legacy = lines.filter((line) => LEGACY_CLI_GITIGNORE_LINES.has(line.trim()));
   return [
     ...legacy.length ? [`.gitignore contains ${legacy.length} legacy client-root override line(s); only .agents is canonical`] : [],
@@ -13409,7 +13785,7 @@ function supportedCliGitignoreIssues(repoRoot) {
   ];
 }
 function ensureSupportedCliGitignore(ctx) {
-  const path = join11(ctx.repoRoot, ".gitignore");
+  const path = join12(ctx.repoRoot, ".gitignore");
   const current = safeReadText2(path) ?? "";
   const kept = current.split(/\r?\n/).filter((line) => {
     const trimmed2 = line.trim();
@@ -13451,6 +13827,24 @@ function withInstallerSkillHandoff(check) {
     }
   };
 }
+function withScaffoldPostcondition(check) {
+  if (check.id !== "bmad.scaffold") return check;
+  return {
+    ...check,
+    migrate: async (ctx, finding2) => {
+      const result2 = await check.migrate(ctx, finding2);
+      if (ctx.dryRun || result2.status !== "applied" && result2.status !== "noop") return result2;
+      const after = await check.audit(ctx);
+      if (after.status === "pass" || after.status === "skip") return result2;
+      return {
+        ...result2,
+        status: "partial",
+        summary: after.summary,
+        details: [...result2.details, `still failing after the install: ${after.summary}`, ...after.details]
+      };
+    }
+  };
+}
 function createBmadChecks() {
   return [
     {
@@ -13468,15 +13862,8 @@ function createBmadChecks() {
             fixable: false
           };
         }
-        const targetRoot = join11(ctx.repoRoot, "_bmad");
         const selectedModules = manifestSelection.status === "valid" ? manifestSelection.modules : configuredBmadModuleSelection(ctx.repoRoot)?.modules ?? [...DEFAULT_BMAD_MODULES];
-        const sentinels = requiredBmadSentinels(ctx.repoRoot, selectedModules);
-        const missing = sentinels.filter((file) => !existsSync8(join11(targetRoot, file)));
-        const projectNameIssues = bmadProjectNameIssues(ctx.repoRoot);
-        const details = [
-          ...missing.map((file) => `_bmad/${file}`),
-          ...projectNameIssues.details
-        ];
+        const { details } = bmadScaffoldIssues(ctx.repoRoot, selectedModules);
         return {
           id: "bmad.scaffold",
           title: "BMAD modules/docs scaffold",
@@ -13515,7 +13902,7 @@ function createBmadChecks() {
           bmadCompanion: preservation
         };
         if (ctx.dryRun) {
-          const sentinels = requiredBmadSentinels(ctx.repoRoot, selectedModules);
+          const issues = bmadScaffoldIssues(ctx.repoRoot, selectedModules);
           const companion = installedBmad ? await runG33PreUpdateCompanion(ctx.repoRoot) : await runG33Companion(ctx.repoRoot, true, "bmad-install");
           if (installedBmad && ["unavailable", "conflict", "error"].includes(companion.status)) {
             return {
@@ -13528,8 +13915,8 @@ function createBmadChecks() {
               bmadCompanion: companion
             };
           }
-          changedFiles.push(...sentinels.map((file) => join11(ctx.repoRoot, "_bmad", file)).filter((path) => !existsSync8(path)));
-          changedFiles.push(...bmadProjectNameIssues(ctx.repoRoot).paths);
+          changedFiles.push(...issues.gaps.map((gap) => join12(ctx.repoRoot, "_bmad", gap.path)));
+          changedFiles.push(...issues.nameIssues.paths);
           const reservedPreview = installedBmad ? evictReservedModuleEntries(ctx.repoRoot, true) : void 0;
           changedFiles.push(...reservedPreview?.changedFiles ?? []);
           return {
@@ -13547,9 +13934,10 @@ function createBmadChecks() {
           };
         }
         if (installedBmad && g33CompanionEnabled(ctx.repoRoot)) {
+          const before2 = bmadScaffoldIssues(ctx.repoRoot, selectedModules);
           const expectedChangedPaths2 = [
-            ...requiredBmadSentinels(ctx.repoRoot, selectedModules).map((file) => join11(ctx.repoRoot, "_bmad", file)).filter((path) => !existsSync8(path)),
-            ...bmadProjectNameIssues(ctx.repoRoot).paths
+            ...before2.gaps.map((gap) => join12(ctx.repoRoot, "_bmad", gap.path)),
+            ...before2.nameIssues.paths
           ];
           const pkg = resolveBmadInstallerPackage(BMAD_INSTALLER_VERSION);
           const scope = deriveBmadUpdateScope(ctx.repoRoot, { tools: BMAD_INSTALL_TOOLS, installer: pkg, companionSurfaces: G33_OWNED_SURFACES });
@@ -13590,16 +13978,17 @@ function createBmadChecks() {
             bmadCompanion: update.companion
           };
         }
+        const before = bmadScaffoldIssues(ctx.repoRoot, selectedModules);
         const expectedChangedPaths = [
-          ...requiredBmadSentinels(ctx.repoRoot, selectedModules).map((file) => join11(ctx.repoRoot, "_bmad", file)).filter((path) => !existsSync8(path)),
-          ...bmadProjectNameIssues(ctx.repoRoot).paths
+          ...before.gaps.map((gap) => join12(ctx.repoRoot, "_bmad", gap.path)),
+          ...before.nameIssues.paths
         ];
         const evicted = evictLegacyBmadPackState(ctx, changedFiles, await skillActivations(ctx));
         const reserved = installedBmad ? evictReservedModuleEntries(ctx.repoRoot, false) : void 0;
         if (reserved) evicted.unshift(...reserved.details);
         const install = await runBmadInstall(ctx.repoRoot, selectedModules, BMAD_INSTALLER_VERSION, channelArgs);
         if (!install.ok && reserved?.original !== void 0) {
-          writeFileSync8(reserved.changedFiles[0], reserved.original, "utf8");
+          writeFileSync9(reserved.changedFiles[0], reserved.original, "utf8");
           evicted.push("restored _bmad/_config/manifest.yaml after the failed install");
         }
         if (!install.ok) {
@@ -13624,6 +14013,58 @@ function createBmadChecks() {
         };
       }
     },
+    {
+      id: "bmad.setup-scripts",
+      title: "BMAD ignored installer setup scripts",
+      audit: (ctx) => {
+        if (!isInstalledBmadProject(ctx.repoRoot)) return {
+          id: "bmad.setup-scripts",
+          title: "BMAD ignored installer setup scripts",
+          status: "skip",
+          summary: "No installed BMAD project",
+          details: [],
+          fixable: false
+        };
+        const state = bmadSetupScriptsState(ctx.repoRoot);
+        const id = "bmad.setup-scripts", title = "BMAD ignored installer setup scripts";
+        switch (state.kind) {
+          case "present":
+            return { id, title, status: "pass", summary: "BMAD installer scripts are present", details: [], fixable: false };
+          case "decline":
+            return { id, title, status: "skip", summary: state.summary, details: [], fixable: false };
+          case "refuse":
+            return { id, title, status: "fail", summary: state.error, details: [state.error], fixable: false };
+          case "missing":
+            return {
+              id,
+              title,
+              status: "fail",
+              summary: "Ignored BMAD installer scripts are missing",
+              details: state.files.map((path) => relative9(ctx.repoRoot, path)),
+              fixable: true
+            };
+        }
+      },
+      migrate: (ctx, finding2) => {
+        const title = finding2.title, id = finding2.id;
+        if (finding2.status === "skip") return { id, title, status: "skipped", summary: finding2.summary, details: [], changedFiles: [] };
+        const state = bmadSetupScriptsState(ctx.repoRoot);
+        if (state.kind === "decline") return { id, title, status: "skipped", summary: state.summary, details: [], changedFiles: [] };
+        if (state.kind === "refuse") return { id, title, status: "blocked", summary: state.error, details: [state.error], changedFiles: [] };
+        if (state.kind === "present") return { id, title, status: "noop", summary: "BMAD installer scripts already present", details: [], changedFiles: [] };
+        const { pkg, files } = state;
+        if (ctx.dryRun) return {
+          id,
+          title,
+          status: "applied",
+          summary: "Would restore ignored scripts from verified pinned bmad-method package",
+          details: [`bmad-method@${BMAD_INSTALLER_VERSION} (${pkg.root})`],
+          changedFiles: files
+        };
+        const applied = applyBmadSetupScripts(ctx.repoRoot, pkg, BMAD_INSTALLER_VERSION);
+        return applied.error ? { id, title, status: "blocked", summary: applied.error, details: [applied.error], changedFiles: [] } : { id, title, status: "applied", summary: "Restored ignored BMAD installer scripts", details: [`bmad-method@${BMAD_INSTALLER_VERSION} (${pkg.root})`], changedFiles: applied.files };
+      }
+    },
     {
       id: "bmad.version",
       title: "BMAD version currency",
@@ -13634,7 +14075,7 @@ function createBmadChecks() {
             id: "bmad.version",
             title: "BMAD version currency",
             status: "skip",
-            summary: existsSync8(join11(ctx.repoRoot, "_bmad")) ? "BMAD installed but version manifest unreadable" : "No BMAD install present",
+            summary: existsSync8(join12(ctx.repoRoot, "_bmad")) ? "BMAD installed but version manifest unreadable" : "No BMAD install present",
             details: [],
             fixable: false
           };
@@ -13722,7 +14163,7 @@ function createBmadChecks() {
         }
         const installed = readInstalledBmadVersion(ctx.repoRoot);
         const available = ctx.bmadVersionPin?.trim() ?? bmadChannelTarget(resolveBmadDistTags(ctx.homeDir)?.distTags)?.version;
-        const manifestPath = join11(ctx.repoRoot, "_bmad", "_config", "manifest.yaml");
+        const manifestPath = join12(ctx.repoRoot, "_bmad", "_config", "manifest.yaml");
         const manifestSelection = manifestBmadModules(ctx.repoRoot);
         if (manifestSelection.status === "invalid") {
           return {
@@ -13820,7 +14261,7 @@ function createBmadChecks() {
         const reserved = evictReservedModuleEntries(ctx.repoRoot, false);
         const install = await runBmadInstall(ctx.repoRoot, selectedModules, available ?? BMAD_TARGET_CHANNEL, channelArgs);
         if (!install.ok) {
-          if (reserved.original !== void 0) writeFileSync8(reserved.changedFiles[0], reserved.original, "utf8");
+          if (reserved.original !== void 0) writeFileSync9(reserved.changedFiles[0], reserved.original, "utf8");
           return {
             id: finding2.id,
             title: finding2.title,
@@ -13855,7 +14296,7 @@ function createBmadChecks() {
       title: "Supported BMAD CLI projection roots",
       audit: (ctx) => {
         const unsupportedNames = Object.keys(UNSUPPORTED_BMAD_ROOTS);
-        const present = unsupportedNames.filter((name) => existsSync8(join11(ctx.repoRoot, name)));
+        const present = unsupportedNames.filter((name) => existsSync8(join12(ctx.repoRoot, name)));
         const attestations = present.map((name) => ({ name, ...unsupportedRootAttestation(ctx.repoRoot, name) }));
         const plan = planSkillRoots(ctx.repoRoot);
         const supportedIssues = supportedCliProjectionIssues(ctx.repoRoot, plan);
@@ -13877,7 +14318,7 @@ function createBmadChecks() {
       },
       migrate: (ctx, finding2) => {
         const unsupportedNames = Object.keys(UNSUPPORTED_BMAD_ROOTS);
-        const present = unsupportedNames.filter((name) => existsSync8(join11(ctx.repoRoot, name)));
+        const present = unsupportedNames.filter((name) => existsSync8(join12(ctx.repoRoot, name)));
         const attestations = present.map((name) => ({ name, ...unsupportedRootAttestation(ctx.repoRoot, name) }));
         const blocked = attestations.filter((entry) => !entry.safe);
         if (blocked.length) {
@@ -13902,7 +14343,7 @@ function createBmadChecks() {
           };
         }
         const gitignoreChanges = ensureSupportedCliGitignore(ctx);
-        const removedRoots = attestations.map((entry) => join11(ctx.repoRoot, entry.name));
+        const removedRoots = attestations.map((entry) => join12(ctx.repoRoot, entry.name));
         if (!ctx.dryRun) for (const path of removedRoots) rmSync5(path, { recursive: true, force: true });
         const changedFiles = [.../* @__PURE__ */ new Set([...projectionResult.changedFiles, ...gitignoreChanges, ...removedRoots])].sort();
         return {
@@ -13915,7 +14356,7 @@ function createBmadChecks() {
         };
       }
     }
-  ].map(withInstallerSkillHandoff);
+  ].map(withInstallerSkillHandoff).map(withScaffoldPostcondition);
 }
 function createProjectMomoChecks() {
   return [
@@ -14604,8 +15045,8 @@ var NodeRecipe = class extends Recipe {
 // src/recipes/ProjectRecipe.ts
 init_project();
 import { spawnSync as spawnSync14 } from "node:child_process";
-import { existsSync as existsSync18, lstatSync as lstatSync16, readFileSync as readFileSync22, rmSync as rmSync8 } from "node:fs";
-import { dirname as dirname18, isAbsolute as isAbsolute10, join as join24, relative as relativePath, resolve as resolve19 } from "node:path";
+import { existsSync as existsSync18, lstatSync as lstatSync17, readFileSync as readFileSync23, rmSync as rmSync8 } from "node:fs";
+import { dirname as dirname18, isAbsolute as isAbsolute10, join as join25, relative as relativePath, resolve as resolve19 } from "node:path";
 
 // src/project/ticketScope.ts
 function ticketScope(ticket) {
@@ -14622,8 +15063,8 @@ init_tree_diff();
 
 // src/recipes/NotebookRecipe.ts
 init_project();
-import { existsSync as existsSync17, readFileSync as readFileSync21 } from "node:fs";
-import { join as join23 } from "node:path";
+import { existsSync as existsSync17, readFileSync as readFileSync22 } from "node:fs";
+import { join as join24 } from "node:path";
 
 // src/notebook/checks.ts
 init_config();
@@ -14631,8 +15072,8 @@ init_notes();
 init_output();
 init_state();
 import { spawnSync as spawnSync8 } from "node:child_process";
-import { existsSync as existsSync14, readFileSync as readFileSync19 } from "node:fs";
-import { join as join19 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync20 } from "node:fs";
+import { join as join20 } from "node:path";
 var NOTEBOOK_RULE_IDS = [
   "notebook.configuration",
   "notebook.binding",
@@ -14649,10 +15090,10 @@ function result(check, status, summary, changedFiles = [], details = []) {
   return { id: check.id, title: check.title, status, summary, changedFiles, details };
 }
 function manifestNotebook(repo) {
-  const path = join19(repo, ".project.json");
+  const path = join20(repo, ".project.json");
   if (!existsSync14(path)) return null;
   try {
-    const parsed = JSON.parse(readFileSync19(path, "utf8"));
+    const parsed = JSON.parse(readFileSync20(path, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
     const notebook = parsed.notebook;
     return notebook && typeof notebook === "object" && !Array.isArray(notebook) ? notebook : null;
@@ -14881,7 +15322,7 @@ function captureAudit(ctx) {
 function overviewMigrate(ctx, current) {
   if (ctx.dryRun) return result(current, "applied", "Would reconcile drifted Project Overview note");
   if (!ctx.live) return result(current, "blocked", "Reconciling the remote Overview note requires --live");
-  const pjanglerEntry = ctx.pjanglerRoot ? join19(ctx.pjanglerRoot, "dist", "index.js") : null;
+  const pjanglerEntry = ctx.pjanglerRoot ? join20(ctx.pjanglerRoot, "dist", "index.js") : null;
   const entry = pjanglerEntry && existsSync14(pjanglerEntry) ? pjanglerEntry : "pj";
   const cmd = entry === "pj" ? ["pj"] : [process.execPath, entry];
   const spawned = spawnSync8(cmd[0], [...cmd.slice(1), "notebook", "overview", ctx.repoRoot], {
@@ -14933,7 +15374,7 @@ import { resolve as resolve18 } from "node:path";
 
 // src/notebook/journal-key.ts
 init_types();
-import { createHash as createHash11 } from "node:crypto";
+import { createHash as createHash12 } from "node:crypto";
 function validateJournalPeriodKey(period, key) {
   if (period === "monthly") {
     if (!/^\d{4}-(?:0[1-9]|1[0-2])$/u.test(key)) throw new NotebookError("INVALID_INPUT", "Monthly period key must be YYYY-MM");
@@ -14952,7 +15393,7 @@ function validateJournalPeriodKey(period, key) {
 }
 function journalNoteOperationId(period, key) {
   validateJournalPeriodKey(period, key);
-  const bytes = createHash11("sha256").update(`pjangler-dev-journal-v1\0infra\0${period}\0${key}`).digest().subarray(0, 16);
+  const bytes = createHash12("sha256").update(`pjangler-dev-journal-v1\0infra\0${period}\0${key}`).digest().subarray(0, 16);
   bytes[6] = bytes[6] & 15 | 80;
   bytes[8] = bytes[8] & 63 | 128;
   const hex = bytes.toString("hex");
@@ -15108,9 +15549,9 @@ init_notes();
 init_state();
 init_types();
 import { spawn as spawn2, spawnSync as spawnSync11 } from "node:child_process";
-import { createHash as createHash12, randomUUID as randomUUID5 } from "node:crypto";
-import { chmodSync as chmodSync6, closeSync as closeSync6, constants as constants5, copyFileSync as copyFileSync3, existsSync as existsSync15, fstatSync as fstatSync3, fsyncSync as fsyncSync4, lstatSync as lstatSync15, mkdirSync as mkdirSync9, openSync as openSync6, readFileSync as readFileSync20, readSync as readSync3, readdirSync as readdirSync10, realpathSync as realpathSync10, renameSync as renameSync8, rmSync as rmSync7, symlinkSync as symlinkSync4, unlinkSync as unlinkSync8, writeFileSync as writeFileSync12 } from "node:fs";
-import { basename as basename10, dirname as dirname17, isAbsolute as isAbsolute8, join as join22, parse as parse3, relative as relative15, resolve as resolve16, sep as sep7 } from "node:path";
+import { createHash as createHash13, randomUUID as randomUUID5 } from "node:crypto";
+import { chmodSync as chmodSync6, closeSync as closeSync7, constants as constants6, copyFileSync as copyFileSync3, existsSync as existsSync15, fstatSync as fstatSync4, fsyncSync as fsyncSync4, lstatSync as lstatSync16, mkdirSync as mkdirSync10, openSync as openSync7, readFileSync as readFileSync21, readSync as readSync3, readdirSync as readdirSync11, realpathSync as realpathSync10, renameSync as renameSync8, rmSync as rmSync7, symlinkSync as symlinkSync4, unlinkSync as unlinkSync9, writeFileSync as writeFileSync13 } from "node:fs";
+import { basename as basename11, dirname as dirname17, isAbsolute as isAbsolute8, join as join23, parse as parse3, relative as relative15, resolve as resolve16, sep as sep7 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 function captureWorkerEnvironment(source, projectSlug) {
   const result2 = {
@@ -15158,7 +15599,7 @@ function bundledSkillCandidates() {
   const candidates = [];
   let cursor = dirname17(fileURLToPath3(import.meta.url));
   for (let depth = 0; depth < 8; depth++) {
-    candidates.push(join22(cursor, "dist", "assets", "project-notebook-skill"), join22(cursor, "assets", "project-notebook-skill"));
+    candidates.push(join23(cursor, "dist", "assets", "project-notebook-skill"), join23(cursor, "assets", "project-notebook-skill"));
     const parent = dirname17(cursor);
     if (parent === cursor) break;
     cursor = parent;
@@ -15176,14 +15617,14 @@ function assertOwnedSkillTree(source) {
   assertNoSymlinkComponents(source);
   const uid = typeof process.getuid === "function" ? process.getuid() : void 0;
   const walk = (directory) => {
-    const directoryStat = lstatSync15(directory);
+    const directoryStat = lstatSync16(directory);
     if (!directoryStat.isDirectory() || directoryStat.isSymbolicLink()) throw new NotebookError("CONFLICT", "Project Notebook skill source contains a non-directory component");
     if (uid !== void 0 && directoryStat.uid !== uid) throw new NotebookError("CONFLICT", "Project Notebook skill source is not owned by the current user");
     if (directoryStat.mode & 3586) throw new NotebookError("CONFLICT", "Project Notebook skill source has unsafe directory mode bits");
-    for (const entry of readdirSync10(directory, { withFileTypes: true })) {
+    for (const entry of readdirSync11(directory, { withFileTypes: true })) {
       if (entry.isDirectory() && (entry.name === "__pycache__" || entry.name === ".git" || entry.name === "node_modules")) continue;
-      const path = join22(directory, entry.name);
-      const stat = lstatSync15(path);
+      const path = join23(directory, entry.name);
+      const stat = lstatSync16(path);
       if (stat.isSymbolicLink()) throw new NotebookError("CONFLICT", "Project Notebook skill source contains a symlink");
       if (entry.isDirectory()) walk(path);
       else if (!entry.isFile()) throw new NotebookError("CONFLICT", "Project Notebook skill source contains a non-regular entry");
@@ -15198,18 +15639,18 @@ function assertOwnedSkillTree(source) {
 function enumerateSkillPayload(source) {
   const result2 = [];
   const walk = (directory) => {
-    for (const entry of readdirSync10(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name, "en"))) {
+    for (const entry of readdirSync11(directory, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name, "en"))) {
       if (entry.isDirectory() && (entry.name === "__pycache__" || entry.name === ".git" || entry.name === "node_modules")) continue;
-      const path = join22(directory, entry.name);
+      const path = join23(directory, entry.name);
       const rel = relative15(source, path).split(sep7).join("/");
       if (!rel.includes("/") && (rel === "export-manifest.json" || rel === "SHA256SUMS" || rel === ".source.yaml")) continue;
       if (!safeSkillRelativePath(rel)) throw new NotebookError("CONFLICT", `Project Notebook skill export path is unsafe: ${rel}`);
-      const stat = lstatSync15(path);
+      const stat = lstatSync16(path);
       if (stat.isSymbolicLink()) throw new NotebookError("CONFLICT", "Project Notebook skill export contains a symlink");
       if (entry.isDirectory()) walk(path);
       else if (entry.isFile()) {
         const expectedMode = rel.endsWith(".sh") || rel.startsWith("scripts/") ? "0755" : "0644";
-        result2.push({ path: rel, sha256: createHash12("sha256").update(readFileSync20(path)).digest("hex"), mode: expectedMode });
+        result2.push({ path: rel, sha256: createHash13("sha256").update(readFileSync21(path)).digest("hex"), mode: expectedMode });
       } else throw new NotebookError("CONFLICT", "Project Notebook skill export contains a non-regular entry");
     }
   };
@@ -15217,9 +15658,9 @@ function enumerateSkillPayload(source) {
   return result2.sort((a, b) => a.path.localeCompare(b.path, "en"));
 }
 function parsePackedManifest(source) {
-  const manifestPath = join22(source, "export-manifest.json");
+  const manifestPath = join23(source, "export-manifest.json");
   if (!existsSync15(manifestPath)) return null;
-  const value = JSON.parse(readFileSync20(manifestPath, "utf8"));
+  const value = JSON.parse(readFileSync21(manifestPath, "utf8"));
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new NotebookError("CONFLICT", "Project Notebook skill export manifest is invalid");
   const manifest = value;
   if (manifest.schema_version !== 1 || manifest.skill !== "project-notebook" || !Array.isArray(manifest.files)) throw new NotebookError("CONFLICT", "Project Notebook skill export manifest is incompatible");
@@ -15228,10 +15669,10 @@ function parsePackedManifest(source) {
     if (!entry || typeof entry.path !== "string" || !/^[a-f0-9]{64}$/u.test(entry.sha256) || !/^(?:0644|0755)$/u.test(entry.mode)) throw new NotebookError("CONFLICT", "Project Notebook skill export entry is invalid");
     if (!safeSkillRelativePath(entry.path) || paths.has(entry.path)) throw new NotebookError("CONFLICT", "Project Notebook skill export path is unsafe or duplicated");
     paths.add(entry.path);
-    const path = join22(source, ...entry.path.split("/"));
-    const stat = lstatSync15(path);
+    const path = join23(source, ...entry.path.split("/"));
+    const stat = lstatSync16(path);
     if (!stat.isFile() || stat.isSymbolicLink()) throw new NotebookError("CONFLICT", "Project Notebook skill export contains a non-regular entry");
-    const actual = createHash12("sha256").update(readFileSync20(path)).digest("hex");
+    const actual = createHash13("sha256").update(readFileSync21(path)).digest("hex");
     if (actual !== entry.sha256) throw new NotebookError("CONFLICT", `Project Notebook skill digest mismatch: ${entry.path}`);
     const actualMode = stat.mode & 511;
     const executable = entry.mode === "0755";
@@ -15243,16 +15684,16 @@ function parsePackedManifest(source) {
   if (JSON.stringify(actualPaths) !== JSON.stringify(manifest.files.map((entry) => entry.path))) throw new NotebookError("CONFLICT", "Project Notebook skill manifest does not exactly enumerate its payload");
   const sums = `${manifest.files.map((entry) => `${entry.sha256}  ${entry.path}`).join("\n")}
 `;
-  if (!existsSync15(join22(source, "SHA256SUMS")) || readFileSync20(join22(source, "SHA256SUMS"), "utf8") !== sums) throw new NotebookError("CONFLICT", "Project Notebook skill SHA256SUMS is missing or stale");
+  if (!existsSync15(join23(source, "SHA256SUMS")) || readFileSync21(join23(source, "SHA256SUMS"), "utf8") !== sums) throw new NotebookError("CONFLICT", "Project Notebook skill SHA256SUMS is missing or stale");
   return manifest;
 }
 function expectedPackedSkill() {
   for (const candidate of bundledSkillCandidates()) {
-    if (!existsSync15(join22(candidate, "export-manifest.json"))) continue;
+    if (!existsSync15(join23(candidate, "export-manifest.json"))) continue;
     assertOwnedSkillTree(candidate);
     const manifest = parsePackedManifest(candidate);
     if (!manifest) continue;
-    const digest = createHash12("sha256").update(JSON.stringify(manifest)).digest("hex");
+    const digest = createHash13("sha256").update(JSON.stringify(manifest)).digest("hex");
     return { source: candidate, manifest, digest };
   }
   throw new NotebookError("NOT_CONFIGURED", "PJ\xE1ngler package has no verified Project Notebook skill export");
@@ -15315,13 +15756,13 @@ function verifyProjectNotebookSkillExport(source) {
 function resolveProjectNotebookSkillSource(env2 = process.env) {
   if (env2.PJ_PROJECT_NOTEBOOK_SKILL_ROOT) {
     const explicit = resolve16(env2.PJ_PROJECT_NOTEBOOK_SKILL_ROOT);
-    if (!existsSync15(join22(explicit, "SKILL.md"))) throw new NotebookError("NOT_CONFIGURED", "Configured Project Notebook skill source is unavailable");
+    if (!existsSync15(join23(explicit, "SKILL.md"))) throw new NotebookError("NOT_CONFIGURED", "Configured Project Notebook skill source is unavailable");
     verifyProjectNotebookSkillExport(explicit);
     return explicit;
   }
   if (env2.PJ_SKILLS_REGISTRY_ROOT) {
     const canonical = resolve16(env2.PJ_SKILLS_REGISTRY_ROOT, "all-skills", "project-notebook");
-    if (existsSync15(join22(canonical, "SKILL.md"))) {
+    if (existsSync15(join23(canonical, "SKILL.md"))) {
       verifyProjectNotebookSkillExport(canonical);
       return canonical;
     }
@@ -15336,7 +15777,7 @@ var REPAIR_COMMAND = "pj notebook skill --apply";
 function probeCanonicalSkillexRootProjection(skillsRoot, link) {
   let rootLink;
   try {
-    rootLink = lstatSync15(skillsRoot);
+    rootLink = lstatSync16(skillsRoot);
   } catch (error) {
     if (error.code === "ENOENT") return { state: "absent" };
     throw error;
@@ -15349,15 +15790,15 @@ function probeCanonicalSkillexRootProjection(skillsRoot, link) {
     if (uid !== void 0 && rootLink.uid !== uid) throw new Error("owner");
     const globalRoot = realpathSync10(skillsRoot);
     assertNoSymlinkComponents(globalRoot);
-    const globalStat = lstatSync15(globalRoot);
+    const globalStat = lstatSync16(globalRoot);
     if (!globalStat.isDirectory() || globalStat.isSymbolicLink()) throw new Error("root-type");
     if (uid !== void 0 && globalStat.uid !== uid) throw new Error("root-owner");
     if (globalStat.mode & 3586) throw new Error("root-mode");
     const skillSetsRoot = dirname17(globalRoot);
-    if (basename10(globalRoot) !== "global" || basename10(skillSetsRoot) !== "skill-sets") throw new Error("layout");
+    if (basename11(globalRoot) !== "global" || basename11(skillSetsRoot) !== "skill-sets") throw new Error("layout");
     const checkoutRoot = dirname17(skillSetsRoot);
-    const expectedSource = join22(checkoutRoot, "all-skills", "project-notebook");
-    const linkStat = lstatSync15(link);
+    const expectedSource = join23(checkoutRoot, "all-skills", "project-notebook");
+    const linkStat = lstatSync16(link);
     if (!linkStat.isSymbolicLink()) throw new Error("projection-type");
     if (uid !== void 0 && linkStat.uid !== uid) throw new Error("projection-owner");
     const projectedSource = realpathSync10(link);
@@ -15391,44 +15832,44 @@ function installPackagedProjectNotebookSkill(input = {}) {
   const source = input.source ?? resolveProjectNotebookSkillSource(env2);
   if (!source) throw new NotebookError("NOT_CONFIGURED", "Project Notebook skill source is unavailable");
   const manifest = verifyProjectNotebookSkillExport(source);
-  const digest = createHash12("sha256").update(JSON.stringify(manifest)).digest("hex");
+  const digest = createHash13("sha256").update(JSON.stringify(manifest)).digest("hex");
   const home = env2.HOME;
   if (!home || !resolve16(home).startsWith("/")) throw new NotebookError("NOT_CONFIGURED", "A trusted HOME is required to install the Project Notebook skill");
-  const skillsRoot = join22(home, ".agents", "skills");
-  const link = join22(skillsRoot, "project-notebook");
+  const skillsRoot = join23(home, ".agents", "skills");
+  const link = join23(skillsRoot, "project-notebook");
   const probe = probeCanonicalSkillexRootProjection(skillsRoot, link);
   if (probe.state === "adopted") return { installed: false, path: link, digest };
   if (probe.state === "declined") return { installed: false, path: link, digest, blocked: probe.block };
-  const dataRoot = resolve16(env2.XDG_DATA_HOME || join22(home, ".local", "share"), "pjangler", "skills", "project-notebook");
-  const payload = join22(dataRoot, `${PJANGLER_VERSION}-${digest}`);
+  const dataRoot = resolve16(env2.XDG_DATA_HOME || join23(home, ".local", "share"), "pjangler", "skills", "project-notebook");
+  const payload = join23(dataRoot, `${PJANGLER_VERSION}-${digest}`);
   assertNoSymlinkComponents(dirname17(dataRoot), true);
-  mkdirSync9(dataRoot, { recursive: true, mode: 448 });
+  mkdirSync10(dataRoot, { recursive: true, mode: 448 });
   assertNoSymlinkComponents(dataRoot);
-  const dataStat = lstatSync15(dataRoot);
+  const dataStat = lstatSync16(dataRoot);
   if (!dataStat.isDirectory() || dataStat.isSymbolicLink() || typeof process.getuid === "function" && dataStat.uid !== process.getuid()) throw new NotebookError("CONFLICT", "Project Notebook skill data root is not a current-user directory");
   chmodSync6(dataRoot, 448);
   if (!existsSync15(payload)) {
-    const staging = join22(dataRoot, `.staging-${randomUUID5()}`);
-    mkdirSync9(staging, { recursive: false, mode: 448 });
+    const staging = join23(dataRoot, `.staging-${randomUUID5()}`);
+    mkdirSync10(staging, { recursive: false, mode: 448 });
     try {
       for (const entry of manifest.files) {
-        const destination = join22(staging, ...entry.path.split("/"));
-        mkdirSync9(dirname17(destination), { recursive: true, mode: 493 });
-        copyFileSync3(join22(source, ...entry.path.split("/")), destination);
+        const destination = join23(staging, ...entry.path.split("/"));
+        mkdirSync10(dirname17(destination), { recursive: true, mode: 493 });
+        copyFileSync3(join23(source, ...entry.path.split("/")), destination);
         const mode = entry.mode === "0755" ? 493 : 420;
         chmodSync6(destination, mode);
-        const fd = openSync6(destination, constants5.O_RDONLY | (constants5.O_NOFOLLOW ?? 0));
+        const fd = openSync7(destination, constants6.O_RDONLY | (constants6.O_NOFOLLOW ?? 0));
         try {
-          const current = fstatSync3(fd);
+          const current = fstatSync4(fd);
           if (!current.isFile()) throw new NotebookError("CONFLICT", `Installed skill entry is not regular: ${entry.path}`);
           fsyncSync4(fd);
         } finally {
-          closeSync6(fd);
+          closeSync7(fd);
         }
       }
-      writeFileSync12(join22(staging, "export-manifest.json"), `${JSON.stringify(manifest, null, 2)}
+      writeFileSync13(join23(staging, "export-manifest.json"), `${JSON.stringify(manifest, null, 2)}
 `, { mode: 420, flag: "wx" });
-      writeFileSync12(join22(staging, "SHA256SUMS"), `${manifest.files.map((entry) => `${entry.sha256}  ${entry.path}`).join("\n")}
+      writeFileSync13(join23(staging, "SHA256SUMS"), `${manifest.files.map((entry) => `${entry.sha256}  ${entry.path}`).join("\n")}
 `, { mode: 420, flag: "wx" });
       verifyProjectNotebookSkillExport(staging);
       renameSync8(staging, payload);
@@ -15436,17 +15877,17 @@ function installPackagedProjectNotebookSkill(input = {}) {
       if (existsSync15(staging)) rmSync7(staging, { recursive: true, force: true });
     }
   } else {
-    const stat = lstatSync15(payload);
+    const stat = lstatSync16(payload);
     if (!stat.isDirectory() || stat.isSymbolicLink()) throw new NotebookError("CONFLICT", "Installed Project Notebook payload is not a real directory");
     verifyProjectNotebookSkillExport(payload);
   }
   assertNoSymlinkComponents(skillsRoot, true);
-  mkdirSync9(skillsRoot, { recursive: true, mode: 448 });
+  mkdirSync10(skillsRoot, { recursive: true, mode: 448 });
   assertNoSymlinkComponents(skillsRoot);
   let linkExists = existsSync15(link);
   if (!linkExists) {
     try {
-      lstatSync15(link);
+      lstatSync16(link);
       linkExists = true;
     } catch {
     }
@@ -15463,7 +15904,7 @@ function installPackagedProjectNotebookSkill(input = {}) {
         repair: REPAIR_COMMAND
       }
     });
-    const stat = lstatSync15(link);
+    const stat = lstatSync16(link);
     if (!stat.isSymbolicLink()) return foreign(["the path is a real file or directory, not a PJ\xE1ngler-owned link"]);
     const target = realpathSync10(link);
     if (target !== realpathSync10(payload) && !isVerifiedCanonicalSkillexProjection(target)) {
@@ -15491,15 +15932,15 @@ function collectSupersededPayloads(dataRoot, keep) {
   const removed = [];
   let entries;
   try {
-    entries = readdirSync10(dataRoot);
+    entries = readdirSync11(dataRoot);
   } catch {
     return removed;
   }
   for (const name of entries) {
     if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?-[0-9a-f]{64}$/u.test(name)) continue;
-    const candidate = join22(dataRoot, name);
+    const candidate = join23(dataRoot, name);
     try {
-      const stat = lstatSync15(candidate);
+      const stat = lstatSync16(candidate);
       if (!stat.isDirectory() || stat.isSymbolicLink()) continue;
       if (kept.has(realpathSync10(candidate))) continue;
       rmSync7(candidate, { recursive: true, force: true });
@@ -15513,8 +15954,8 @@ function repairProjectNotebookSkillProjection(input = {}) {
   const env2 = input.env ?? process.env;
   const home = env2.HOME;
   if (!home || !resolve16(home).startsWith("/")) throw new NotebookError("NOT_CONFIGURED", "A trusted HOME is required to repair the Project Notebook skill projection");
-  const skillsRoot = join22(home, ".agents", "skills");
-  const link = join22(skillsRoot, "project-notebook");
+  const skillsRoot = join23(home, ".agents", "skills");
+  const link = join23(skillsRoot, "project-notebook");
   const probe = probeCanonicalSkillexRootProjection(skillsRoot, link);
   if (probe.state === "adopted") return { status: "clean", summary: "Canonical Skillex projection already matches the version-pinned export", source: probe.source, drift: [], changed_files: [] };
   if (probe.state !== "declined") {
@@ -15527,8 +15968,8 @@ function repairProjectNotebookSkillProjection(input = {}) {
   assertOwnedSkillTree(source);
   const present = [];
   const walk = (directory) => {
-    for (const entry of readdirSync10(directory, { withFileTypes: true })) {
-      const path = join22(directory, entry.name);
+    for (const entry of readdirSync11(directory, { withFileTypes: true })) {
+      const path = join23(directory, entry.name);
       const rel = relative15(source, path).split(sep7).join("/");
       if (entry.isDirectory()) {
         walk(path);
@@ -15542,11 +15983,11 @@ function repairProjectNotebookSkillProjection(input = {}) {
   walk(source);
   const stale = present.filter((rel) => !wanted.has(rel)).sort();
   const changed = expected.manifest.files.filter((entry) => {
-    const path = join22(source, ...entry.path.split("/"));
+    const path = join23(source, ...entry.path.split("/"));
     if (!existsSync15(path)) return true;
-    const stat = lstatSync15(path);
+    const stat = lstatSync16(path);
     if (!stat.isFile()) return true;
-    if (createHash12("sha256").update(readFileSync20(path)).digest("hex") !== entry.sha256) return true;
+    if (createHash13("sha256").update(readFileSync21(path)).digest("hex") !== entry.sha256) return true;
     const mode = stat.mode & 511;
     const executable = entry.mode === "0755";
     return executable && (mode & 64) === 0 || !executable && (mode & 73) !== 0;
@@ -15561,15 +16002,15 @@ function repairProjectNotebookSkillProjection(input = {}) {
       summary: `Would restore ${affected.length} file(s) in ${source} from the version-pinned export`,
       source,
       drift: probe.block.details,
-      changed_files: affected.map((rel) => join22(source, ...rel.split("/")))
+      changed_files: affected.map((rel) => join23(source, ...rel.split("/")))
     };
   }
-  for (const rel of stale) rmSync7(join22(source, ...rel.split("/")), { force: true });
+  for (const rel of stale) rmSync7(join23(source, ...rel.split("/")), { force: true });
   for (const rel of changed) {
-    const destination = join22(source, ...rel.split("/"));
+    const destination = join23(source, ...rel.split("/"));
     const entry = expected.manifest.files.find((item) => item.path === rel);
-    mkdirSync9(dirname17(destination), { recursive: true, mode: 493 });
-    copyFileSync3(join22(expected.source, ...rel.split("/")), destination);
+    mkdirSync10(dirname17(destination), { recursive: true, mode: 493 });
+    copyFileSync3(join23(expected.source, ...rel.split("/")), destination);
     chmodSync6(destination, entry.mode === "0755" ? 493 : 420);
   }
   verifyProjectNotebookSkillExport(source);
@@ -15578,21 +16019,21 @@ function repairProjectNotebookSkillProjection(input = {}) {
     summary: `Restored ${affected.length} file(s) in ${source} from the version-pinned export; commit the change in the Skillex checkout`,
     source,
     drift: probe.block.details,
-    changed_files: affected.map((rel) => join22(source, ...rel.split("/")))
+    changed_files: affected.map((rel) => join23(source, ...rel.split("/")))
   };
 }
 function inspectProjectNotebookIntegration(env2 = process.env) {
   const home = env2.HOME;
   if (!home) return { skill_installed: false, hooks_projected: false, details: ["HOME is unavailable"] };
-  const skillsRoot = join22(home, ".agents", "skills");
-  const link = join22(skillsRoot, "project-notebook");
+  const skillsRoot = join23(home, ".agents", "skills");
+  const link = join23(skillsRoot, "project-notebook");
   try {
     const expected = expectedPackedSkill();
-    const dataRoot = resolve16(env2.XDG_DATA_HOME || join22(home, ".local", "share"), "pjangler", "skills", "project-notebook");
-    const expectedPayload = join22(dataRoot, `${PJANGLER_VERSION}-${expected.digest}`);
+    const dataRoot = resolve16(env2.XDG_DATA_HOME || join23(home, ".local", "share"), "pjangler", "skills", "project-notebook");
+    const expectedPayload = join23(dataRoot, `${PJANGLER_VERSION}-${expected.digest}`);
     const probe = probeCanonicalSkillexRootProjection(skillsRoot, link);
     if (probe.state === "declined") return { skill_installed: false, hooks_projected: false, details: probe.block.details, blocked: probe.block };
-    const stat = lstatSync15(link);
+    const stat = lstatSync16(link);
     if (!stat.isSymbolicLink()) {
       return {
         skill_installed: false,
@@ -15629,8 +16070,8 @@ function inspectProjectNotebookIntegration(env2 = process.env) {
   }
 }
 function projectorArguments(source, command, input) {
-  const script = join22(source, "scripts", "project-hooks.py");
-  const args = [script, command, "--master", join22(source, "hooks", "hooks.master.json"), "--fragment", join22(source, "hooks", "claude.settings.json"), "--target", input.target];
+  const script = join23(source, "scripts", "project-hooks.py");
+  const args = [script, command, "--master", join23(source, "hooks", "hooks.master.json"), "--fragment", join23(source, "hooks", "claude.settings.json"), "--target", input.target];
   if (command === "check") args.push("--json");
   else if (input.stateHome) args.push("--state-home", input.stateHome);
   return args;
@@ -15652,7 +16093,7 @@ function checkProjectNotebookHooks(input = {}) {
   verifyProjectNotebookSkillExport(source);
   const home = env2.HOME;
   if (!home) throw new NotebookError("NOT_CONFIGURED", "HOME is required to check Project Notebook hooks");
-  const target = resolve16(input.target ?? env2.PJ_PROJECT_NOTEBOOK_CLAUDE_SETTINGS ?? join22(home, ".claude", "settings.json"));
+  const target = resolve16(input.target ?? env2.PJ_PROJECT_NOTEBOOK_CLAUDE_SETTINGS ?? join23(home, ".claude", "settings.json"));
   const result2 = spawnSync11("/usr/bin/python3", ["-I", ...projectorArguments(source, "check", { target })], { encoding: "utf8", env: projectorEnvironment(env2), timeout: 5e3, maxBuffer: 1048576 });
   if (result2.status !== 0 && result2.status !== 1) throw new NotebookError("CONFLICT", (result2.stderr || "Project Notebook projector check failed").trim().slice(0, 512));
   try {
@@ -15670,14 +16111,14 @@ function installProjectNotebookIntegration(input = {}) {
   const source = realpathSync10(skill.path);
   const home = env2.HOME;
   if (!home) throw new NotebookError("NOT_CONFIGURED", "HOME is required to install Project Notebook hooks");
-  const target = resolve16(input.target ?? env2.PJ_PROJECT_NOTEBOOK_CLAUDE_SETTINGS ?? join22(home, ".claude", "settings.json"));
-  const stateHome = resolve16(env2.XDG_STATE_HOME || join22(home, ".local", "state"));
+  const target = resolve16(input.target ?? env2.PJ_PROJECT_NOTEBOOK_CLAUDE_SETTINGS ?? join23(home, ".claude", "settings.json"));
+  const stateHome = resolve16(env2.XDG_STATE_HOME || join23(home, ".local", "state"));
   const result2 = spawnSync11("/usr/bin/python3", ["-I", ...projectorArguments(source, "install", { target, stateHome })], { encoding: "utf8", env: projectorEnvironment(env2), timeout: 5e3, maxBuffer: 1048576 });
   if (result2.status !== 0) {
     if (skill.installed) {
       try {
-        const stat = lstatSync15(skill.path);
-        if (stat.isSymbolicLink() && realpathSync10(skill.path) === source) unlinkSync8(skill.path);
+        const stat = lstatSync16(skill.path);
+        if (stat.isSymbolicLink() && realpathSync10(skill.path) === source) unlinkSync9(skill.path);
       } catch {
       }
     }
@@ -15722,10 +16163,10 @@ function assertNoSymlinkComponents(path, allowMissing = false) {
   const root = parse3(absolute).root;
   let cursor = root;
   for (const component of absolute.slice(root.length).split(sep7).filter(Boolean)) {
-    cursor = join22(cursor, component);
+    cursor = join23(cursor, component);
     let stat;
     try {
-      stat = lstatSync15(cursor);
+      stat = lstatSync16(cursor);
     } catch (error) {
       if (allowMissing && error.code === "ENOENT") return;
       throw error;
@@ -15744,18 +16185,18 @@ function readHookPayload(input) {
   if (rel === ".." || rel.startsWith(`..${sep7}`) || rel.startsWith(sep7)) throw new NotebookError("INVALID_INPUT", "Hook payload file is outside Notebook XDG state");
   assertNoSymlinkComponents(root);
   assertNoSymlinkComponents(path);
-  const before = lstatSync15(path);
+  const before = lstatSync16(path);
   if (!before.isFile() || before.isSymbolicLink() || (before.mode & 511) !== 384 || before.nlink !== 1) throw new NotebookError("INVALID_INPUT", "Hook payload file must be a contained mode-0600 regular file");
   if (typeof process.getuid === "function" && before.uid !== process.getuid()) throw new NotebookError("INVALID_INPUT", "Hook payload file must be owned by the current user");
   if (before.size > input.maxBytes) throw new NotebookError("INVALID_INPUT", "Hook payload file exceeds its configured ceiling");
-  const fd = openSync6(path, constants5.O_RDONLY | (constants5.O_NOFOLLOW ?? 0));
+  const fd = openSync7(path, constants6.O_RDONLY | (constants6.O_NOFOLLOW ?? 0));
   try {
-    const opened = fstatSync3(fd);
+    const opened = fstatSync4(fd);
     if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino) throw new NotebookError("INVALID_INPUT", "Hook payload file changed while opening");
     const value = readBoundedHookStdin(input.maxBytes, fd);
     return { payload: parsePayload(value, input.maxBytes), bytes: Buffer.byteLength(value, "utf8") };
   } finally {
-    closeSync6(fd);
+    closeSync7(fd);
   }
 }
 var ALLOWED_CLIENT_NAMES = /* @__PURE__ */ new Set([
@@ -16482,17 +16923,17 @@ init_remote_mutation_journal();
 function integrationEnvironment(module, ctx) {
   const env2 = { ...module.environment, HOME: ctx.homeDir };
   if (module.environment.HOME !== ctx.homeDir) {
-    env2.XDG_DATA_HOME = join23(ctx.homeDir, ".local", "share");
-    env2.XDG_STATE_HOME = join23(ctx.homeDir, ".local", "state");
-    env2.PJ_PROJECT_NOTEBOOK_CLAUDE_SETTINGS = join23(ctx.homeDir, ".claude", "settings.json");
+    env2.XDG_DATA_HOME = join24(ctx.homeDir, ".local", "share");
+    env2.XDG_STATE_HOME = join24(ctx.homeDir, ".local", "state");
+    env2.PJ_PROJECT_NOTEBOOK_CLAUDE_SETTINGS = join24(ctx.homeDir, ".claude", "settings.json");
   }
   return env2;
 }
 function resolvedForPlan(plan) {
-  const manifestPath = join23(plan.project.repo_path, ".project.json");
+  const manifestPath = join24(plan.project.repo_path, ".project.json");
   let manifest = plan.manifest;
   if (existsSync17(manifestPath)) {
-    const parsed = JSON.parse(readFileSync21(manifestPath, "utf8"));
+    const parsed = JSON.parse(readFileSync22(manifestPath, "utf8"));
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`${manifestPath} must contain a JSON object`);
     manifest = parsed;
   }
@@ -16669,7 +17110,7 @@ function unsafeToRemove(targetDir) {
   while (!seen.has(cursor)) {
     seen.add(cursor);
     try {
-      const stat = lstatSync16(cursor);
+      const stat = lstatSync17(cursor);
       if (stat.isSymbolicLink()) {
         return cursor === absolute ? `${absolute} is a symlink; removing it would leave the tree it points at orphaned` : `${cursor} is a symlink on the path to ${absolute}; a recursive remove would traverse it`;
       }
@@ -16697,12 +17138,12 @@ function publicMigration(report) {
   };
 }
 function hasGitRepository(runtime, targetDir) {
-  if (!existsSync18(join24(targetDir, ".git"))) return false;
+  if (!existsSync18(join25(targetDir, ".git"))) return false;
   return runtime.runGit(targetDir, ["rev-parse", "--is-inside-work-tree"]).status === 0;
 }
 function refreshPlanFromCanonicalManifest(plan) {
-  const manifestPath = join24(plan.project.repo_path, ".project.json");
-  const manifest = JSON.parse(readFileSync22(manifestPath, "utf8"));
+  const manifestPath = join25(plan.project.repo_path, ".project.json");
+  const manifest = JSON.parse(readFileSync23(manifestPath, "utf8"));
   if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) {
     throw new Error(`${manifestPath} must contain a JSON object`);
   }
@@ -16933,7 +17374,7 @@ var ProjectRecipe = class extends Recipe {
         if (hasGitRepository(this.runtime, targetDir)) {
           phases.push({ id: "project.git", status: "unchanged", changedFiles: [], message: "Git repository already initialized" });
         } else {
-          const gitPath = join24(targetDir, ".git");
+          const gitPath = join25(targetDir, ".git");
           for (const { args, label, options } of [
             { args: ["init", "--initial-branch=main"], label: "git init" },
             { args: ["add", "-A"], label: "git add" },
@@ -17144,12 +17585,12 @@ var ProjectRecipe = class extends Recipe {
 };
 
 // src/recipes/registry.ts
-import { readFileSync as readFileSync23 } from "node:fs";
-import { join as join25 } from "node:path";
+import { readFileSync as readFileSync24 } from "node:fs";
+import { join as join26 } from "node:path";
 function projectWaivers(repoRoot) {
   let waive;
   try {
-    waive = JSON.parse(readFileSync23(join25(repoRoot, ".project.json"), "utf8"))?.parity?.waive;
+    waive = JSON.parse(readFileSync24(join26(repoRoot, ".project.json"), "utf8"))?.parity?.waive;
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -17490,8 +17931,8 @@ var recipeRegistry = new RecipeRegistry([
 
 // src/commands/AgentHooksCommands.ts
 import { homedir as homedir10 } from "node:os";
-import { join as join26, dirname as dirname19 } from "node:path";
-import { existsSync as existsSync19, cpSync, mkdirSync as mkdirSync10, readFileSync as readFileSync24, writeFileSync as writeFileSync13 } from "node:fs";
+import { join as join27, dirname as dirname19 } from "node:path";
+import { existsSync as existsSync19, cpSync, mkdirSync as mkdirSync11, readFileSync as readFileSync25, writeFileSync as writeFileSync14 } from "node:fs";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 init_project();
 import { parse as parseToml4 } from "smol-toml";
@@ -17504,16 +17945,16 @@ function resolveTemplateRoot() {
   try {
     let dir = dirname19(fileURLToPath4(import.meta.url));
     for (let i = 0; i < 8; i++) {
-      candidates.push(join26(dir, "templates", "commonproject", "template"));
+      candidates.push(join27(dir, "templates", "commonproject", "template"));
       const parent = dirname19(dir);
       if (parent === dir) break;
       dir = parent;
     }
   } catch {
   }
-  candidates.push(join26(homedir10(), "code", "pjangler", "templates", "commonproject", "template"));
+  candidates.push(join27(homedir10(), "code", "pjangler", "templates", "commonproject", "template"));
   for (const c of candidates) {
-    if (existsSync19(join26(c, ".agents", "hooks", "hooks.master.json"))) return c;
+    if (existsSync19(join27(c, ".agents", "hooks", "hooks.master.json"))) return c;
   }
   throw new Error(
     "Could not locate the CommonProject template. Set PJANGLER_COMMONPROJECT_TEMPLATE to <repo>/templates/commonproject/template."
@@ -17539,15 +17980,15 @@ var CopyAgentHooksTree = class extends Command {
     const created = [];
     const skipped = [];
     for (const { rel, dir } of items) {
-      const src = join26(templateRoot, rel);
-      const dest = join26(this.context.targetDir, rel);
+      const src = join27(templateRoot, rel);
+      const dest = join27(this.context.targetDir, rel);
       if (!existsSync19(src)) continue;
       if (existsSync19(dest) && !this.context.force) {
         skipped.push(rel);
         continue;
       }
       if (!this.context.dryRun) {
-        mkdirSync10(dirname19(dest), { recursive: true });
+        mkdirSync11(dirname19(dest), { recursive: true });
         cpSync(src, dest, { recursive: dir, force: true });
       }
       created.push(rel);
@@ -17568,14 +18009,14 @@ var WireMiseAgentHooks = class _WireMiseAgentHooks extends Command {
     if (!resolveAgentHooksLayer2()) {
       return { success: true, message: this.formatMessage(AGENT_HOOKS_SKIP_MESSAGE) };
     }
-    const misePath = join26(this.context.targetDir, "mise.toml");
+    const misePath = join27(this.context.targetDir, "mise.toml");
     if (!existsSync19(misePath)) {
       return {
         success: false,
         message: "\u26A0\uFE0F  No mise.toml found \u2014 run `pj add mise` first, then re-run."
       };
     }
-    let content = readFileSync24(misePath, "utf8");
+    let content = readFileSync25(misePath, "utf8");
     if (content.includes(_WireMiseAgentHooks.MARKER)) {
       return { success: true, message: this.formatMessage("\u2713 mise.toml already wired for agent-hooks") };
     }
@@ -17659,7 +18100,7 @@ ${leaveBlock}`);
     if (!verdict.ok) {
       return { success: false, message: `\u26A0\uFE0F  mise.toml was not rewritten: ${verdict.reason}. Add the agent-hooks tasks by hand.` };
     }
-    if (!this.context.dryRun) writeFileSync13(misePath, content);
+    if (!this.context.dryRun) writeFileSync14(misePath, content);
     if (wiredHooks) {
       return { success: true, message: this.formatMessage("\u2705 Wired mise.toml ([hooks] enter/leave + tasks)") };
     }
@@ -17790,7 +18231,7 @@ if __name__ == "__main__":
 
 // src/commands/AddMiseCodegraphScript.ts
 import { chmodSync as chmodSync7 } from "fs";
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 var AddMiseCodegraphScript = class extends Command {
   async invoke() {
     const filePath = ".mise/scripts/codegraph.sh";
@@ -17844,7 +18285,7 @@ fi
 `;
     this.writeFile(filePath, content);
     if (!this.context.dryRun) {
-      chmodSync7(join27(this.context.targetDir, filePath), 493);
+      chmodSync7(join28(this.context.targetDir, filePath), 493);
     }
     return {
       success: true,
@@ -17882,12 +18323,12 @@ SECRET_KEY=""
 // src/parity/index.ts
 import { existsSync as existsSync20 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
-import { dirname as dirname20, join as join28, resolve as resolve20 } from "node:path";
+import { dirname as dirname20, join as join29, resolve as resolve20 } from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function resolvePjanglerRoot2() {
   let dir = dirname20(fileURLToPath5(import.meta.url));
   while (dir !== dirname20(dir)) {
-    if (existsSync20(join28(dir, "package.json")) && existsSync20(join28(dir, "templates", "commonproject", "copier.yml"))) return dir;
+    if (existsSync20(join29(dir, "package.json")) && existsSync20(join29(dir, "templates", "commonproject", "copier.yml"))) return dir;
     dir = dirname20(dir);
   }
   return resolve20(process.cwd());
@@ -18079,13 +18520,13 @@ init_project();
 // src/project/info.ts
 init_boardUrl();
 init_project();
-import { readFileSync as readFileSync25 } from "node:fs";
-import { join as join29, resolve as resolve21 } from "node:path";
+import { readFileSync as readFileSync26 } from "node:fs";
+import { join as join30, resolve as resolve21 } from "node:path";
 function readManifest2(root) {
-  const path = join29(root, ".project.json");
+  const path = join30(root, ".project.json");
   let manifest;
   try {
-    const value = JSON.parse(readFileSync25(path, "utf8"));
+    const value = JSON.parse(readFileSync26(path, "utf8"));
     if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("expected a JSON object");
     manifest = value;
   } catch (error) {
@@ -18126,7 +18567,7 @@ function readProjectInfo(input = {}) {
     ok: true,
     project_id: projectId,
     repo_path: resolve21(root),
-    manifest_path: join29(resolve21(root), ".project.json"),
+    manifest_path: join30(resolve21(root), ".project.json"),
     manifest,
     registry: { location, status: "indexed" }
   };
@@ -18175,20 +18616,20 @@ init_project();
 init_version();
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 import {
-  closeSync as closeSync7,
+  closeSync as closeSync8,
   existsSync as existsSync21,
-  fchmodSync as fchmodSync4,
+  fchmodSync as fchmodSync5,
   fsyncSync as fsyncSync5,
-  lstatSync as lstatSync17,
-  mkdirSync as mkdirSync11,
-  openSync as openSync7,
-  readFileSync as readFileSync26,
+  lstatSync as lstatSync18,
+  mkdirSync as mkdirSync12,
+  openSync as openSync8,
+  readFileSync as readFileSync27,
   renameSync as renameSync9,
-  unlinkSync as unlinkSync9,
-  writeFileSync as writeFileSync14
+  unlinkSync as unlinkSync10,
+  writeFileSync as writeFileSync15
 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
-import { dirname as dirname21, join as join30, resolve as resolve22 } from "node:path";
+import { dirname as dirname21, join as join31, resolve as resolve22 } from "node:path";
 import YAML7 from "yaml";
 var DEAD_AGENT_IDS = ["coachingagentframework-pm"];
 function isRecord6(value) {
@@ -18196,7 +18637,7 @@ function isRecord6(value) {
 }
 function hermesAgentsRegistryPath(env2 = process.env, home = homedir12()) {
   const override = env2.HERMES_AGENTS_REGISTRY?.trim();
-  return override || join30(home, ".hermes", "agents-registry.yaml");
+  return override || join31(home, ".hermes", "agents-registry.yaml");
 }
 function planeApiKeyFor(workspace, env2, home) {
   return resolvePlaneApiKey(workspace, env2, home) ?? resolvePlaneApiKey(DEFAULT_PLANE_WORKSPACE, env2, home);
@@ -18207,7 +18648,7 @@ async function fetchPlaneBoards(workspace, env2 = process.env, home = homedir12(
   const apiKey = planeApiKeyFor(workspace, env2, home);
   if (!apiKey) {
     throw new BoardError(
-      `no Plane API key for workspace "${workspace}": set PLANE_API_KEY, or add one to ${env2.HERMES_FLEET_ENV?.trim() || join30(home, ".hermes", "fleet.env")}`
+      `no Plane API key for workspace "${workspace}": set PLANE_API_KEY, or add one to ${env2.HERMES_FLEET_ENV?.trim() || join31(home, ".hermes", "fleet.env")}`
     );
   }
   const base = planeBase(env2, home);
@@ -18256,7 +18697,7 @@ async function patchPlaneBoardIdentifier(workspace, boardId, identifier, env2 =
   const apiKey = planeApiKeyFor(workspace, env2, home);
   if (!apiKey) {
     throw new BoardError(
-      `no Plane API key for workspace "${workspace}": set PLANE_API_KEY, or add one to ${env2.HERMES_FLEET_ENV?.trim() || join30(home, ".hermes", "fleet.env")}`
+      `no Plane API key for workspace "${workspace}": set PLANE_API_KEY, or add one to ${env2.HERMES_FLEET_ENV?.trim() || join31(home, ".hermes", "fleet.env")}`
     );
   }
   const base = planeBase(env2, home);
@@ -18290,7 +18731,7 @@ async function patchPlaneBoardIdentifier(workspace, boardId, identifier, env2 =
   }
 }
 function trelloCredential(name, env2, home) {
-  const fleetEnv = env2.HERMES_FLEET_ENV?.trim() || join30(home, ".hermes", "fleet.env");
+  const fleetEnv = env2.HERMES_FLEET_ENV?.trim() || join31(home, ".hermes", "fleet.env");
   const raw = env2[name]?.trim() || dotenvValue(fleetEnv, name)?.trim();
   return raw ? resolveSecretValue(raw) : void 0;
 }
@@ -18328,7 +18769,7 @@ async function fetchTrelloBoard(boardId, env2 = process.env, home = homedir12())
   };
 }
 function readHermesAgentBoards(path) {
-  const document = YAML7.parseDocument(readFileSync26(path, "utf8"));
+  const document = YAML7.parseDocument(readFileSync27(path, "utf8"));
   if (document.errors.length) throw new Error(`Hermes agents registry YAML is invalid: ${path}`);
   const parsed = document.toJS();
   const agents = isRecord6(parsed) && isRecord6(parsed.agents) ? parsed.agents : {};
@@ -18359,11 +18800,11 @@ function matchRegistrySlug(agent, registry) {
 }
 function readManifestBoard(repoPath) {
   if (!repoPath) return void 0;
-  const path = join30(repoPath, ".project.json");
+  const path = join31(repoPath, ".project.json");
   if (!existsSync21(path)) return void 0;
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync26(path, "utf8"));
+    parsed = JSON.parse(readFileSync27(path, "utf8"));
   } catch {
     return void 0;
   }
@@ -18382,32 +18823,32 @@ function yamlStyleOf(original) {
   return { indentSeq: !/\n([ \t]*)[^\s#][^\n]*:[ \t]*\n\1- /.test(original), lineWidth: 0 };
 }
 function atomicWrite(path, text2) {
-  const mode = existsSync21(path) ? lstatSync17(path).mode & 511 : 384;
-  mkdirSync11(dirname21(path), { recursive: true });
+  const mode = existsSync21(path) ? lstatSync18(path).mode & 511 : 384;
+  mkdirSync12(dirname21(path), { recursive: true });
   const temp = `${path}.${process.pid}.${Date.now()}.tmp`;
   let fd;
   try {
-    fd = openSync7(temp, "wx", mode);
-    writeFileSync14(fd, text2, "utf8");
-    fchmodSync4(fd, mode);
+    fd = openSync8(temp, "wx", mode);
+    writeFileSync15(fd, text2, "utf8");
+    fchmodSync5(fd, mode);
     fsyncSync5(fd);
-    closeSync7(fd);
+    closeSync8(fd);
     fd = void 0;
     renameSync9(temp, path);
   } catch (error) {
     if (fd !== void 0) try {
-      closeSync7(fd);
+      closeSync8(fd);
     } catch {
     }
     try {
-      unlinkSync9(temp);
+      unlinkSync10(temp);
     } catch {
     }
     throw error;
   }
 }
 function applyHermesIdentifiers(path, identifiers, deletions) {
-  const original = readFileSync26(path, "utf8");
+  const original = readFileSync27(path, "utf8");
   const document = YAML7.parseDocument(original);
   if (document.errors.length) throw new Error(`Hermes agents registry YAML is invalid: ${path}`);
   const before = document.toJS();
@@ -18863,11 +19304,11 @@ function formatIdentityReport(report) {
   return lines.join("\n");
 }
 function writeManifestTicketProvider(repoPath, provider, expectedProvider) {
-  const path = join30(repoPath, ".project.json");
+  const path = join31(repoPath, ".project.json");
   if (!existsSync21(path)) return void 0;
   let existing = {};
   try {
-    const parsed = JSON.parse(readFileSync26(path, "utf8"));
+    const parsed = JSON.parse(readFileSync27(path, "utf8"));
     if (isRecord6(parsed)) existing = parsed;
   } catch {
     throw new BoardError(`${path} is not readable JSON; fix it before linking a board`);
@@ -18892,7 +19333,7 @@ function writeManifestTicketProvider(repoPath, provider, expectedProvider) {
   };
   const text2 = `${JSON.stringify(next, null, 2)}
 `;
-  if (readFileSync26(path, "utf8") === text2) return void 0;
+  if (readFileSync27(path, "utf8") === text2) return void 0;
   atomicWrite(path, text2);
   return path;
 }
@@ -18904,8 +19345,8 @@ async function linkProjectBoard(options) {
   const project = getProject(registry, options.slug);
   const boardId = options.boardId.trim();
   if (!boardId) throw new BoardError("a board id is required");
-  const manifestFile = join30(project.repo_path, ".project.json");
-  const expectedProvider = !isRegistryServiceLocation(registryPath) && existsSync21(manifestFile) ? JSON.parse(readFileSync26(manifestFile, "utf8")).ticket_provider : void 0;
+  const manifestFile = join31(project.repo_path, ".project.json");
+  const expectedProvider = !isRegistryServiceLocation(registryPath) && existsSync21(manifestFile) ? JSON.parse(readFileSync27(manifestFile, "utf8")).ticket_provider : void 0;
   const current = project.ticket_provider;
   const type = (current.type || "plane").trim().toLowerCase();
   const workspace = (options.workspace ?? current.workspace ?? DEFAULT_PLANE_WORKSPACE).trim();
@@ -18956,10 +19397,10 @@ async function linkProjectBoard(options) {
   if (apply) {
     registry.projects[project.slug] = { ...project, ticket_provider: { ...current, ...block }, updated_at: now };
     if (isRegistryServiceLocation(registryPath)) {
-      const beforeManifest = existsSync21(manifestFile) ? readFileSync26(manifestFile, "utf8") : null;
+      const beforeManifest = existsSync21(manifestFile) ? readFileSync27(manifestFile, "utf8") : null;
       saveProjectRegistry(registry, registryPath);
       manifestPath = manifestFile;
-      const afterManifest = existsSync21(manifestFile) ? readFileSync26(manifestFile, "utf8") : null;
+      const afterManifest = existsSync21(manifestFile) ? readFileSync27(manifestFile, "utf8") : null;
       if (beforeManifest !== afterManifest) changedFiles.push(manifestFile);
     } else {
       manifestPath = writeManifestTicketProvider(project.repo_path, block, expectedProvider);
@@ -18968,7 +19409,7 @@ async function linkProjectBoard(options) {
       changedFiles.push(registryPath);
     }
   } else {
-    manifestPath = existsSync21(join30(project.repo_path, ".project.json")) ? join30(project.repo_path, ".project.json") : void 0;
+    manifestPath = existsSync21(join31(project.repo_path, ".project.json")) ? join31(project.repo_path, ".project.json") : void 0;
   }
   return {
     ok: true,
@@ -18992,9 +19433,9 @@ async function linkProjectBoard(options) {
 // src/project/rename.ts
 init_boardUrl();
 import { spawnSync as spawnSync15 } from "node:child_process";
-import { existsSync as existsSync22, readdirSync as readdirSync11, readFileSync as readFileSync27, realpathSync as realpathSync11, statSync as statSync6 } from "node:fs";
+import { existsSync as existsSync22, readdirSync as readdirSync12, readFileSync as readFileSync28, realpathSync as realpathSync11, statSync as statSync6 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
-import { isAbsolute as isAbsolute11, join as join31, relative as relative16 } from "node:path";
+import { isAbsolute as isAbsolute11, join as join32, relative as relative16 } from "node:path";
 import YAML8 from "yaml";
 init_project();
 init_registryClient();
@@ -19015,7 +19456,7 @@ function message(error) {
 function readJsonObject(path) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync27(path, "utf8"));
+    parsed = JSON.parse(readFileSync28(path, "utf8"));
   } catch {
     throw new RenameError("manifest_invalid", `${path} is not readable JSON; fix it before renaming`);
   }
@@ -19068,7 +19509,7 @@ async function renameProject(options) {
     let from;
     if (existing && oldInput) {
       try {
-        const candidate = readJsonObject(join31(existing.repo_path, ".project.json")).renamed_from;
+        const candidate = readJsonObject(join32(existing.repo_path, ".project.json")).renamed_from;
         if (isRecord7(candidate)) from = candidate;
       } catch {
       }
@@ -19087,7 +19528,7 @@ async function renameProject(options) {
   const isPlane = type === "plane";
   const workspace = isPlane ? String(provider.workspace ?? "").trim() || DEFAULT_PLANE_WORKSPACE : String(provider.workspace ?? "").trim();
   const repoPath = record3.repo_path;
-  const manifestPath = join31(repoPath, ".project.json");
+  const manifestPath = join32(repoPath, ".project.json");
   const manifestExists = existsSync22(manifestPath);
   if (service && !manifestExists) {
     throw new RenameError("manifest_missing", `${manifestPath} is missing; the registry service indexes manifests, so there is nothing to rename`);
@@ -19232,7 +19673,7 @@ async function renameProject(options) {
     return { status: "done", detail, files: service ? [] : [registryPath] };
   };
   const roleStep = async (doApply) => {
-    const hermesDir = join31(repoPath, "agents", "hermes");
+    const hermesDir = join32(repoPath, "agents", "hermes");
     if (!existsSync22(hermesDir)) return { status: "skipped", detail: "no agents/hermes directory" };
     if (!isPlane) return { status: "skipped", detail: "role.yaml plane.identifier is a Plane field" };
     const files = [];
@@ -19240,16 +19681,16 @@ async function renameProject(options) {
     let settled = 0;
     let entries;
     try {
-      entries = readdirSync11(hermesDir, { withFileTypes: true });
+      entries = readdirSync12(hermesDir, { withFileTypes: true });
     } catch (error) {
       return { status: "failed", detail: `${hermesDir}: ${message(error)}` };
     }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const path = join31(hermesDir, entry.name, "role.yaml");
+      const path = join32(hermesDir, entry.name, "role.yaml");
       if (!existsSync22(path)) continue;
       try {
-        const original = readFileSync27(path, "utf8");
+        const original = readFileSync28(path, "utf8");
         const document = YAML8.parseDocument(original);
         if (document.errors.length) throw new Error("YAML is invalid");
         const node = document.getIn(["plane", "identifier"], true);
@@ -19307,7 +19748,7 @@ async function renameProject(options) {
     }
   };
   const agentsMdStep = async (doApply) => {
-    const link = join31(repoPath, "AGENTS.md");
+    const link = join32(repoPath, "AGENTS.md");
     if (!existsSync22(link)) return { status: "skipped", detail: "no AGENTS.md" };
     try {
       const path = realpathSync11(link);
@@ -19315,7 +19756,7 @@ async function renameProject(options) {
       if (inside.startsWith("..") || isAbsolute11(inside)) {
         return { status: "skipped", detail: `AGENTS.md resolves outside the repo (${path}); left untouched` };
       }
-      const original = readFileSync27(path, "utf8");
+      const original = readFileSync28(path, "utf8");
       const lines = original.split("\n");
       let boardLines = 0;
       let replaced = 0;
@@ -19345,8 +19786,8 @@ async function renameProject(options) {
     }
   };
   const hintsStep = async (doApply) => {
-    const configDir = env2.PILOT_CONFIG_DIR?.trim() || join31(env2.XDG_CONFIG_HOME?.trim() || join31(home, ".config"), "pilot");
-    const path = join31(configDir, "harvest", "project-hints.json");
+    const configDir = env2.PILOT_CONFIG_DIR?.trim() || join32(env2.XDG_CONFIG_HOME?.trim() || join32(home, ".config"), "pilot");
+    const path = join32(configDir, "harvest", "project-hints.json");
     if (!existsSync22(path)) return { status: "skipped", detail: `no harvest hints at ${path}` };
     try {
       const hints = readJsonObject(path);
@@ -19380,7 +19821,7 @@ async function renameProject(options) {
     if (oldInput === newId && steps.every((step) => step.status === "already" || step.status === "skipped")) {
       return { status: "already", detail: "nothing changed; projection not re-synced" };
     }
-    const cwd = join31(home, "code", "33GOD", "candystore");
+    const cwd = join32(home, "code", "33GOD", "candystore");
     try {
       if (!statSync6(cwd).isDirectory()) throw new Error("not a directory");
     } catch {
@@ -19475,7 +19916,7 @@ init_boardQuery();
 // src/describe/activity.ts
 import { spawn as spawn3, spawnSync as spawnSync16 } from "node:child_process";
 import { statSync as statSync7 } from "node:fs";
-import { join as join32 } from "node:path";
+import { join as join33 } from "node:path";
 var ACTIVE_WINDOW_SECONDS = 24 * 60 * 60;
 var MAX_DIRTY_STATS = 500;
 var GIT_TIMEOUT_MS = 5e3;
@@ -19640,7 +20081,7 @@ function uncommittedSource(repo, paths) {
   let newest = 0;
   for (const path of paths.slice(0, MAX_DIRTY_STATS)) {
     try {
-      const mtime = Math.floor(statSync7(join32(repo, path)).mtimeMs / 1e3);
+      const mtime = Math.floor(statSync7(join33(repo, path)).mtimeMs / 1e3);
       if (mtime > newest) newest = mtime;
     } catch {
     }
@@ -19838,8 +20279,8 @@ function openUrl(url, env2 = process.env, platform = process.platform) {
 }
 
 // src/describe/index.ts
-import { existsSync as existsSync23, readFileSync as readFileSync28, readdirSync as readdirSync12, statSync as statSync8 } from "node:fs";
-import { join as join33, resolve as resolve23 } from "node:path";
+import { existsSync as existsSync23, readFileSync as readFileSync29, readdirSync as readdirSync13, statSync as statSync8 } from "node:fs";
+import { join as join34, resolve as resolve23 } from "node:path";
 init_project();
 init_config();
 init_state();
@@ -19895,7 +20336,7 @@ var CONFIG_FILES = [
 ];
 function readJson(path) {
   try {
-    const parsed = JSON.parse(readFileSync28(path, "utf8"));
+    const parsed = JSON.parse(readFileSync29(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
   } catch {
     return void 0;
@@ -19917,23 +20358,23 @@ function describeType(repo) {
   const evidence = [];
   const note = (signal, file) => evidence.push(`${signal} (${file})`);
   for (const marker of LANGUAGE_MARKERS) {
-    if (!existsSync23(join33(repo, marker.file))) continue;
+    if (!existsSync23(join34(repo, marker.file))) continue;
     if (!languages.includes(marker.language)) {
       languages.push(marker.language);
       note(marker.language, marker.file);
     }
   }
   try {
-    const dotnet = readdirSync12(repo).find((entry) => entry.endsWith(".csproj") || entry.endsWith(".sln"));
+    const dotnet = readdirSync13(repo).find((entry) => entry.endsWith(".csproj") || entry.endsWith(".sln"));
     if (dotnet && !languages.includes("dotnet")) {
       languages.push("dotnet");
       note("dotnet", dotnet);
     }
   } catch {
   }
-  const pkg = readJson(join33(repo, "package.json"));
+  const pkg = readJson(join34(repo, "package.json"));
   if (pkg) {
-    if (existsSync23(join33(repo, "tsconfig.json"))) {
+    if (existsSync23(join34(repo, "tsconfig.json"))) {
       const index = languages.indexOf("javascript");
       if (index >= 0) languages.splice(index, 1);
       if (!languages.includes("typescript")) {
@@ -19967,14 +20408,14 @@ function describeType(repo) {
     ["hermes-fleet-host", "agents/hermes"]
   ];
   for (const [role, marker] of roleMarkers) {
-    if (!existsSync23(join33(repo, marker))) continue;
+    if (!existsSync23(join34(repo, marker))) continue;
     roles.push(role);
     note(role, marker);
   }
   return { primaryLanguage: languages[0], languages, roles, evidence };
 }
 function describeIdentity(repo, registryPath) {
-  const manifestPath = join33(repo, ".project.json");
+  const manifestPath = join34(repo, ".project.json");
   const manifest = readJson(manifestPath);
   const drift = [];
   let record3;
@@ -20067,12 +20508,12 @@ function describeSubsystems(repo, findings) {
     const markers = SUBSYSTEM_MARKERS[metadata.id] ?? [];
     const evidence = metadata.id === "notebook" ? (() => {
       try {
-        const manifest = JSON.parse(readFileSync28(join33(repo, ".project.json"), "utf8"));
+        const manifest = JSON.parse(readFileSync29(join34(repo, ".project.json"), "utf8"));
         return manifest.notebook && typeof manifest.notebook === "object" ? [".project.json#notebook"] : [];
       } catch {
         return [];
       }
-    })() : markers.filter((marker) => existsSync23(join33(repo, marker)));
+    })() : markers.filter((marker) => existsSync23(join34(repo, marker)));
     const rules = (byRecipe.get(metadata.id) ?? []).map((finding2) => ({
       id: finding2.id,
       title: finding2.title,
@@ -20091,7 +20532,7 @@ function describeNotebook(repo, registryPath) {
   try {
     const registry = loadProjectRegistry(registryPath);
     const project = Object.values(registry.projects).find((entry) => resolve23(entry.repo_path) === resolve23(repo));
-    const manifest = existsSync23(join33(repo, ".project.json")) ? JSON.parse(readFileSync28(join33(repo, ".project.json"), "utf8")) : void 0;
+    const manifest = existsSync23(join34(repo, ".project.json")) ? JSON.parse(readFileSync29(join34(repo, ".project.json"), "utf8")) : void 0;
     const declared = Boolean(project?.notebook || manifest?.notebook && typeof manifest.notebook === "object");
     if (!declared) return { declared: false, bindingState: null, notebookId: null, overviewNoteId: null, health: null, remoteCheck: "skip", captureAdmission: null };
     const config = loadEffectiveNotebookConfig(repo, registryPath);
@@ -20109,7 +20550,7 @@ function describeNotebook(repo, registryPath) {
   }
 }
 function describeConfigFiles(repo) {
-  return CONFIG_FILES.filter((spec) => existsSync23(join33(repo, spec.path))).map((spec) => ({ path: spec.path, purpose: spec.purpose, subsystem: spec.subsystem }));
+  return CONFIG_FILES.filter((spec) => existsSync23(join34(repo, spec.path))).map((spec) => ({ path: spec.path, purpose: spec.purpose, subsystem: spec.subsystem }));
 }
 function describeNextSteps(description, findings) {
   const steps = [];
@@ -20533,7 +20974,7 @@ init_style();
 // src/notebook/cli.ts
 init_project();
 init_capture();
-import { closeSync as closeSync8, constants as constants6, existsSync as existsSync24, fstatSync as fstatSync4, lstatSync as lstatSync18, openSync as openSync8, readSync as readSync4 } from "node:fs";
+import { closeSync as closeSync9, constants as constants7, existsSync as existsSync24, fstatSync as fstatSync5, lstatSync as lstatSync19, openSync as openSync9, readSync as readSync4 } from "node:fs";
 import { resolve as resolve24 } from "node:path";
 import { createInterface } from "node:readline/promises";
 
@@ -20676,12 +21117,12 @@ async function execute(input) {
 function readBoundedRegularFile(path, maxBytes) {
   const absolute = resolve24(path);
   if (!existsSync24(absolute)) throw new NotebookError("INVALID_INPUT", `File not found: ${absolute}`);
-  const before = lstatSync18(absolute);
+  const before = lstatSync19(absolute);
   if (!before.isFile() || before.isSymbolicLink()) throw new NotebookError("INVALID_INPUT", `File must be a regular non-symlink: ${absolute}`);
   if (before.size > maxBytes) throw new NotebookError("INVALID_INPUT", `File exceeds the configured ceiling: ${absolute}`);
-  const fd = openSync8(absolute, constants6.O_RDONLY | (constants6.O_NOFOLLOW ?? 0));
+  const fd = openSync9(absolute, constants7.O_RDONLY | (constants7.O_NOFOLLOW ?? 0));
   try {
-    const opened = fstatSync4(fd);
+    const opened = fstatSync5(fd);
     if (!opened.isFile() || opened.dev !== before.dev || opened.ino !== before.ino) throw new NotebookError("INVALID_INPUT", `File changed while opening: ${absolute}`);
     const chunks = [];
     let total = 0;
@@ -20699,7 +21140,7 @@ function readBoundedRegularFile(path, maxBytes) {
       throw new NotebookError("INVALID_INPUT", `File must be valid UTF-8: ${absolute}`);
     }
   } finally {
-    closeSync8(fd);
+    closeSync9(fd);
   }
 }
 function textInput(options, maxBytes) {
@@ -20951,14 +21392,14 @@ async function loadScreen(relativeToDist, base) {
 init_boardQuery();
 init_style();
 import { spawnSync as spawnSync17 } from "node:child_process";
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync30, realpathSync as realpathSync12, renameSync as renameSync10, writeFileSync as writeFileSync15 } from "node:fs";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync31, realpathSync as realpathSync12, renameSync as renameSync10, writeFileSync as writeFileSync16 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
-import { dirname as dirname22, join as join35 } from "node:path";
+import { dirname as dirname22, join as join36 } from "node:path";
 
 // src/crank/engine.ts
-import { closeSync as closeSync9, constants as constants7, fstatSync as fstatSync5, openSync as openSync9, readFileSync as readFileSync29, readSync as readSync5 } from "node:fs";
+import { closeSync as closeSync10, constants as constants8, fstatSync as fstatSync6, openSync as openSync10, readFileSync as readFileSync30, readSync as readSync5 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
-import { join as join34 } from "node:path";
+import { join as join35 } from "node:path";
 var ENGINE_DEFAULT_JOB_ID = "777c511a009c";
 var WINDOW_MS = 24 * 60 * 60 * 1e3;
 var TICK_MS = 5 * 60 * 1e3;
@@ -21058,9 +21499,9 @@ function parseEngineStatus(auditText, input) {
   }
 }
 function readTail(path, maxBytes) {
-  const fd = openSync9(path, constants7.O_RDONLY | constants7.O_NONBLOCK);
+  const fd = openSync10(path, constants8.O_RDONLY | constants8.O_NONBLOCK);
   try {
-    const stat = fstatSync5(fd);
+    const stat = fstatSync6(fd);
     if (!stat.isFile()) throw new Error(`${path} is not a regular file`);
     const size = stat.size;
     const length = Math.min(size, maxBytes);
@@ -21076,20 +21517,20 @@ function readTail(path, maxBytes) {
     const newline = text2.indexOf("\n");
     return newline === -1 ? "" : text2.slice(newline + 1);
   } finally {
-    closeSync9(fd);
+    closeSync10(fd);
   }
 }
 function engineSources(env2 = process.env) {
-  const cronDir = join34(homedir14(), ".hermes", "profiles", "33god-pm", "cron");
+  const cronDir = join35(homedir14(), ".hermes", "profiles", "33god-pm", "cron");
   return {
-    auditPath: env2.PJ_CRANK_USAGE_AUDIT?.trim() || join34(cronDir, "usage_audit.jsonl"),
-    jobsPath: join34(cronDir, "jobs.json"),
+    auditPath: env2.PJ_CRANK_USAGE_AUDIT?.trim() || join35(cronDir, "usage_audit.jsonl"),
+    jobsPath: join35(cronDir, "jobs.json"),
     jobId: env2.PJ_CRANK_JOB_ID?.trim() || ENGINE_DEFAULT_JOB_ID
   };
 }
 function readCap(jobsPath, jobId) {
   try {
-    const parsed = JSON.parse(readFileSync29(jobsPath, "utf8"));
+    const parsed = JSON.parse(readFileSync30(jobsPath, "utf8"));
     const jobs = Array.isArray(parsed.jobs) ? parsed.jobs : [];
     const job = jobs.find((j) => typeof j === "object" && j !== null && String(j.id ?? "") === jobId);
     const economics = job?.economics;
@@ -21475,11 +21916,11 @@ function withTabOwners(tabs, panes, identify, claimed = []) {
 }
 var PANE_CWD_TTL_SECONDS = 6 * 3600;
 function paneCwdCachePath(env2 = process.env) {
-  return env2.ZCRANK_CWD_CACHE?.trim() || join35(homedir15(), ".local/state/zcrank/pane-cwds.json");
+  return env2.ZCRANK_CWD_CACHE?.trim() || join36(homedir15(), ".local/state/zcrank/pane-cwds.json");
 }
 function loadCwdCache(path) {
   try {
-    const parsed = JSON.parse(readFileSync30(path, "utf8"));
+    const parsed = JSON.parse(readFileSync31(path, "utf8"));
     return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
@@ -21487,9 +21928,9 @@ function loadCwdCache(path) {
 }
 function saveCwdCache(path, cache) {
   try {
-    mkdirSync12(dirname22(path), { recursive: true });
+    mkdirSync13(dirname22(path), { recursive: true });
     const tmp = `${path}.${process.pid}.tmp`;
-    writeFileSync15(tmp, JSON.stringify(cache));
+    writeFileSync16(tmp, JSON.stringify(cache));
     renameSync10(tmp, path);
   } catch {
   }
@@ -21642,7 +22083,7 @@ function resolveByName(project, live, storedTabs) {
 function projectNameFor(handle, registryName) {
   if (registryName && registryName.trim()) return registryName.trim();
   try {
-    const manifest = JSON.parse(readFileSync30(join35(handle.root, ".project.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync31(join36(handle.root, ".project.json"), "utf8"));
     const name = manifest.project_name;
     if (typeof name === "string" && name.trim()) return name.trim();
   } catch {
@@ -21653,7 +22094,7 @@ function projectAgentsFor(handle, registryAgents) {
   const fromRecord = Object.entries(registryAgents ?? {}).map(([agentHandle, value]) => ({ handle: agentHandle, role: String(value?.role ?? "") }));
   if (fromRecord.length) return fromRecord;
   try {
-    const manifest = JSON.parse(readFileSync30(join35(handle.root, ".project.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync31(join36(handle.root, ".project.json"), "utf8"));
     const agents = manifest.agents;
     if (agents && typeof agents === "object" && !Array.isArray(agents)) {
       return Object.entries(agents).map(([agentHandle, value]) => ({ handle: agentHandle, role: typeof value?.role === "string" ? value.role : "" }));
@@ -21971,9 +22412,9 @@ function createCrankController(deps) {
 }
 
 // src/crank/panes.ts
-import { readFileSync as readFileSync31, readdirSync as readdirSync13, readlinkSync as readlinkSync9 } from "node:fs";
+import { readFileSync as readFileSync32, readdirSync as readdirSync14, readlinkSync as readlinkSync9 } from "node:fs";
 import { homedir as homedir16 } from "node:os";
-import { basename as basename11, join as join36 } from "node:path";
+import { basename as basename12, join as join37 } from "node:path";
 var AGENT_CLIS = [
   "claude",
   "codex",
@@ -22055,7 +22496,7 @@ function parseProcStat(text2) {
 }
 function readProcStat(pid) {
   try {
-    return parseProcStat(readFileSync31(`/proc/${pid}/stat`, "latin1"));
+    return parseProcStat(readFileSync32(`/proc/${pid}/stat`, "latin1"));
   } catch {
     return null;
   }
@@ -22063,7 +22504,7 @@ function readProcStat(pid) {
 function readTag(pid) {
   let raw;
   try {
-    raw = readFileSync31(`/proc/${pid}/environ`);
+    raw = readFileSync32(`/proc/${pid}/environ`);
   } catch {
     return null;
   }
@@ -22089,8 +22530,8 @@ function readTag(pid) {
 }
 function readArgv(pid) {
   try {
-    const parts = readFileSync31(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean);
-    return { argv: parts.join(" "), exe: parts[0] ? basename11(parts[0]) : "" };
+    const parts = readFileSync32(`/proc/${pid}/cmdline`, "utf8").split("\0").filter(Boolean);
+    return { argv: parts.join(" "), exe: parts[0] ? basename12(parts[0]) : "" };
   } catch {
     return { argv: "", exe: "" };
   }
@@ -22130,7 +22571,7 @@ var ProcScanner = class {
       pids = [...this.enumerate()];
     } else {
       try {
-        pids = readdirSync13("/proc").filter((name) => /^\d+$/.test(name)).map(Number);
+        pids = readdirSync14("/proc").filter((name) => /^\d+$/.test(name)).map(Number);
       } catch {
         return [];
       }
@@ -22166,13 +22607,13 @@ var ProcScanner = class {
 var PANE_STATUSES = ["busy", "idle", "shell"];
 function claudeSessionsDir(env2 = process.env) {
   const override = env2.PJ_CLAUDE_SESSIONS_DIR?.trim();
-  return override || join36(homedir16(), ".claude", "sessions");
+  return override || join37(homedir16(), ".claude", "sessions");
 }
 function readClaudeSession(pid, stat, dir = claudeSessionsDir()) {
   const none = (reason) => ({ kind: null, sessionId: null, reason, status: "unknown", statusUpdatedAt: null });
   let raw;
   try {
-    raw = readFileSync31(join36(dir, `${pid}.json`), "utf8");
+    raw = readFileSync32(join37(dir, `${pid}.json`), "utf8");
   } catch {
     return none("no-session-file");
   }
@@ -22633,7 +23074,7 @@ async function promptForRuleIds(rules) {
 function readJson2(path) {
   if (!existsSync26(path)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync32(path, "utf8"));
+    const parsed = JSON.parse(readFileSync33(path, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
   } catch {
     return void 0;
@@ -22650,9 +23091,9 @@ function packageNameToProjectName(value) {
   return name.replace(/[-_]+/g, " ").replace(/\b\w/g, (letter) => letter.toUpperCase()).trim();
 }
 function deriveProjectDefaults(targetDir) {
-  const manifest = readJson2(join37(targetDir, ".project.json"));
-  const pkg = readJson2(join37(targetDir, "package.json"));
-  const name = String(manifest?.project_name ?? "").trim() || packageNameToProjectName(typeof pkg?.name === "string" ? pkg.name : void 0) || packageNameToProjectName(basename12(targetDir)) || "Project";
+  const manifest = readJson2(join38(targetDir, ".project.json"));
+  const pkg = readJson2(join38(targetDir, "package.json"));
+  const name = String(manifest?.project_name ?? "").trim() || packageNameToProjectName(typeof pkg?.name === "string" ? pkg.name : void 0) || packageNameToProjectName(basename13(targetDir)) || "Project";
   const ticketProvider = manifest?.ticket_provider && typeof manifest.ticket_provider === "object" ? manifest.ticket_provider : {};
   return {
     name,
@@ -22726,7 +23167,7 @@ function actionNeedsRun(plan, kind, syncMode) {
     if (!action || action.kind !== "project.write-manifest") return false;
     const next = `${JSON.stringify(action.manifest, null, 2)}
 `;
-    return !existsSync26(action.path) || readFileSync32(action.path, "utf8") !== next;
+    return !existsSync26(action.path) || readFileSync33(action.path, "utf8") !== next;
   }
   if (kind === "copier.copy.commonproject") return true;
   if (kind === "ticket-provider.create-or-link") return plan.actions.some((action) => action.kind === kind && action.enabled);
@@ -22783,11 +23224,11 @@ async function resolveProjectInitTarget(name, options) {
   if (!targetDir && cwdGitRoot) {
     targetDir = cwdGitRoot;
   }
-  if (!targetDir && !name && existsSync26(join37(cwd, ".project.json"))) {
+  if (!targetDir && !name && existsSync26(join38(cwd, ".project.json"))) {
     targetDir = cwd;
   }
   if (!targetDir && interactive) {
-    const promptedName = await promptTextValue("Project name", packageNameToProjectName(basename12(cwd)));
+    const promptedName = await promptTextValue("Project name", packageNameToProjectName(basename13(cwd)));
     targetDir = resolve25(await promptTextValue("Project directory", projectTargetDirUnder(promptedName, cwd)));
     name = promptedName;
   }
@@ -22797,14 +23238,14 @@ async function resolveProjectInitTarget(name, options) {
   const targetExists = existsSync26(targetDir);
   if (targetExists && !statSync9(targetDir).isDirectory()) throw new Error(`Target path is not a directory: ${targetDir}`);
   const targetGitRoot = targetExists ? findGitRoot(targetDir) : void 0;
-  const alreadyScaffolded = targetExists && (existsSync26(join37(targetDir, ".project.json")) || existsSync26(join37(targetDir, ".copier-answers.yml")));
+  const alreadyScaffolded = targetExists && (existsSync26(join38(targetDir, ".project.json")) || existsSync26(join38(targetDir, ".copier-answers.yml")));
   const syncMode = Boolean(
     targetGitRoot && resolve25(targetGitRoot) === resolve25(targetDir) || alreadyScaffolded
   );
-  if (targetExists && !syncMode && !options.force && readdirSync14(targetDir).length > 0) {
+  if (targetExists && !syncMode && !options.force && readdirSync15(targetDir).length > 0) {
     throw new Error(`Target already exists and is not empty: ${targetDir} (pass --force to render over it)`);
   }
-  const defaults = targetExists ? deriveProjectDefaults(targetDir) : { name: packageNameToProjectName(basename12(targetDir)) ?? "Project", description: "" };
+  const defaults = targetExists ? deriveProjectDefaults(targetDir) : { name: packageNameToProjectName(basename13(targetDir)) ?? "Project", description: "" };
   if (!name && interactive && !syncMode) {
     name = await promptTextValue("Project name", defaults.name);
   }
@@ -23319,7 +23760,7 @@ program.command("reindex").argument("[project-id]", "Canonical project ID (defau
     else if (options.all) result2 = registryRequest(location, "POST", "/v1/reindex", {});
     else {
       const repo = projectId ? getProject(loadProjectRegistry(location), projectId).repo_path : resolveProject(process.cwd()).root;
-      result2 = registryRequest(location, "POST", "/v1/index", { manifest_path: join37(repo, ".project.json") });
+      result2 = registryRequest(location, "POST", "/v1/index", { manifest_path: join38(repo, ".project.json") });
     }
     const statuses = result2.__registry_status;
     const stale = Object.entries(statuses ?? {}).filter(([, item]) => item.status !== "ok");