snipara-companion 3.6.21 → 3.6.22

package/dist/index.js

@@ -405,9 +405,9 @@ function warnIfCompanionUpdateAvailable(currentVersion) {
 
 // src/commands/init.ts
 var readline = __toESM(require("readline"));
-var fs10 = __toESM(require("fs"));
-var path10 = __toESM(require("path"));
-var import_node_crypto = require("crypto");
+var fs11 = __toESM(require("fs"));
+var path11 = __toESM(require("path"));
+var import_node_crypto2 = require("crypto");
 
 // src/config/store.ts
 var fs2 = __toESM(require("fs"));
@@ -608,9 +608,9 @@ function getConfigPath(options = {}) {
 }
 
 // src/api/client.ts
-var fs4 = __toESM(require("fs"));
+var fs5 = __toESM(require("fs"));
 var os3 = __toESM(require("os"));
-var path4 = __toESM(require("path"));
+var path5 = __toESM(require("path"));
 
 // src/project/resolver.ts
 var fs3 = __toESM(require("fs"));
@@ -690,6 +690,70 @@ function readGitRemote(cwd) {
   return `${match[1]}/${match[2]}`;
 }
 
+// src/session/checkpoint.ts
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var import_node_crypto = require("crypto");
+function checkpointText(value, limit = 12e3) {
+  return value.replace(
+    /-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?-----END [^-]*PRIVATE KEY-----/g,
+    "[REDACTED PRIVATE KEY]"
+  ).replace(/\bBearer\s+[A-Za-z0-9._~+/=-]{12,}/gi, "Bearer [REDACTED]").replace(/\b(?:sk|snp|rlm)[_-][A-Za-z0-9_-]{16,}\b/g, "[REDACTED KEY]").replace(
+    /\b([\w-]*(?:api[_-]?key|token|password|passwd|secret)[\w-]*)\s*[:=]\s*(?:"[^"]*"|'[^']*'|[^\s,;]+)/gi,
+    "$1=[REDACTED]"
+  ).trim().slice(0, limit);
+}
+function normalizeSessionCheckpoint(input) {
+  if (!/^[A-Za-z0-9_.:-]{1,200}$/.test(input.sessionId)) {
+    throw new Error(
+      "Session id must contain 1-200 letters, digits, dots, colons, underscores or hyphens"
+    );
+  }
+  return {
+    sessionId: input.sessionId,
+    summary: checkpointText(input.summary ?? ""),
+    files: [
+      ...new Set((input.files ?? []).map((file) => checkpointText(file, 500)).filter(Boolean))
+    ].sort().slice(0, 100)
+  };
+}
+function sessionCloseoutPath(cwd, projectId, checkpoint) {
+  const digest = (0, import_node_crypto.createHash)("sha256").update(JSON.stringify({ projectId, checkpoint })).digest("hex");
+  return path4.join(cwd, ".snipara", "companion", "session-closeouts", `${digest}.json`);
+}
+function lockSessionCloseout(file) {
+  const lockPath = `${file}.lock`;
+  if (fs4.existsSync(lockPath)) {
+    const owner = Number(fs4.readFileSync(lockPath, "utf8"));
+    if (Number.isSafeInteger(owner) && owner > 0) {
+      try {
+        process.kill(owner, 0);
+      } catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ESRCH") {
+          fs4.unlinkSync(lockPath);
+        }
+      }
+    }
+  }
+  const lock = fs4.openSync(lockPath, "wx", 384);
+  fs4.writeSync(lock, String(process.pid));
+  return lock;
+}
+function readSessionCloseout(file) {
+  if (!fs4.existsSync(file)) return void 0;
+  const value = JSON.parse(fs4.readFileSync(file, "utf8"));
+  if (value.version !== "snipara.session_closeout.v1" || typeof value.workspace !== "string" || typeof value.projectId !== "string" || typeof value.checkpoint?.sessionId !== "string" || typeof value.checkpoint.summary !== "string" || !Array.isArray(value.checkpoint.files) || !value.checkpoint.files.every((file2) => typeof file2 === "string") || value.status === "saved" && (typeof value.entryId !== "string" || !value.entryId.trim()) || !["pending", "saved", "skipped", "error"].includes(value.status)) {
+    throw new Error("Invalid session closeout receipt");
+  }
+  return value;
+}
+function writeSessionCloseout(file, value) {
+  fs4.mkdirSync(path4.dirname(file), { recursive: true, mode: 448 });
+  const temporary = `${file}.${(0, import_node_crypto.randomUUID)()}.tmp`;
+  fs4.writeFileSync(temporary, JSON.stringify(value, null, 2) + "\n", { mode: 384 });
+  fs4.renameSync(temporary, file);
+}
+
 // src/api/client.ts
 var CORRELATED_RETRIEVAL_TOOL_NAMES = /* @__PURE__ */ new Set([
   "snipara_context_query",
@@ -708,15 +772,15 @@ function withCompanionRetrievalClient(toolName, args) {
   };
 }
 function getSniparaTokenStorePath() {
-  return path4.join(os3.homedir(), ".snipara", "tokens.json");
+  return path5.join(os3.homedir(), ".snipara", "tokens.json");
 }
 function loadProjectApiKeyFromTokenStore(projectIdentifier, currentApiKey) {
   const tokensPath = getSniparaTokenStorePath();
-  if (!fs4.existsSync(tokensPath)) {
+  if (!fs5.existsSync(tokensPath)) {
     return null;
   }
   try {
-    const raw = fs4.readFileSync(tokensPath, "utf8");
+    const raw = fs5.readFileSync(tokensPath, "utf8");
     const parsed = JSON.parse(raw);
     const direct = parsed[projectIdentifier];
     if (direct?.api_key && direct.api_key !== currentApiKey) {
@@ -1100,13 +1164,41 @@ var RLMClient = class {
     };
   }
   /**
-   * Persist session context using snipara_remember
+   * Persist an explicit bounded checkpoint to the hosted journal. An event
+   * acknowledgement is not a persistence receipt.
    */
-  async persistSession() {
+  async persistSession(input = {}) {
+    const checkpoint = normalizeSessionCheckpoint({
+      ...input,
+      sessionId: input.sessionId ?? this.config.sessionId ?? "unknown"
+    });
+    if (!checkpoint.summary && checkpoint.files.length === 0) {
+      return {
+        success: false,
+        status: "skipped",
+        session_id: checkpoint.sessionId,
+        files_tracked: 0
+      };
+    }
+    const receipt = await this.journalAppend(
+      [
+        "Checkpoint: session-end",
+        `Session: ${checkpoint.sessionId}`,
+        checkpoint.summary ? `Summary: ${checkpoint.summary}` : "Summary: Session file checkpoint",
+        checkpoint.files.length ? `Files: ${checkpoint.files.join(", ")}` : ""
+      ].filter(Boolean).join("\n"),
+      ["companion", "checkpoint", "session-end"]
+    );
+    if (receipt.success === false || typeof receipt.entry_id !== "string" || !receipt.entry_id.trim()) {
+      throw new Error("Hosted journal did not confirm a persisted entry");
+    }
     return {
       success: true,
-      session_id: this.config.sessionId || "unknown",
-      files_tracked: 0
+      status: "saved",
+      session_id: checkpoint.sessionId,
+      files_tracked: checkpoint.files.length,
+      entry_id: receipt.entry_id,
+      date: receipt.date
     };
   }
   /**
@@ -1748,9 +1840,9 @@ var RLMClient = class {
       ...maxTokens ? { max_tokens: maxTokens } : {}
     });
   }
-  async uploadDocument(path44, content, options = {}) {
+  async uploadDocument(path46, content, options = {}) {
     return this.mcpCall("snipara_upload_document", {
-      path: path44,
+      path: path46,
       content,
       ...options.kind ? { kind: options.kind } : {},
       ...options.format ? { format: options.format } : {},
@@ -1877,9 +1969,9 @@ var RLMClient = class {
       ...maxTokens ? { max_tokens: maxTokens } : {}
     });
   }
-  async loadDocument(path44) {
+  async loadDocument(path46) {
     return this.mcpCall("snipara_load_document", {
-      path: path44
+      path: path46
     });
   }
   async getSessionMemories(maxCriticalTokens, maxDailyTokens, includeYesterday) {
@@ -1945,8 +2037,8 @@ function createClient(timeout, options = {}) {
 
 // src/commands/automations.ts
 var crypto = __toESM(require("crypto"));
-var fs5 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 var AUTOMATION_MANIFEST_RELATIVE_PATH = ".snipara/automations/manifest.json";
 var MANIFEST_VERSION = 1;
 var SUPPORTED_CLIENTS = /* @__PURE__ */ new Set([
@@ -2061,20 +2153,20 @@ function canInstallNativeHookBundle(client) {
   return NATIVE_HOOK_CAPABLE_CLIENTS.has(client);
 }
 function normalizeProjectDir(dir) {
-  return path5.resolve(dir || process.cwd());
+  return path6.resolve(dir || process.cwd());
 }
 function normalizeRelativePath(filePath) {
-  const normalized = path5.posix.normalize(filePath.replace(/\\/g, "/"));
-  if (normalized === "." || normalized.startsWith("../") || normalized.includes("/../") || path5.isAbsolute(filePath)) {
+  const normalized = path6.posix.normalize(filePath.replace(/\\/g, "/"));
+  if (normalized === "." || normalized.startsWith("../") || normalized.includes("/../") || path6.isAbsolute(filePath)) {
     throw new Error(`Unsafe automation file path: ${filePath}`);
   }
   return normalized;
 }
 function resolveTargetPath(projectDir, filePath) {
   const normalized = normalizeRelativePath(filePath);
-  const target = path5.resolve(projectDir, normalized);
-  const root = path5.resolve(projectDir);
-  if (target !== root && !target.startsWith(`${root}${path5.sep}`)) {
+  const target = path6.resolve(projectDir, normalized);
+  const root = path6.resolve(projectDir);
+  if (target !== root && !target.startsWith(`${root}${path6.sep}`)) {
     throw new Error(`Automation file escapes project directory: ${filePath}`);
   }
   return target;
@@ -2234,21 +2326,21 @@ function prepareBundleForLocalInstall(client, bundle) {
   };
 }
 function readFileIfExists(filePath) {
-  if (!fs5.existsSync(filePath)) {
+  if (!fs6.existsSync(filePath)) {
     return null;
   }
-  return fs5.readFileSync(filePath, "utf8");
+  return fs6.readFileSync(filePath, "utf8");
 }
 function getAutomationManifestPath(projectDir = process.cwd()) {
-  return path5.join(normalizeProjectDir(projectDir), AUTOMATION_MANIFEST_RELATIVE_PATH);
+  return path6.join(normalizeProjectDir(projectDir), AUTOMATION_MANIFEST_RELATIVE_PATH);
 }
 function loadAutomationManifest(projectDir = process.cwd()) {
   const manifestPath2 = getAutomationManifestPath(projectDir);
-  if (!fs5.existsSync(manifestPath2)) {
+  if (!fs6.existsSync(manifestPath2)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs5.readFileSync(manifestPath2, "utf8"));
+    const parsed = JSON.parse(fs6.readFileSync(manifestPath2, "utf8"));
     if (!Array.isArray(parsed.files)) {
       return null;
     }
@@ -2259,8 +2351,8 @@ function loadAutomationManifest(projectDir = process.cwd()) {
 }
 function writeAutomationManifest(projectDir, manifest) {
   const manifestPath2 = getAutomationManifestPath(projectDir);
-  fs5.mkdirSync(path5.dirname(manifestPath2), { recursive: true });
-  fs5.writeFileSync(manifestPath2, `${JSON.stringify(manifest, null, 2)}
+  fs6.mkdirSync(path6.dirname(manifestPath2), { recursive: true });
+  fs6.writeFileSync(manifestPath2, `${JSON.stringify(manifest, null, 2)}
 `, "utf8");
 }
 function findManifestFile(manifest, filePath) {
@@ -2373,10 +2465,10 @@ function manifestFromBundle(args) {
 function writeBundleFile(projectDir, file, content = file.content) {
   const relativePath2 = normalizeRelativePath(file.path);
   const targetPath = resolveTargetPath(projectDir, relativePath2);
-  fs5.mkdirSync(path5.dirname(targetPath), { recursive: true });
-  fs5.writeFileSync(targetPath, content, "utf8");
+  fs6.mkdirSync(path6.dirname(targetPath), { recursive: true });
+  fs6.writeFileSync(targetPath, content, "utf8");
   if (shouldMakeExecutable(relativePath2)) {
-    fs5.chmodSync(targetPath, 493);
+    fs6.chmodSync(targetPath, 493);
   }
 }
 async function fetchAutomationBundle(args) {
@@ -2578,13 +2670,13 @@ var import_typescript = __toESM(require("typescript"));
 
 // src/commands/context-pack.ts
 var crypto2 = __toESM(require("crypto"));
-var fs6 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 var DEFAULT_MAX_BYTES = 2 * 1024 * 1024;
-var BASE_RELATIVE_PATH = path6.join(".snipara", "context-pack");
-var BLOBS_RELATIVE_PATH = path6.join(BASE_RELATIVE_PATH, "blobs");
-var MANIFESTS_RELATIVE_PATH = path6.join(BASE_RELATIVE_PATH, "items");
-var LATEST_RELATIVE_PATH = path6.join(BASE_RELATIVE_PATH, "latest.json");
+var BASE_RELATIVE_PATH = path7.join(".snipara", "context-pack");
+var BLOBS_RELATIVE_PATH = path7.join(BASE_RELATIVE_PATH, "blobs");
+var MANIFESTS_RELATIVE_PATH = path7.join(BASE_RELATIVE_PATH, "items");
+var LATEST_RELATIVE_PATH = path7.join(BASE_RELATIVE_PATH, "latest.json");
 var STORAGE_GITIGNORE_CONTENT = "*\n!.gitignore\n";
 var SECRET_REDACTION_PATTERNS = [
   [
@@ -2600,14 +2692,14 @@ var SECRET_REDACTION_PATTERNS = [
   ]
 ];
 function resolveRepoRoot(cwd) {
-  return findWorkspaceRoot(path6.resolve(cwd), true) ?? path6.resolve(cwd);
+  return findWorkspaceRoot(path7.resolve(cwd), true) ?? path7.resolve(cwd);
 }
 function normalizeRelativePath2(value) {
-  return value.split(path6.sep).join("/");
+  return value.split(path7.sep).join("/");
 }
 function toRepoRelative(repoRoot, absolutePath) {
-  const relative15 = path6.relative(repoRoot, absolutePath);
-  return normalizeRelativePath2(relative15 || path6.basename(absolutePath));
+  const relative15 = path7.relative(repoRoot, absolutePath);
+  return normalizeRelativePath2(relative15 || path7.basename(absolutePath));
 }
 function sha2562(content) {
   return crypto2.createHash("sha256").update(content, "utf8").digest("hex");
@@ -2641,18 +2733,18 @@ function optionalPositiveInteger(value) {
   return Number.isFinite(value) && value !== void 0 && value > 0 ? Math.floor(value) : void 0;
 }
 function ensureDir(dir, mode = 448) {
-  fs6.mkdirSync(dir, { recursive: true, mode });
+  fs7.mkdirSync(dir, { recursive: true, mode });
 }
 function maybeReadJsonFile(filePath) {
   try {
-    return JSON.parse(fs6.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs7.readFileSync(filePath, "utf8"));
   } catch {
     return null;
   }
 }
 function writeJsonFile(filePath, value) {
-  ensureDir(path6.dirname(filePath));
-  fs6.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+  ensureDir(path7.dirname(filePath));
+  fs7.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
 `, {
     encoding: "utf8",
     mode: 384
@@ -2660,9 +2752,9 @@ function writeJsonFile(filePath, value) {
 }
 function ensureStorageGitignore(paths) {
   ensureDir(paths.baseDir);
-  const gitignorePath = path6.join(paths.baseDir, ".gitignore");
-  if (!fs6.existsSync(gitignorePath)) {
-    fs6.writeFileSync(gitignorePath, STORAGE_GITIGNORE_CONTENT, {
+  const gitignorePath = path7.join(paths.baseDir, ".gitignore");
+  if (!fs7.existsSync(gitignorePath)) {
+    fs7.writeFileSync(gitignorePath, STORAGE_GITIGNORE_CONTENT, {
       encoding: "utf8",
       mode: 384
     });
@@ -2725,19 +2817,19 @@ function readManifest(paths, manifestPath2) {
   };
 }
 function listManifestPaths(paths) {
-  if (!fs6.existsSync(paths.manifestsDir)) {
+  if (!fs7.existsSync(paths.manifestsDir)) {
     return [];
   }
-  return fs6.readdirSync(paths.manifestsDir).filter((name) => name.endsWith(".json")).sort().map((name) => path6.join(paths.manifestsDir, name));
+  return fs7.readdirSync(paths.manifestsDir).filter((name) => name.endsWith(".json")).sort().map((name) => path7.join(paths.manifestsDir, name));
 }
 function loadRecords(paths) {
   return listManifestPaths(paths).map((manifestPath2) => readManifest(paths, manifestPath2)).filter((record2) => record2 !== null);
 }
 function recordManifestPath(paths, id) {
-  return path6.join(paths.manifestsDir, `${id}.json`);
+  return path7.join(paths.manifestsDir, `${id}.json`);
 }
 function recordBlobPath(paths, sha) {
-  return path6.join(paths.blobsDir, `${sha}.txt`);
+  return path7.join(paths.blobsDir, `${sha}.txt`);
 }
 function writeLatestPointer(paths, record2) {
   writeJsonFile(paths.latestPath, {
@@ -2750,8 +2842,8 @@ function writeLatestPointer(paths, record2) {
 function refreshLatestPointer(paths) {
   const records = loadRecords(paths).sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
   if (records.length === 0) {
-    if (fs6.existsSync(paths.latestPath)) {
-      fs6.rmSync(paths.latestPath);
+    if (fs7.existsSync(paths.latestPath)) {
+      fs7.rmSync(paths.latestPath);
     }
     return;
   }
@@ -2759,13 +2851,13 @@ function refreshLatestPointer(paths) {
 }
 function getContextPackStoragePaths(cwd = process.cwd()) {
   const repoRoot = resolveRepoRoot(cwd);
-  const baseDir = path6.join(repoRoot, BASE_RELATIVE_PATH);
+  const baseDir = path7.join(repoRoot, BASE_RELATIVE_PATH);
   return {
     repoRoot,
     baseDir,
-    blobsDir: path6.join(repoRoot, BLOBS_RELATIVE_PATH),
-    manifestsDir: path6.join(repoRoot, MANIFESTS_RELATIVE_PATH),
-    latestPath: path6.join(repoRoot, LATEST_RELATIVE_PATH)
+    blobsDir: path7.join(repoRoot, BLOBS_RELATIVE_PATH),
+    manifestsDir: path7.join(repoRoot, MANIFESTS_RELATIVE_PATH),
+    latestPath: path7.join(repoRoot, LATEST_RELATIVE_PATH)
   };
 }
 function packContext(options) {
@@ -2823,15 +2915,15 @@ function packContext(options) {
     warnings,
     storage: {
       baseRelativePath: normalizeRelativePath2(BASE_RELATIVE_PATH),
-      manifestRelativePath: normalizeRelativePath2(path6.relative(paths.repoRoot, manifestPath2)),
-      blobRelativePath: normalizeRelativePath2(path6.relative(paths.repoRoot, blobPath))
+      manifestRelativePath: normalizeRelativePath2(path7.relative(paths.repoRoot, manifestPath2)),
+      blobRelativePath: normalizeRelativePath2(path7.relative(paths.repoRoot, blobPath))
     }
   };
   ensureStorageGitignore(paths);
   ensureDir(paths.blobsDir);
   ensureDir(paths.manifestsDir);
-  if (!fs6.existsSync(blobPath)) {
-    fs6.writeFileSync(blobPath, content, { encoding: "utf8", mode: 384 });
+  if (!fs7.existsSync(blobPath)) {
+    fs7.writeFileSync(blobPath, content, { encoding: "utf8", mode: 384 });
   }
   writeJsonFile(manifestPath2, record2);
   writeLatestPointer(paths, record2);
@@ -2854,7 +2946,7 @@ function resolveContextPackRecord(idOrRef, cwd = process.cwd()) {
     if (!pointer) {
       throw new Error("No latest context pack is available.");
     }
-    const manifestPath2 = path6.join(paths.repoRoot, pointer.manifestRelativePath);
+    const manifestPath2 = path7.join(paths.repoRoot, pointer.manifestRelativePath);
     const record3 = readManifest(paths, manifestPath2);
     if (!record3) {
       throw new Error(`Latest context pack manifest is missing or invalid: ${pointer.id}`);
@@ -2881,13 +2973,13 @@ function resolveContextPackRecord(idOrRef, cwd = process.cwd()) {
 }
 function retrieveContextPack(idOrRef, cwd = process.cwd()) {
   const { paths, record: record2, manifestPath: manifestPath2 } = resolveContextPackRecord(idOrRef, cwd);
-  const blobPath = path6.join(paths.repoRoot, record2.storage.blobRelativePath);
-  if (!fs6.existsSync(blobPath)) {
+  const blobPath = path7.join(paths.repoRoot, record2.storage.blobRelativePath);
+  if (!fs7.existsSync(blobPath)) {
     throw new Error(`Context pack blob is missing for ${record2.id}`);
   }
   return {
     record: record2,
-    content: fs6.readFileSync(blobPath, "utf8"),
+    content: fs7.readFileSync(blobPath, "utf8"),
     baseDir: paths.baseDir,
     manifestPath: manifestPath2,
     blobPath
@@ -2935,8 +3027,8 @@ function cleanContextPacks(options = {}) {
   });
   if (!options.dryRun) {
     for (const record2 of selected) {
-      fs6.rmSync(recordManifestPath(paths, record2.id), { force: true });
-      fs6.rmSync(path6.join(paths.repoRoot, record2.storage.blobRelativePath), { force: true });
+      fs7.rmSync(recordManifestPath(paths, record2.id), { force: true });
+      fs7.rmSync(path7.join(paths.repoRoot, record2.storage.blobRelativePath), { force: true });
     }
     refreshLatestPointer(paths);
   }
@@ -2951,8 +3043,8 @@ function cleanContextPacks(options = {}) {
 }
 function readPackContent(options) {
   if (options.file) {
-    const filePath = path6.resolve(options.cwd ?? process.cwd(), options.file);
-    const content = fs6.readFileSync(filePath, "utf8");
+    const filePath = path7.resolve(options.cwd ?? process.cwd(), options.file);
+    const content = fs7.readFileSync(filePath, "utf8");
     const paths = getContextPackStoragePaths(options.cwd ?? process.cwd());
     return {
       content,
@@ -3016,9 +3108,9 @@ async function contextPackPackCommand(options) {
 async function contextPackRetrieveCommand(idOrRef, options = {}) {
   const result = retrieveContextPack(idOrRef, options.cwd);
   if (options.output) {
-    const outputPath = path6.resolve(options.cwd ?? process.cwd(), options.output);
-    ensureDir(path6.dirname(outputPath));
-    fs6.writeFileSync(outputPath, result.content, { encoding: "utf8", mode: 384 });
+    const outputPath = path7.resolve(options.cwd ?? process.cwd(), options.output);
+    ensureDir(path7.dirname(outputPath));
+    fs7.writeFileSync(outputPath, result.content, { encoding: "utf8", mode: 384 });
     if (options.json) {
       const payload = options.metadataOnly ? {
         record: result.record,
@@ -7252,7 +7344,7 @@ async function startLocalCodeHttpServer(options) {
   const server = import_http.default.createServer((req, res) => {
     void handleLocalCodeHttpRequest(req, res, options);
   });
-  await new Promise((resolve25, reject) => {
+  await new Promise((resolve26, reject) => {
     server.once("error", reject);
     server.listen(port, host, () => {
       server.off("error", reject);
@@ -7270,12 +7362,12 @@ async function startLocalCodeHttpServer(options) {
       } else {
         console.log(`Snipara local code overlay HTTP server listening on ${ready.baseUrl}`);
       }
-      resolve25();
+      resolve26();
     });
   });
-  await new Promise((resolve25) => {
+  await new Promise((resolve26) => {
     const shutdown = () => {
-      server.close(() => resolve25());
+      server.close(() => resolve26());
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
@@ -7375,8 +7467,8 @@ async function startLocalCodeMcpStdioServer(options) {
       }
     }
   });
-  await new Promise((resolve25) => {
-    process.stdin.once("end", resolve25);
+  await new Promise((resolve26) => {
+    process.stdin.once("end", resolve26);
     process.once("SIGINT", () => process.exit(0));
     process.once("SIGTERM", () => process.exit(0));
   });
@@ -7394,8 +7486,8 @@ async function codeMcpCommand(options) {
 }
 
 // src/commands/project-auth.ts
-var fs9 = __toESM(require("fs"));
-var path9 = __toESM(require("path"));
+var fs10 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 var os4 = __toESM(require("os"));
 var import_child_process3 = require("child_process");
 var PROJECT_DEVICE_CLIENT_ID = "snipara-companion";
@@ -7403,7 +7495,7 @@ var DEVICE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
 var DEVICE_POLL_TIMEOUT_MS = 15 * 60 * 1e3;
 var DEFAULT_DEVICE_POLL_INTERVAL_SECONDS = 5;
 function sleep(ms) {
-  return new Promise((resolve25) => setTimeout(resolve25, ms));
+  return new Promise((resolve26) => setTimeout(resolve26, ms));
 }
 function openBrowser(url) {
   try {
@@ -7418,14 +7510,14 @@ function openBrowser(url) {
   }
 }
 function getSniparaTokenStorePath2() {
-  return path9.join(os4.homedir(), ".snipara", "tokens.json");
+  return path10.join(os4.homedir(), ".snipara", "tokens.json");
 }
 function rememberProjectApiKey(projectId, projectSlug, apiKey) {
   const tokensPath = getSniparaTokenStorePath2();
   let tokens = {};
-  if (fs9.existsSync(tokensPath)) {
+  if (fs10.existsSync(tokensPath)) {
     try {
-      const parsed = JSON.parse(fs9.readFileSync(tokensPath, "utf8"));
+      const parsed = JSON.parse(fs10.readFileSync(tokensPath, "utf8"));
       if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
         tokens = parsed;
       }
@@ -7439,15 +7531,15 @@ function rememberProjectApiKey(projectId, projectSlug, apiKey) {
     project_slug: projectSlug,
     api_key: apiKey
   };
-  fs9.mkdirSync(path9.dirname(tokensPath), { recursive: true });
-  fs9.writeFileSync(tokensPath, `${JSON.stringify(tokens, null, 2)}
+  fs10.mkdirSync(path10.dirname(tokensPath), { recursive: true });
+  fs10.writeFileSync(tokensPath, `${JSON.stringify(tokens, null, 2)}
 `, "utf8");
 }
 function writeProjectBinding(projectDir, projectSlug) {
-  const bindingDir = path9.join(projectDir, ".snipara");
-  const bindingPath = path9.join(bindingDir, "project");
-  fs9.mkdirSync(bindingDir, { recursive: true });
-  fs9.writeFileSync(bindingPath, `${projectSlug}
+  const bindingDir = path10.join(projectDir, ".snipara");
+  const bindingPath = path10.join(bindingDir, "project");
+  fs10.mkdirSync(bindingDir, { recursive: true });
+  fs10.writeFileSync(bindingPath, `${projectSlug}
 `, "utf8");
 }
 function normalizeLocalProjectValue(value) {
@@ -7481,23 +7573,23 @@ function addLocalIdentifier(identifiers, seen, source2, value) {
 }
 function readWorkspaceCompanionProject(projectDir) {
   const configPath = getConfigPath({ cwd: projectDir, scope: "workspace" });
-  if (!fs9.existsSync(configPath)) {
+  if (!fs10.existsSync(configPath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs9.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs10.readFileSync(configPath, "utf8"));
     return normalizeLocalProjectValue(parsed.projectId ?? parsed.project_id ?? parsed.project);
   } catch {
     return null;
   }
 }
 function readProjectBinding(projectDir) {
-  const bindingPath = path9.join(projectDir, ".snipara", "project");
-  if (!fs9.existsSync(bindingPath)) {
+  const bindingPath = path10.join(projectDir, ".snipara", "project");
+  if (!fs10.existsSync(bindingPath)) {
     return null;
   }
   try {
-    const content = fs9.readFileSync(bindingPath, "utf8").trim();
+    const content = fs10.readFileSync(bindingPath, "utf8").trim();
     if (!content) {
       return null;
     }
@@ -7535,12 +7627,12 @@ function extractProjectSlugFromMcpUrl(value) {
   return match?.[1] ? normalizeLocalProjectValue(decodeURIComponent(match[1])) : null;
 }
 function readProjectFromMcpJson(projectDir) {
-  const configPath = path9.join(projectDir, ".mcp.json");
-  if (!fs9.existsSync(configPath)) {
+  const configPath = path10.join(projectDir, ".mcp.json");
+  if (!fs10.existsSync(configPath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs9.readFileSync(configPath, "utf8"));
+    const parsed = JSON.parse(fs10.readFileSync(configPath, "utf8"));
     for (const [serverName, serverConfig] of Object.entries(parsed.mcpServers ?? {})) {
       const endpointSlug = extractProjectSlugFromMcpUrl(serverConfig?.url);
       if (endpointSlug) {
@@ -7778,15 +7870,15 @@ function getNativeHookBlockReason(client) {
   return reasons[client] ?? "This client is MCP-first; no native hook files are installed.";
 }
 function ensureCompanionConfigIsGitIgnored(projectDir) {
-  const gitignorePath = path10.join(projectDir, ".gitignore");
+  const gitignorePath = path11.join(projectDir, ".gitignore");
   const ignoreEntry = "/.snipara/companion/";
-  const current = fs10.existsSync(gitignorePath) ? fs10.readFileSync(gitignorePath, "utf8") : "";
+  const current = fs11.existsSync(gitignorePath) ? fs11.readFileSync(gitignorePath, "utf8") : "";
   const entries = current.split(/\r?\n/).map((entry) => entry.trim());
   if (entries.includes(ignoreEntry)) {
     return;
   }
   const separator = current.length === 0 || current.endsWith("\n") ? "" : "\n";
-  fs10.writeFileSync(gitignorePath, `${current}${separator}${ignoreEntry}
+  fs11.writeFileSync(gitignorePath, `${current}${separator}${ignoreEntry}
 `, "utf8");
 }
 function formatClientName(client) {
@@ -7945,14 +8037,14 @@ alwaysApply: true
 ${body}`;
 }
 function ensureWorkflowInstructionFile(projectDir, relativePath2, generatedContent) {
-  const filePath = path10.join(projectDir, relativePath2);
-  const currentContent = fs10.existsSync(filePath) ? fs10.readFileSync(filePath, "utf8") : void 0;
+  const filePath = path11.join(projectDir, relativePath2);
+  const currentContent = fs11.existsSync(filePath) ? fs11.readFileSync(filePath, "utf8") : void 0;
   const nextContent = relativePath2 === ".cursor/rules/snipara.mdc" ? mergeCursorRuleInstructionContent(relativePath2, generatedContent, currentContent) : mergeWorkflowInstructionContent(relativePath2, generatedContent, currentContent);
   if (currentContent === nextContent) {
     return { relativePath: relativePath2, action: "unchanged" };
   }
-  fs10.mkdirSync(path10.dirname(filePath), { recursive: true });
-  fs10.writeFileSync(filePath, nextContent);
+  fs11.mkdirSync(path11.dirname(filePath), { recursive: true });
+  fs11.writeFileSync(filePath, nextContent);
   return { relativePath: relativePath2, action: currentContent === void 0 ? "created" : "updated" };
 }
 function ensureWorkflowInstructions(projectDir, projectSlug, client) {
@@ -7975,10 +8067,10 @@ function prompt(question) {
     input: process.stdin,
     output: process.stdout
   });
-  return new Promise((resolve25) => {
+  return new Promise((resolve26) => {
     rl.question(question, (answer) => {
       rl.close();
-      resolve25(answer.trim());
+      resolve26(answer.trim());
     });
   });
 }
@@ -8528,38 +8620,38 @@ fi
 function installHooks(projectDir, projectId, _apiKey, client) {
   try {
     if (client === "cursor") {
-      const cursorDir = path10.join(projectDir, ".cursor");
-      const hooksDir2 = path10.join(cursorDir, "hooks");
-      const hooksPath = path10.join(cursorDir, "hooks.json");
-      if (!fs10.existsSync(cursorDir)) {
-        fs10.mkdirSync(cursorDir, { recursive: true });
-      }
-      if (!fs10.existsSync(hooksDir2)) {
-        fs10.mkdirSync(hooksDir2, { recursive: true });
-      }
-      const preCompactPath = path10.join(hooksDir2, "preCompact.sh");
-      fs10.writeFileSync(preCompactPath, generateCursorPreCompactScript(projectId));
-      fs10.chmodSync(preCompactPath, "755");
-      const sessionStartPath = path10.join(hooksDir2, "sessionStart.sh");
-      fs10.writeFileSync(sessionStartPath, generateCursorSessionStartScript(projectId));
-      fs10.chmodSync(sessionStartPath, "755");
-      const beforeReadPath = path10.join(hooksDir2, "beforeReadFile.sh");
-      fs10.writeFileSync(beforeReadPath, generateCursorBeforeReadScript());
-      fs10.chmodSync(beforeReadPath, "755");
-      const afterEditPath = path10.join(hooksDir2, "afterFileEdit.sh");
-      fs10.writeFileSync(afterEditPath, generateCursorAfterFileEditScript());
-      fs10.chmodSync(afterEditPath, "755");
-      fs10.writeFileSync(hooksPath, JSON.stringify(generateCursorHookConfig(), null, 2));
+      const cursorDir = path11.join(projectDir, ".cursor");
+      const hooksDir2 = path11.join(cursorDir, "hooks");
+      const hooksPath = path11.join(cursorDir, "hooks.json");
+      if (!fs11.existsSync(cursorDir)) {
+        fs11.mkdirSync(cursorDir, { recursive: true });
+      }
+      if (!fs11.existsSync(hooksDir2)) {
+        fs11.mkdirSync(hooksDir2, { recursive: true });
+      }
+      const preCompactPath = path11.join(hooksDir2, "preCompact.sh");
+      fs11.writeFileSync(preCompactPath, generateCursorPreCompactScript(projectId));
+      fs11.chmodSync(preCompactPath, "755");
+      const sessionStartPath = path11.join(hooksDir2, "sessionStart.sh");
+      fs11.writeFileSync(sessionStartPath, generateCursorSessionStartScript(projectId));
+      fs11.chmodSync(sessionStartPath, "755");
+      const beforeReadPath = path11.join(hooksDir2, "beforeReadFile.sh");
+      fs11.writeFileSync(beforeReadPath, generateCursorBeforeReadScript());
+      fs11.chmodSync(beforeReadPath, "755");
+      const afterEditPath = path11.join(hooksDir2, "afterFileEdit.sh");
+      fs11.writeFileSync(afterEditPath, generateCursorAfterFileEditScript());
+      fs11.chmodSync(afterEditPath, "755");
+      fs11.writeFileSync(hooksPath, JSON.stringify(generateCursorHookConfig(), null, 2));
       return { success: true };
     }
-    const claudeDir = path10.join(projectDir, ".claude");
-    const hooksDir = path10.join(claudeDir, "hooks");
-    const settingsPath = path10.join(claudeDir, "settings.json");
-    if (!fs10.existsSync(claudeDir)) {
-      fs10.mkdirSync(claudeDir, { recursive: true });
+    const claudeDir = path11.join(projectDir, ".claude");
+    const hooksDir = path11.join(claudeDir, "hooks");
+    const settingsPath = path11.join(claudeDir, "settings.json");
+    if (!fs11.existsSync(claudeDir)) {
+      fs11.mkdirSync(claudeDir, { recursive: true });
     }
-    if (!fs10.existsSync(hooksDir)) {
-      fs10.mkdirSync(hooksDir, { recursive: true });
+    if (!fs11.existsSync(hooksDir)) {
+      fs11.mkdirSync(hooksDir, { recursive: true });
     }
     const hookScripts = [
       ["snipara-stuck-guard.sh", generateClaudeStuckGuardScript()],
@@ -8568,14 +8660,14 @@ function installHooks(projectDir, projectId, _apiKey, client) {
       ["snipara-compact.sh", generateClaudeCompactScript()]
     ];
     for (const [fileName, content] of hookScripts) {
-      const hookPath = path10.join(hooksDir, fileName);
-      fs10.writeFileSync(hookPath, content);
-      fs10.chmodSync(hookPath, "755");
+      const hookPath = path11.join(hooksDir, fileName);
+      fs11.writeFileSync(hookPath, content);
+      fs11.chmodSync(hookPath, "755");
     }
     let settings = {};
-    if (fs10.existsSync(settingsPath)) {
+    if (fs11.existsSync(settingsPath)) {
       try {
-        settings = JSON.parse(fs10.readFileSync(settingsPath, "utf-8"));
+        settings = JSON.parse(fs11.readFileSync(settingsPath, "utf-8"));
       } catch {
       }
     }
@@ -8584,7 +8676,7 @@ function installHooks(projectDir, projectId, _apiKey, client) {
       restoreOnSessionStart: true
     });
     settings = { ...settings, ...hookConfig };
-    fs10.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+    fs11.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
     return { success: true };
   } catch (error) {
     return {
@@ -8720,7 +8812,7 @@ async function initCommand(options) {
     existingProjectId: existingConfig.projectId,
     selectedProject
   });
-  const sessionId = `sess_${Date.now()}_${(0, import_node_crypto.randomBytes)(6).toString("hex")}`;
+  const sessionId = `sess_${Date.now()}_${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
   saveConfig(
     {
       apiKey,
@@ -8933,7 +9025,7 @@ function showConfig() {
 
 // src/commands/login.ts
 var import_child_process4 = require("child_process");
-var import_node_crypto2 = require("crypto");
+var import_node_crypto3 = require("crypto");
 var USER_KEY_CLIENT_ID = "snipara-cli";
 var CLIENT_VERSION = "1.1.20";
 var GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
@@ -8994,7 +9086,7 @@ async function pollForToken(apiUrl, deviceCode, intervalSeconds) {
   throw new Error("Login timed out (15 min). Run `snipara-companion login --user-key` again.");
 }
 function createSessionId() {
-  return `sess_${Date.now()}_${(0, import_node_crypto2.randomBytes)(6).toString("hex")}`;
+  return `sess_${Date.now()}_${(0, import_node_crypto3.randomBytes)(6).toString("hex")}`;
 }
 async function loginCommand(options = {}) {
   const projectDir = options.dir || process.cwd();
@@ -9075,9 +9167,9 @@ async function userKeyLoginCommand(apiUrl) {
 
 // src/cache/query-cache.ts
 var crypto5 = __toESM(require("crypto"));
-var fs11 = __toESM(require("fs"));
+var fs12 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
-var path11 = __toESM(require("path"));
+var path12 = __toESM(require("path"));
 var CACHE_VERSION = 2;
 var WARM_SNAPSHOT_VERSION = 1;
 var SEARCH_MODE = "hybrid";
@@ -9169,7 +9261,7 @@ var LocalQueryCache = class {
     }
     const key = buildCacheKey(this.scope.workspaceKey, normalizedQuery, options.maxTokens);
     const fileName = `${key}.json`;
-    const filePath = path11.join(getCacheDir(), fileName);
+    const filePath = path12.join(getCacheDir(), fileName);
     const now = Date.now();
     const payload = {
       version: CACHE_VERSION,
@@ -9179,7 +9271,7 @@ var LocalQueryCache = class {
     const content = JSON.stringify(payload);
     ensureCacheDir();
     try {
-      fs11.writeFileSync(filePath, content, "utf8");
+      fs12.writeFileSync(filePath, content, "utf8");
     } catch {
       return;
     }
@@ -9209,7 +9301,7 @@ var LocalQueryCache = class {
     const entries = extractWarmSnapshotEntries(result);
     const index = this.loadIndex();
     const fileName = `warm-${this.scope.workspaceKey}.json`;
-    const filePath = path11.join(getCacheDir(), fileName);
+    const filePath = path12.join(getCacheDir(), fileName);
     index.warmSnapshots = index.warmSnapshots.filter(
       (snapshot2) => snapshot2.workspaceKey !== this.scope.workspaceKey
     );
@@ -9232,7 +9324,7 @@ var LocalQueryCache = class {
     const content = JSON.stringify(snapshot);
     ensureCacheDir();
     try {
-      fs11.writeFileSync(filePath, content, "utf8");
+      fs12.writeFileSync(filePath, content, "utf8");
     } catch {
       return { storedEntries: 0 };
     }
@@ -9252,21 +9344,21 @@ var LocalQueryCache = class {
   }
   clear() {
     const cacheDir = getCacheDir();
-    if (!fs11.existsSync(cacheDir)) {
+    if (!fs12.existsSync(cacheDir)) {
       return 0;
     }
-    const files = fs11.readdirSync(cacheDir).filter((file) => file.endsWith(".json"));
-    fs11.rmSync(cacheDir, { recursive: true, force: true });
+    const files = fs12.readdirSync(cacheDir).filter((file) => file.endsWith(".json"));
+    fs12.rmSync(cacheDir, { recursive: true, force: true });
     return files.length;
   }
   loadIndex() {
     ensureCacheDir();
     const indexFile = getIndexFile();
-    if (!fs11.existsSync(indexFile)) {
+    if (!fs12.existsSync(indexFile)) {
       return emptyIndex();
     }
     try {
-      const content = fs11.readFileSync(indexFile, "utf8");
+      const content = fs12.readFileSync(indexFile, "utf8");
       const parsed = JSON.parse(content);
       const index = {
         version: parsed.version === CACHE_VERSION ? CACHE_VERSION : CACHE_VERSION,
@@ -9282,7 +9374,7 @@ var LocalQueryCache = class {
     const pruned = this.pruneIndex(index);
     ensureCacheDir();
     try {
-      fs11.writeFileSync(getIndexFile(), JSON.stringify(pruned, null, 2), "utf8");
+      fs12.writeFileSync(getIndexFile(), JSON.stringify(pruned, null, 2), "utf8");
     } catch {
     }
   }
@@ -9291,20 +9383,20 @@ var LocalQueryCache = class {
     const cacheDir = getCacheDir();
     index.entries = index.entries.filter((entry) => {
       if (entry.expiresAt <= now) {
-        tryDeleteFile(path11.join(cacheDir, entry.fileName));
+        tryDeleteFile(path12.join(cacheDir, entry.fileName));
         return false;
       }
-      if (!fs11.existsSync(path11.join(cacheDir, entry.fileName))) {
+      if (!fs12.existsSync(path12.join(cacheDir, entry.fileName))) {
         return false;
       }
       return true;
     });
     index.warmSnapshots = index.warmSnapshots.filter((snapshot) => {
       if (snapshot.expiresAt <= now) {
-        tryDeleteFile(path11.join(cacheDir, snapshot.fileName));
+        tryDeleteFile(path12.join(cacheDir, snapshot.fileName));
         return false;
       }
-      if (!fs11.existsSync(path11.join(cacheDir, snapshot.fileName))) {
+      if (!fs12.existsSync(path12.join(cacheDir, snapshot.fileName))) {
         return false;
       }
       return true;
@@ -9317,19 +9409,19 @@ var LocalQueryCache = class {
         break;
       }
       totalBytes -= removed.sizeBytes;
-      tryDeleteFile(path11.join(cacheDir, removed.fileName));
+      tryDeleteFile(path12.join(cacheDir, removed.fileName));
     }
     return index;
   }
   readEntry(entry, index) {
-    const filePath = path11.join(getCacheDir(), entry.fileName);
-    if (!fs11.existsSync(filePath)) {
+    const filePath = path12.join(getCacheDir(), entry.fileName);
+    if (!fs12.existsSync(filePath)) {
       index.entries = index.entries.filter((candidate) => candidate.key !== entry.key);
       this.persistIndex(index);
       return null;
     }
     try {
-      const content = fs11.readFileSync(filePath, "utf8");
+      const content = fs12.readFileSync(filePath, "utf8");
       const parsed = JSON.parse(content);
       if (parsed.version !== CACHE_VERSION || !isContextQueryResult(parsed.result)) {
         throw new Error("invalid cache payload");
@@ -9373,8 +9465,8 @@ var LocalQueryCache = class {
     if (!snapshotMeta) {
       return null;
     }
-    const filePath = path11.join(getCacheDir(), snapshotMeta.fileName);
-    if (!fs11.existsSync(filePath)) {
+    const filePath = path12.join(getCacheDir(), snapshotMeta.fileName);
+    if (!fs12.existsSync(filePath)) {
       index.warmSnapshots = index.warmSnapshots.filter(
         (snapshot) => snapshot.workspaceKey !== this.scope.workspaceKey
       );
@@ -9382,7 +9474,7 @@ var LocalQueryCache = class {
       return null;
     }
     try {
-      const content = fs11.readFileSync(filePath, "utf8");
+      const content = fs12.readFileSync(filePath, "utf8");
       const snapshot = JSON.parse(content);
       if (snapshot.version !== WARM_SNAPSHOT_VERSION || snapshot.workspaceKey !== this.scope.workspaceKey || !Array.isArray(snapshot.entries)) {
         throw new Error("invalid warm snapshot");
@@ -9431,7 +9523,7 @@ function createLocalQueryCache(scope = {}) {
   return new LocalQueryCache(scope);
 }
 function resolveScope(scope) {
-  const cwd = path11.resolve(scope.cwd ?? process.cwd());
+  const cwd = path12.resolve(scope.cwd ?? process.cwd());
   const workspaceRoot2 = normalizeFilePath(findWorkspaceRoot(cwd, true) ?? cwd);
   const workspaceKey = hashString(
     JSON.stringify({ projectId: scope.projectId ?? "", workspaceRoot: workspaceRoot2 })
@@ -9575,13 +9667,13 @@ function emptyIndex() {
 }
 function ensureCacheDir() {
   const cacheDir = getCacheDir();
-  if (!fs11.existsSync(cacheDir)) {
-    fs11.mkdirSync(cacheDir, { recursive: true });
+  if (!fs12.existsSync(cacheDir)) {
+    fs12.mkdirSync(cacheDir, { recursive: true });
   }
 }
 function tryDeleteFile(filePath) {
   try {
-    fs11.unlinkSync(filePath);
+    fs12.unlinkSync(filePath);
   } catch {
   }
 }
@@ -9611,14 +9703,14 @@ function readPositiveFloat(name, fallback) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
 }
 function getCacheDir() {
-  return path11.join(os5.homedir(), ".snipara", "cache", "context-v2");
+  return path12.join(os5.homedir(), ".snipara", "cache", "context-v2");
 }
 function getIndexFile() {
-  return path11.join(getCacheDir(), "index.json");
+  return path12.join(getCacheDir(), "index.json");
 }
 
 // src/commands/stuck-guard.ts
-var fs12 = __toESM(require("fs"));
+var fs13 = __toESM(require("fs"));
 var SEARCH_TOOL_PATTERN = /\b(read|grep|glob|find|rg|ripgrep|search|ls)\b/i;
 var SECRET_PATTERNS2 = [
   [/\b(Bearer\s+)[A-Za-z0-9._~+/=-]{20,}\b/g, "$1[REDACTED]"],
@@ -9826,7 +9918,7 @@ async function stuckGuardCheckCommand(toolInput, options) {
 }
 async function stuckGuardSimulateCommand(options) {
   ensureConfiguredForCommand();
-  const fixture = JSON.parse(fs12.readFileSync(options.fixture, "utf8"));
+  const fixture = JSON.parse(fs13.readFileSync(options.fixture, "utf8"));
   const payload = normalizeFixture(fixture);
   const client = createClient(1e4);
   const result = await client.evaluateStuckGuard(payload);
@@ -10187,8 +10279,8 @@ function clearCache() {
 var import_node_child_process5 = require("child_process");
 
 // src/commands/memory-guard.ts
-var fs13 = __toESM(require("fs"));
-var path12 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
 var import_node_child_process3 = require("child_process");
 var import_chalk2 = __toESM(require("chalk"));
 var MEMORY_GUARD_EXIT_CODES = {
@@ -10305,12 +10397,12 @@ function buildValidationResult(errors) {
   };
 }
 function safeRelative(root, filePath) {
-  const absolute = path12.isAbsolute(filePath) ? filePath : path12.join(root, filePath);
-  return path12.relative(root, absolute).replaceAll(path12.sep, "/");
+  const absolute = path13.isAbsolute(filePath) ? filePath : path13.join(root, filePath);
+  return path13.relative(root, absolute).replaceAll(path13.sep, "/");
 }
 function readJsonFile(filePath) {
   try {
-    const parsed = JSON.parse(fs13.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs14.readFileSync(filePath, "utf8"));
     return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -10327,17 +10419,17 @@ function parsePyprojectProject(content) {
   return { name, version };
 }
 function findManifestForFile(root, filePath, manifest) {
-  let current = path12.dirname(path12.join(root, filePath));
-  const resolvedRoot = path12.resolve(root);
+  let current = path13.dirname(path13.join(root, filePath));
+  const resolvedRoot = path13.resolve(root);
   while (current.startsWith(resolvedRoot)) {
-    const candidate = path12.join(current, manifest);
-    if (fs13.existsSync(candidate)) {
+    const candidate = path13.join(current, manifest);
+    if (fs14.existsSync(candidate)) {
       return candidate;
     }
     if (current === resolvedRoot) {
       break;
     }
-    current = path12.dirname(current);
+    current = path13.dirname(current);
   }
   return null;
 }
@@ -10346,7 +10438,7 @@ function detectReleaseSurfacesFromFiles(root, files) {
   const seen = /* @__PURE__ */ new Set();
   for (const rawFile of files) {
     const file = safeRelative(root, rawFile);
-    const packageManifest = file.endsWith("package.json") && fs13.existsSync(path12.join(root, file)) ? path12.join(root, file) : findManifestForFile(root, file, "package.json");
+    const packageManifest = file.endsWith("package.json") && fs14.existsSync(path13.join(root, file)) ? path13.join(root, file) : findManifestForFile(root, file, "package.json");
     if (packageManifest && !seen.has(packageManifest)) {
       seen.add(packageManifest);
       const packageJson = readJsonFile(packageManifest);
@@ -10361,10 +10453,10 @@ function detectReleaseSurfacesFromFiles(root, files) {
         });
       }
     }
-    const pyprojectManifest = file.endsWith("pyproject.toml") && fs13.existsSync(path12.join(root, file)) ? path12.join(root, file) : findManifestForFile(root, file, "pyproject.toml");
+    const pyprojectManifest = file.endsWith("pyproject.toml") && fs14.existsSync(path13.join(root, file)) ? path13.join(root, file) : findManifestForFile(root, file, "pyproject.toml");
     if (pyprojectManifest && !seen.has(pyprojectManifest)) {
       seen.add(pyprojectManifest);
-      const project = parsePyprojectProject(fs13.readFileSync(pyprojectManifest, "utf8"));
+      const project = parsePyprojectProject(fs14.readFileSync(pyprojectManifest, "utf8"));
       if (project.name) {
         surfaces.push({
           ecosystem: "pypi",
@@ -10851,9 +10943,9 @@ async function rememberGuardMemoryCommand(options) {
 }
 
 // src/commands/activity.ts
-var fs14 = __toESM(require("fs"));
-var path13 = __toESM(require("path"));
-var import_node_crypto7 = require("crypto");
+var fs15 = __toESM(require("fs"));
+var path14 = __toESM(require("path"));
+var import_node_crypto8 = require("crypto");
 
 // ../project-intelligence-contracts/src/engineering-lead.ts
 var PROJECT_HEALTH_COCKPIT_STATUSES = ["healthy", "watch", "risk", "unknown"];
@@ -11481,7 +11573,7 @@ function buildProjectIntentLedger(input, changedFilesOverride) {
 }
 
 // ../project-intelligence-contracts/src/worker-profile.ts
-var import_node_crypto3 = require("crypto");
+var import_node_crypto4 = require("crypto");
 var WORKER_PROFILE_SCHEMA_VERSION = "snipara.worker_profile.v0";
 var WORKER_PROFILE_RISK_CEILINGS = ["low", "medium", "high", "critical"];
 var WORKER_PROFILE_PRIVACY_CLASSES = ["local", "cloud"];
@@ -11575,7 +11667,7 @@ function stableWorkerProfileJsonStringify(value) {
   return JSON.stringify(sortJsonValue(value), null, 2);
 }
 function hashWorkerProfileContent(content) {
-  return (0, import_node_crypto3.createHash)("sha256").update(content).digest("hex");
+  return (0, import_node_crypto4.createHash)("sha256").update(content).digest("hex");
 }
 function normalizeWorkerProfileTransport(value) {
   if (!isRecord2(value)) {
@@ -12329,10 +12421,10 @@ function renderProjectRealityCheckMarkdown(result) {
 }
 
 // ../project-intelligence-contracts/src/producer-loop.ts
-var import_node_crypto4 = require("crypto");
+var import_node_crypto5 = require("crypto");
 
 // ../project-intelligence-contracts/src/decision-request.ts
-var import_node_crypto5 = require("crypto");
+var import_node_crypto6 = require("crypto");
 var DECISION_REQUEST_VERSION = "snipara.decision_request.v0";
 var DECISION_RESPONSE_VERSION = "snipara.decision_response.v0";
 var DECISION_REQUEST_RELATIVE_DIR = ".snipara/decisions";
@@ -12340,7 +12432,7 @@ function stableDecisionJsonStringify(value) {
   return JSON.stringify(sortJsonValue2(value), null, 2);
 }
 function hashDecisionContent(content) {
-  return (0, import_node_crypto5.createHash)("sha256").update(content).digest("hex");
+  return (0, import_node_crypto6.createHash)("sha256").update(content).digest("hex");
 }
 function hashDecisionJsonValue(value) {
   return `sha256:${hashDecisionContent(stableDecisionJsonStringify(value))}`;
@@ -14177,7 +14269,7 @@ var WHY_CAPTURE_CONFIDENCE_VERSION = why_capture_confidence_v1_default.version;
 var WHY_CAPTURE_CONFIDENCE_TEST_VECTORS = why_capture_confidence_v1_default.vectors;
 
 // ../project-intelligence-contracts/src/judgment-integrity.ts
-var import_node_crypto6 = require("crypto");
+var import_node_crypto7 = require("crypto");
 
 // ../project-intelligence-contracts/src/agent-context.ts
 var AGENT_CONTEXT_MANIFEST_VERSION = "snipara.agent_context_manifest.v0";
@@ -15414,9 +15506,9 @@ function isAgentContextEvidenceReceipt(value) {
 // src/commands/activity.ts
 var ACTIVITY_TIMELINE_VERSION = "snipara.activity_timeline.v0";
 var SESSION_SNAPSHOT_VERSION = "snipara.session_snapshot.v0";
-var ACTIVITY_RELATIVE_DIR = path13.join(".snipara", "activity");
-var ACTIVITY_TIMELINE_RELATIVE_PATH = path13.join(ACTIVITY_RELATIVE_DIR, "timeline.jsonl");
-var SESSION_SNAPSHOT_RELATIVE_PATH = path13.join(ACTIVITY_RELATIVE_DIR, "session.json");
+var ACTIVITY_RELATIVE_DIR = path14.join(".snipara", "activity");
+var ACTIVITY_TIMELINE_RELATIVE_PATH = path14.join(ACTIVITY_RELATIVE_DIR, "timeline.jsonl");
+var SESSION_SNAPSHOT_RELATIVE_PATH = path14.join(ACTIVITY_RELATIVE_DIR, "session.json");
 function uniqueStrings15(values) {
   return Array.from(new Set(values.map((value) => value?.trim()).filter(Boolean)));
 }
@@ -15435,11 +15527,11 @@ function sortJsonValue3(value) {
   return value;
 }
 function hashEvent(input) {
-  return (0, import_node_crypto7.createHash)("sha256").update(stableJson(input)).digest("hex").slice(0, 16);
+  return (0, import_node_crypto8.createHash)("sha256").update(stableJson(input)).digest("hex").slice(0, 16);
 }
 function safeReadJson(filePath) {
   try {
-    const parsed = JSON.parse(fs14.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs15.readFileSync(filePath, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -15447,7 +15539,7 @@ function safeReadJson(filePath) {
 }
 function readJsonDir(dir) {
   try {
-    return fs14.readdirSync(dir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => safeReadJson(path13.join(dir, fileName))).filter((record2) => Boolean(record2));
+    return fs15.readdirSync(dir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => safeReadJson(path14.join(dir, fileName))).filter((record2) => Boolean(record2));
   } catch {
     return [];
   }
@@ -15461,10 +15553,10 @@ function countBy(items, key) {
   return counts;
 }
 function getActivityTimelinePath(cwd = process.cwd()) {
-  return path13.join(cwd, ACTIVITY_TIMELINE_RELATIVE_PATH);
+  return path14.join(cwd, ACTIVITY_TIMELINE_RELATIVE_PATH);
 }
 function getSessionSnapshotPath(cwd = process.cwd()) {
-  return path13.join(cwd, SESSION_SNAPSHOT_RELATIVE_PATH);
+  return path14.join(cwd, SESSION_SNAPSHOT_RELATIVE_PATH);
 }
 function appendActivityEvent(input) {
   const cwd = input.cwd ?? process.cwd();
@@ -15495,8 +15587,8 @@ function appendActivityEvent(input) {
     metadata: input.metadata ?? {}
   };
   const timelinePath = getActivityTimelinePath(cwd);
-  fs14.mkdirSync(path13.dirname(timelinePath), { recursive: true });
-  fs14.appendFileSync(timelinePath, `${JSON.stringify(event)}
+  fs15.mkdirSync(path14.dirname(timelinePath), { recursive: true });
+  fs15.appendFileSync(timelinePath, `${JSON.stringify(event)}
 `, "utf8");
   return event;
 }
@@ -15505,7 +15597,7 @@ function readActivityTimeline(options = {}) {
   const limit = options.limit && options.limit > 0 ? options.limit : void 0;
   let lines;
   try {
-    lines = fs14.readFileSync(timelinePath, "utf8").split(/\r?\n/).filter(Boolean);
+    lines = fs15.readFileSync(timelinePath, "utf8").split(/\r?\n/).filter(Boolean);
   } catch {
     return [];
   }
@@ -15519,7 +15611,7 @@ function readActivityTimeline(options = {}) {
   return limit ? events.slice(0, limit) : events;
 }
 function workflowSnapshot(cwd) {
-  const state = safeReadJson(path13.join(cwd, ".snipara", "workflow", "current.json"));
+  const state = safeReadJson(path14.join(cwd, ".snipara", "workflow", "current.json"));
   if (!state) {
     return null;
   }
@@ -15541,7 +15633,7 @@ function countDecisionFingerprintRepeats(records) {
   return Object.values(counts).filter((count2) => count2 > 1).length;
 }
 function producerLoopSummary(cwd) {
-  const records = readJsonDir(path13.join(cwd, ".snipara", "producer-loop"));
+  const records = readJsonDir(path14.join(cwd, ".snipara", "producer-loop"));
   let reviewedCount = 0;
   let rejectedCount = 0;
   let unreviewedCount = 0;
@@ -15562,7 +15654,7 @@ function producerLoopSummary(cwd) {
   };
 }
 function teamSyncSnapshot(cwd) {
-  const state = safeReadJson(path13.join(cwd, ".snipara", "team-sync", "session.json"));
+  const state = safeReadJson(path14.join(cwd, ".snipara", "team-sync", "session.json"));
   const work = Array.isArray(state?.work) ? state?.work : [];
   const handoffs = Array.isArray(state?.handoffs) ? state?.handoffs : [];
   const latestHandoffAt = handoffs.map((handoff) => typeof handoff.createdAt === "string" ? handoff.createdAt : void 0).filter(Boolean).sort().at(-1);
@@ -15608,8 +15700,8 @@ function buildSessionSnapshot(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const events = readActivityTimeline({ cwd });
   const latestEvents = events.slice(0, options.limit && options.limit > 0 ? options.limit : 20);
-  const pendingDecisions = readJsonDir(path13.join(cwd, ".snipara", "decisions", "pending"));
-  const resolvedDecisions = readJsonDir(path13.join(cwd, ".snipara", "decisions", "resolved"));
+  const pendingDecisions = readJsonDir(path14.join(cwd, ".snipara", "decisions", "pending"));
+  const resolvedDecisions = readJsonDir(path14.join(cwd, ".snipara", "decisions", "resolved"));
   const workflow2 = workflowSnapshot(cwd);
   const producerLoop = producerLoopSummary(cwd);
   const teamSync2 = teamSyncSnapshot(cwd);
@@ -15672,8 +15764,8 @@ function writeSessionSnapshot(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const snapshot = buildSessionSnapshot({ cwd, limit: options.limit });
   const snapshotPath = getSessionSnapshotPath(cwd);
-  fs14.mkdirSync(path13.dirname(snapshotPath), { recursive: true });
-  fs14.writeFileSync(snapshotPath, `${JSON.stringify(snapshot, null, 2)}
+  fs15.mkdirSync(path14.dirname(snapshotPath), { recursive: true });
+  fs15.writeFileSync(snapshotPath, `${JSON.stringify(snapshot, null, 2)}
 `, "utf8");
   return snapshot;
 }
@@ -15687,8 +15779,8 @@ function readSessionSnapshot(cwd = process.cwd()) {
 
 // src/commands/why-capture.ts
 var import_node_child_process4 = require("child_process");
-var fs15 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs16 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 var MAX_SOURCE_TEXT_CHARS = 12e3;
 var MAX_TASK_CHARS = 700;
 var MAX_RECEIPT_TEXT_CHARS = 900;
@@ -15794,12 +15886,12 @@ function readCommitSha(cwd) {
   return readGitValue(cwd, ["rev-parse", "--verify", "HEAD^{commit}"]);
 }
 function hasActiveManagedWorkflow(cwd) {
-  const statePath = path14.join(cwd, ".snipara", "workflow", "current.json");
-  if (!fs15.existsSync(statePath)) {
+  const statePath = path15.join(cwd, ".snipara", "workflow", "current.json");
+  if (!fs16.existsSync(statePath)) {
     return false;
   }
   try {
-    const parsed = JSON.parse(fs15.readFileSync(statePath, "utf8"));
+    const parsed = JSON.parse(fs16.readFileSync(statePath, "utf8"));
     return parsed.status !== "completed";
   } catch {
     return true;
@@ -15830,7 +15922,7 @@ function readStandaloneCommitEvidence(cwd, commitSha, additionalFiles = []) {
 function readLatestWorkflowCommands(cwd) {
   try {
     const state = JSON.parse(
-      fs15.readFileSync(path14.join(cwd, ".snipara", "workflow", "current.json"), "utf8")
+      fs16.readFileSync(path15.join(cwd, ".snipara", "workflow", "current.json"), "utf8")
     );
     const bindings = state.runtime?.sandbox?.bindings ?? [];
     for (let index = bindings.length - 1; index >= 0; index -= 1) {
@@ -16295,38 +16387,100 @@ async function postToolCommand(options) {
 }
 
 // src/commands/session.ts
-async function sessionEndCommand() {
+var fs17 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
+var import_node_crypto9 = require("crypto");
+function printCloseout(report, file, json) {
+  if (json) {
+    console.log(JSON.stringify({ ...report, reportPath: file }, null, 2));
+    return;
+  }
+  const message = report.status === "saved" ? `Session saved to journal (${report.checkpoint.files.length} files; entry ${report.entryId})` : report.status === "skipped" ? "Session checkpoint skipped: no summary or files supplied" : "Session NOT saved; local checkpoint retained for retry";
+  console.log(`${message}
+Receipt: ${file}`);
+  if (report.status === "error" || report.status === "pending") {
+    console.error(`Retry: snipara-companion session-end --retry ${JSON.stringify(file)}`);
+  }
+  if (report.status === "saved" && report.eventDelivered === false) {
+    console.error("Journal saved; automation event delivery was not confirmed.");
+  }
+}
+async function sessionEndCommand(options = {}) {
   if (!isConfigured()) {
-    console.log("Not configured. Run 'npx -y snipara-companion@latest init' first.");
-    process.exit(0);
+    console.log(
+      options.json ? JSON.stringify({ status: "skipped", reason: "not_configured", reportPath: null }) : "Not configured. Run 'npx -y snipara-companion@latest init' first."
+    );
+    return;
   }
+  const cwd = path16.resolve(process.env.SNIPARA_WORKSPACE_DIR || process.cwd());
+  const config = loadConfig();
+  const previous = options.retry ? readSessionCloseout(path16.resolve(options.retry)) : void 0;
+  if (options.retry && (!previous || previous.workspace !== cwd || previous.projectId !== config.projectId)) {
+    throw new Error("Retry receipt does not belong to this workspace and project");
+  }
+  const checkpoint = normalizeSessionCheckpoint(
+    previous?.checkpoint ?? {
+      sessionId: options.sessionId ?? config.sessionId ?? `sess_${(0, import_node_crypto9.randomUUID)()}`,
+      summary: options.summary,
+      files: options.files
+    }
+  );
+  const file = sessionCloseoutPath(cwd, config.projectId, checkpoint);
+  const existing = readSessionCloseout(file);
+  if (existing?.status === "saved" && existing.entryId) {
+    printCloseout(existing, file, options.json);
+    return;
+  }
+  const report = {
+    version: "snipara.session_closeout.v1",
+    workspace: cwd,
+    projectId: config.projectId,
+    checkpoint,
+    status: "pending",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  fs17.mkdirSync(path16.dirname(file), { recursive: true, mode: 448 });
+  const lock = lockSessionCloseout(file);
   try {
-    const client = createClient(3e4);
-    const result = await client.persistSession();
-    await emitCanonicalEvent({
-      eventType: "session_end",
-      payload: {
-        persisted: true,
-        files_tracked: result.files_tracked
-      }
-    });
-    console.log(`\u2713 Session saved (${result.files_tracked} files tracked)`);
-    const newSessionId = `sess_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
-    saveConfig({ sessionId: newSessionId });
-  } catch (error) {
-    await emitCanonicalEvent({
-      eventType: "session_end",
-      payload: {
-        persisted: false,
-        offline: true
-      }
-    });
-    if (process.env.RLM_DEBUG) {
-      console.error(
-        `[Snipara] Session error: ${error instanceof Error ? error.message : "Unknown error"}`
-      );
+    const confirmed = readSessionCloseout(file);
+    if (confirmed?.status === "saved" && confirmed.entryId) {
+      printCloseout(confirmed, file, options.json);
+      return;
     }
-    console.log("Session ended (offline)");
+    writeSessionCloseout(file, report);
+    try {
+      const result = await createClient(15e3).persistSession(checkpoint);
+      report.status = result.status;
+      report.entryId = result.entry_id;
+      report.journalDate = result.date;
+    } catch {
+      report.status = "error";
+      report.error = "Hosted journal persistence was not confirmed. The checkpoint is retained locally.";
+      process.exitCode = 1;
+    }
+    writeSessionCloseout(file, report);
+    report.eventDelivered = await emitCanonicalEvent(
+      {
+        eventType: "session_end",
+        sessionId: checkpoint.sessionId,
+        payload: {
+          persisted: report.status === "saved",
+          persistence_status: report.status,
+          files_tracked: checkpoint.files.length,
+          ...report.entryId ? { journal_entry_id: report.entryId } : {}
+        }
+      },
+      { timeoutMs: 2e3 }
+    );
+    writeSessionCloseout(file, report);
+    writeSessionCloseout(path16.join(cwd, ".snipara", "companion", "session-closeout.json"), report);
+    if (report.status === "saved" && !options.sessionId && loadConfig().sessionId === checkpoint.sessionId) {
+      saveConfig({ sessionId: `sess_${(0, import_node_crypto9.randomUUID)()}` });
+    }
+    printCloseout(report, file, options.json);
+  } finally {
+    fs17.closeSync(lock);
+    fs17.unlinkSync(`${file}.lock`);
   }
 }
 async function sessionStatusCommand() {
@@ -16337,6 +16491,17 @@ async function sessionStatusCommand() {
   const config = loadConfig();
   console.log("\n\u{1F4CA} Session Status\n");
   console.log(`Session ID: ${config.sessionId || "none"}`);
+  const reportFile = path16.join(
+    process.env.SNIPARA_WORKSPACE_DIR || process.cwd(),
+    ".snipara",
+    "companion",
+    "session-closeout.json"
+  );
+  const report = readSessionCloseout(reportFile);
+  if (report) {
+    console.log(`Last checkpoint: ${report.status}${report.entryId ? ` (${report.entryId})` : ""}`);
+    console.log(`Receipt: ${reportFile}`);
+  }
   try {
     const client = createClient(5e3);
     const status = await client.getSession();
@@ -16358,17 +16523,17 @@ function sessionResetCommand() {
 var import_chalk3 = __toESM(require("chalk"));
 
 // src/commands/decision-requests.ts
-var fs16 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
+var fs18 = __toESM(require("fs"));
+var path17 = __toESM(require("path"));
 function decisionPendingDir(cwd = process.cwd()) {
-  return path15.join(cwd, DECISION_REQUEST_RELATIVE_DIR, "pending");
+  return path17.join(cwd, DECISION_REQUEST_RELATIVE_DIR, "pending");
 }
 function decisionResolvedDir(cwd = process.cwd()) {
-  return path15.join(cwd, DECISION_REQUEST_RELATIVE_DIR, "resolved");
+  return path17.join(cwd, DECISION_REQUEST_RELATIVE_DIR, "resolved");
 }
 function ensureDecisionDirs(cwd = process.cwd()) {
-  fs16.mkdirSync(decisionPendingDir(cwd), { recursive: true });
-  fs16.mkdirSync(decisionResolvedDir(cwd), { recursive: true });
+  fs18.mkdirSync(decisionPendingDir(cwd), { recursive: true });
+  fs18.mkdirSync(decisionResolvedDir(cwd), { recursive: true });
 }
 function writeDecisionRequest(request, cwd = process.cwd()) {
   ensureDecisionDirs(cwd);
@@ -16393,8 +16558,8 @@ function writeDecisionRequest(request, cwd = process.cwd()) {
       relativePath: existing.relativePath
     };
   }
-  const filePath = path15.join(decisionPendingDir(cwd), `${request.requestId}.json`);
-  fs16.writeFileSync(filePath, `${stableDecisionJsonStringify(request)}
+  const filePath = path17.join(decisionPendingDir(cwd), `${request.requestId}.json`);
+  fs18.writeFileSync(filePath, `${stableDecisionJsonStringify(request)}
 `, "utf8");
   return {
     status: "written",
@@ -16409,8 +16574,8 @@ function listPendingDecisionRequests(cwd = process.cwd()) {
   const resolved = new Set(
     listResolvedDecisionRecords(cwd).map((record2) => record2.request.fingerprint)
   );
-  return fs16.readdirSync(decisionPendingDir(cwd)).filter((fileName) => fileName.endsWith(".json")).map((fileName) => path15.join(decisionPendingDir(cwd), fileName)).sort().map((filePath) => {
-    const parsed = JSON.parse(fs16.readFileSync(filePath, "utf8"));
+  return fs18.readdirSync(decisionPendingDir(cwd)).filter((fileName) => fileName.endsWith(".json")).map((fileName) => path17.join(decisionPendingDir(cwd), fileName)).sort().map((filePath) => {
+    const parsed = JSON.parse(fs18.readFileSync(filePath, "utf8"));
     if (!isDecisionRequest(parsed)) {
       throw new Error(
         `Invalid decision request artifact: ${toProjectRelativePath(filePath, cwd)}`
@@ -16426,8 +16591,8 @@ function listPendingDecisionRequests(cwd = process.cwd()) {
   });
 }
 function listResolvedDecisionRecords(cwd = process.cwd()) {
-  fs16.mkdirSync(decisionResolvedDir(cwd), { recursive: true });
-  return fs16.readdirSync(decisionResolvedDir(cwd)).filter((fileName) => fileName.endsWith(".json")).map((fileName) => path15.join(decisionResolvedDir(cwd), fileName)).sort().map((filePath) => JSON.parse(fs16.readFileSync(filePath, "utf8"))).filter((record2) => record2?.schemaVersion === "snipara.decision_resolution.v0");
+  fs18.mkdirSync(decisionResolvedDir(cwd), { recursive: true });
+  return fs18.readdirSync(decisionResolvedDir(cwd)).filter((fileName) => fileName.endsWith(".json")).map((fileName) => path17.join(decisionResolvedDir(cwd), fileName)).sort().map((filePath) => JSON.parse(fs18.readFileSync(filePath, "utf8"))).filter((record2) => record2?.schemaVersion === "snipara.decision_resolution.v0");
 }
 function resolveDecisionRequest(options) {
   const cwd = options.cwd ?? process.cwd();
@@ -16455,18 +16620,18 @@ function resolveDecisionRequest(options) {
     request: entry.request,
     response
   };
-  const resolvedPath = path15.join(decisionResolvedDir(cwd), `${entry.request.requestId}.json`);
-  fs16.writeFileSync(resolvedPath, `${stableDecisionJsonStringify(record2)}
+  const resolvedPath = path17.join(decisionResolvedDir(cwd), `${entry.request.requestId}.json`);
+  fs18.writeFileSync(resolvedPath, `${stableDecisionJsonStringify(record2)}
 `, "utf8");
-  fs16.unlinkSync(entry.path);
+  fs18.unlinkSync(entry.path);
   return { request: entry.request, response, resolvedPath };
 }
 function decisionPendingCount(cwd = process.cwd()) {
   return listPendingDecisionRequests(cwd).filter((entry) => entry.status === "pending").length;
 }
 function toProjectRelativePath(absolutePath, cwd) {
-  const relative15 = path15.relative(cwd, absolutePath).replace(/\\/g, "/");
-  return relative15.startsWith(".") ? relative15 : `.${path15.sep}${relative15}`.replace(/\\/g, "/");
+  const relative15 = path17.relative(cwd, absolutePath).replace(/\\/g, "/");
+  return relative15.startsWith(".") ? relative15 : `.${path17.sep}${relative15}`.replace(/\\/g, "/");
 }
 
 // src/commands/memory.ts
@@ -17249,8 +17414,8 @@ async function memoryAuditCommand(options) {
 }
 
 // src/commands/local-stack.ts
-var fs17 = __toESM(require("fs"));
-var path16 = __toESM(require("path"));
+var fs19 = __toESM(require("fs"));
+var path18 = __toESM(require("path"));
 var import_node_child_process6 = require("child_process");
 function uniqueStrings17(values) {
   return Array.from(new Set((values ?? []).map((value) => value.trim()).filter(Boolean)));
@@ -17266,13 +17431,13 @@ function keywordHints(value) {
 }
 function readJsonFile2(filePath) {
   try {
-    return JSON.parse(fs17.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs19.readFileSync(filePath, "utf8"));
   } catch {
     return void 0;
   }
 }
 function maybeLocalArtifact(rootDir, relativePath2) {
-  const absolutePath = path16.join(rootDir, relativePath2);
+  const absolutePath = path18.join(rootDir, relativePath2);
   const value = readJsonFile2(absolutePath);
   if (!value) {
     return null;
@@ -17305,7 +17470,7 @@ function expectedItems(section, values, files) {
   });
 }
 function buildEvalCaseArtifact(options = {}) {
-  const rootDir = path16.resolve(options.dir ?? process.cwd());
+  const rootDir = path18.resolve(options.dir ?? process.cwd());
   const files = uniqueStrings17(options.files);
   const commandsRun = uniqueStrings17(options.commandRun);
   const summary = options.summary?.trim() || "Snipara companion local workflow evaluation";
@@ -17324,8 +17489,8 @@ function buildEvalCaseArtifact(options = {}) {
     }
   }
   const artifacts = [
-    maybeLocalArtifact(rootDir, path16.join(".snipara", "workflow", "current.json")),
-    maybeLocalArtifact(rootDir, path16.join(".snipara", "team-sync", "session.json"))
+    maybeLocalArtifact(rootDir, path18.join(".snipara", "workflow", "current.json")),
+    maybeLocalArtifact(rootDir, path18.join(".snipara", "team-sync", "session.json"))
   ].filter((artifact) => artifact !== null);
   return {
     id,
@@ -17345,8 +17510,8 @@ function buildEvalCaseArtifact(options = {}) {
   };
 }
 function writeOutput(filePath, content) {
-  fs17.mkdirSync(path16.dirname(filePath), { recursive: true });
-  fs17.writeFileSync(filePath, content, "utf8");
+  fs19.mkdirSync(path18.dirname(filePath), { recursive: true });
+  fs19.writeFileSync(filePath, content, "utf8");
 }
 function runCommand(command, args, missingHint) {
   const result = (0, import_node_child_process6.spawnSync)(command, args, {
@@ -17377,10 +17542,10 @@ async function memoryLocalCommand(options) {
   process.exitCode = code2;
 }
 async function evalExportCommand(options) {
-  const rootDir = path16.resolve(options.dir ?? process.cwd());
-  const output = path16.resolve(
+  const rootDir = path18.resolve(options.dir ?? process.cwd());
+  const output = path18.resolve(
     rootDir,
-    options.output ?? path16.join(".snipara", "evals", "case.json")
+    options.output ?? path18.join(".snipara", "evals", "case.json")
   );
   const artifact = buildEvalCaseArtifact(options);
   const content = `${JSON.stringify(artifact, null, 2)}
@@ -17399,7 +17564,7 @@ async function evalRunCommand(options) {
   }
   const runner = options.runner || process.env.SNIPARA_EVALS_RUNNER || "npx";
   const packageSpec = options.packageSpec || "snipara-evals@latest";
-  const args = path16.basename(runner) === "snipara-evals" ? ["run", ...options.cases] : ["--yes", packageSpec, "run", ...options.cases];
+  const args = path18.basename(runner) === "snipara-evals" ? ["run", ...options.cases] : ["--yes", packageSpec, "run", ...options.cases];
   if (options.json) {
     args.push("--json");
   }
@@ -17415,15 +17580,15 @@ async function evalRunCommand(options) {
 }
 
 // src/commands/doctor.ts
-var fs19 = __toESM(require("fs"));
-var path18 = __toESM(require("path"));
+var fs21 = __toESM(require("fs"));
+var path20 = __toESM(require("path"));
 var import_node_child_process7 = require("child_process");
 var import_chalk4 = __toESM(require("chalk"));
 
 // src/runtime/detection.ts
-var fs18 = __toESM(require("fs"));
+var fs20 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
-var path17 = __toESM(require("path"));
+var path19 = __toESM(require("path"));
 var import_child_process5 = require("child_process");
 var RUNTIME_INTENT_PATTERN = /\b(test|tests|validate|validation|verify|evaluate|eval|execute|execution|run|sandbox|sandboxed|isolated|isolation|simulate|script|python|csv|dataframe|notebook|generate report|lint|type-?check|build|benchmark|parse|transform|repeatable|reproducible)\b/i;
 var ORCHESTRATOR_PRODUCTION_PATTERN = /\b(prod|production|deploy|deployment|release|rollout|cutover|drift|live validation|live check|live checks)\b/i;
@@ -17599,14 +17764,14 @@ function getCommandVersion(command) {
 }
 function executableExists(filePath) {
   try {
-    const stat = fs18.statSync(filePath);
+    const stat = fs20.statSync(filePath);
     if (!stat.isFile()) {
       return false;
     }
     if (process.platform === "win32") {
       return true;
     }
-    fs18.accessSync(filePath, fs18.constants.X_OK);
+    fs20.accessSync(filePath, fs20.constants.X_OK);
     return true;
   } catch {
     return false;
@@ -17652,11 +17817,11 @@ function detectOrchestratorCli(cwd, workspaceRoot2) {
 }
 function findWorkspaceOrchestratorVersion(cwd, workspaceRoot2) {
   const roots = Array.from(
-    new Set([workspaceRoot2, path17.resolve(cwd)].filter((value) => Boolean(value)))
+    new Set([workspaceRoot2, path19.resolve(cwd)].filter((value) => Boolean(value)))
   );
   for (const root of roots) {
     const version = readPyprojectVersion(
-      path17.join(root, "packages", "agentic-orchestrator", "pyproject.toml"),
+      path19.join(root, "packages", "agentic-orchestrator", "pyproject.toml"),
       "snipara-orchestrator"
     );
     if (version) {
@@ -17666,10 +17831,10 @@ function findWorkspaceOrchestratorVersion(cwd, workspaceRoot2) {
   return void 0;
 }
 function readPyprojectVersion(filePath, packageName) {
-  if (!fs18.existsSync(filePath)) {
+  if (!fs20.existsSync(filePath)) {
     return void 0;
   }
-  const content = fs18.readFileSync(filePath, "utf-8");
+  const content = fs20.readFileSync(filePath, "utf-8");
   const nameMatch = content.match(/^\s*name\s*=\s*["']([^"']+)["']/m);
   if (nameMatch && nameMatch[1] !== packageName) {
     return void 0;
@@ -17687,13 +17852,13 @@ function parseOrchestratorVersion(version) {
 function findWorkspaceExecutableCandidates(command, cwd, workspaceRoot2) {
   const executableName = process.platform === "win32" ? `${command}.exe` : command;
   const roots = Array.from(
-    new Set([workspaceRoot2, path17.resolve(cwd)].filter((value) => Boolean(value)))
+    new Set([workspaceRoot2, path19.resolve(cwd)].filter((value) => Boolean(value)))
   );
   return roots.flatMap((root) => [
-    path17.join(root, ".venv", "bin", executableName),
-    path17.join(root, "venv", "bin", executableName),
-    path17.join(root, "packages", "agentic-orchestrator", ".venv", "bin", executableName),
-    path17.join(root, "apps", "mcp-server", ".venv", "bin", executableName)
+    path19.join(root, ".venv", "bin", executableName),
+    path19.join(root, "venv", "bin", executableName),
+    path19.join(root, "packages", "agentic-orchestrator", ".venv", "bin", executableName),
+    path19.join(root, "apps", "mcp-server", ".venv", "bin", executableName)
   ]);
 }
 function parseRuntimeVersion(version) {
@@ -17748,7 +17913,7 @@ function loadEnvFiles(cwd, workspaceRoot2) {
   const values = {};
   const files = [];
   for (const envFile of findEnvFilePaths(cwd, workspaceRoot2)) {
-    if (!fs18.existsSync(envFile)) {
+    if (!fs20.existsSync(envFile)) {
       continue;
     }
     const parsed = parseEnvFile(envFile);
@@ -17759,17 +17924,17 @@ function loadEnvFiles(cwd, workspaceRoot2) {
 }
 function findEnvFilePaths(cwd, workspaceRoot2) {
   const names = [".env", ".env.local", ".env.development", ".env.development.local"];
-  const roots = [workspaceRoot2, path17.resolve(cwd)].filter(
+  const roots = [workspaceRoot2, path19.resolve(cwd)].filter(
     (value) => Boolean(value)
   );
-  const candidates = roots.flatMap((root) => names.map((name) => path17.join(root, name)));
+  const candidates = roots.flatMap((root) => names.map((name) => path19.join(root, name)));
   return Array.from(new Set(candidates));
 }
 function parseEnvFile(filePath) {
   const values = {};
   let content;
   try {
-    content = fs18.readFileSync(filePath, "utf-8");
+    content = fs20.readFileSync(filePath, "utf-8");
   } catch {
     return values;
   }
@@ -17813,24 +17978,24 @@ function parseEnvValue(rawValue) {
 }
 function findRuntimeMcpConfigPaths(cwd, workspaceRoot2) {
   const candidatePaths = [
-    workspaceRoot2 ? path17.join(workspaceRoot2, ".mcp.json") : null,
-    path17.join(cwd, ".mcp.json"),
-    path17.join(os6.homedir(), ".mcp.json"),
-    path17.join(os6.homedir(), ".claude", "claude_desktop_config.json"),
-    path17.join(os6.homedir(), ".codex", "config.toml")
+    workspaceRoot2 ? path19.join(workspaceRoot2, ".mcp.json") : null,
+    path19.join(cwd, ".mcp.json"),
+    path19.join(os6.homedir(), ".mcp.json"),
+    path19.join(os6.homedir(), ".claude", "claude_desktop_config.json"),
+    path19.join(os6.homedir(), ".codex", "config.toml")
   ].filter((value) => Boolean(value));
   const uniquePaths = Array.from(new Set(candidatePaths));
   return uniquePaths.filter((configPath) => configHasRuntimeServer(configPath));
 }
 function configHasRuntimeServer(configPath) {
-  if (!fs18.existsSync(configPath)) {
+  if (!fs20.existsSync(configPath)) {
     return false;
   }
   if (configPath.endsWith(".toml")) {
     return tomlConfigHasRuntimeServer(configPath);
   }
   try {
-    const parsed = JSON.parse(fs18.readFileSync(configPath, "utf-8"));
+    const parsed = JSON.parse(fs20.readFileSync(configPath, "utf-8"));
     if (!isRecord9(parsed)) {
       return false;
     }
@@ -17857,7 +18022,7 @@ function configHasRuntimeServer(configPath) {
 function tomlConfigHasRuntimeServer(configPath) {
   let content;
   try {
-    content = fs18.readFileSync(configPath, "utf-8");
+    content = fs20.readFileSync(configPath, "utf-8");
   } catch {
     return false;
   }
@@ -17910,7 +18075,7 @@ async function doctorCommand(options = {}) {
   printDoctorReport(report, companionVersion, auth, toolCatalog);
 }
 function probeCompanionVersion(report) {
-  const currentVersion = readPackageVersion(path18.resolve(__dirname, "../package.json"));
+  const currentVersion = readPackageVersion(path20.resolve(__dirname, "../package.json"));
   const workspacePackageVersion = findWorkspaceCompanionVersion(report);
   const latestNpm = probeLatestNpmVersion();
   const warnings = [];
@@ -17950,7 +18115,7 @@ function probeCompanionVersion(report) {
 }
 function readPackageVersion(packageJsonPath) {
   try {
-    const raw = fs19.readFileSync(packageJsonPath, "utf8");
+    const raw = fs21.readFileSync(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     return typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : void 0;
   } catch {
@@ -17959,9 +18124,9 @@ function readPackageVersion(packageJsonPath) {
 }
 function findWorkspaceCompanionVersion(report) {
   const candidates = [
-    path18.join(report.cwd, "packages", "cli", "package.json"),
-    report.workspaceRoot ? path18.join(report.workspaceRoot, "packages", "cli", "package.json") : void 0,
-    path18.basename(report.cwd) === "cli" ? path18.join(report.cwd, "package.json") : void 0
+    path20.join(report.cwd, "packages", "cli", "package.json"),
+    report.workspaceRoot ? path20.join(report.workspaceRoot, "packages", "cli", "package.json") : void 0,
+    path20.basename(report.cwd) === "cli" ? path20.join(report.cwd, "package.json") : void 0
   ].filter((value) => Boolean(value));
   for (const candidate of candidates) {
     const version = readPackageVersion(candidate);
@@ -18304,23 +18469,23 @@ var import_path5 = __toESM(require("path"));
 var import_chalk10 = __toESM(require("chalk"));
 
 // src/commands/workflows.ts
-var fs30 = __toESM(require("fs"));
-var path29 = __toESM(require("path"));
+var fs32 = __toESM(require("fs"));
+var path31 = __toESM(require("path"));
 var import_node_child_process15 = require("child_process");
-var import_node_crypto13 = require("crypto");
+var import_node_crypto15 = require("crypto");
 var import_chalk9 = __toESM(require("chalk"));
 
 // src/runtime/orchestrator-handoff.ts
-var fs20 = __toESM(require("fs"));
-var path19 = __toESM(require("path"));
+var fs22 = __toESM(require("fs"));
+var path21 = __toESM(require("path"));
 var import_child_process6 = require("child_process");
-var ORCHESTRATOR_HANDOFF_RELATIVE_PATH = path19.join(
+var ORCHESTRATOR_HANDOFF_RELATIVE_PATH = path21.join(
   ".snipara",
   "orchestrator",
   "handoff.json"
 );
 function buildOrchestratorHandoff(options) {
-  const rootDir = path19.resolve(options.rootDir ?? process.cwd());
+  const rootDir = path21.resolve(options.rootDir ?? process.cwd());
   const workflowState = readWorkflowState(rootDir);
   const changedFiles = normalizeStringList2(
     options.changedFiles ?? (Array.isArray(workflowState?.currentPhase?.files) ? workflowState.currentPhase.files : [])
@@ -18672,11 +18837,11 @@ function compactObject2(value) {
   );
 }
 function writeOrchestratorHandoff(options) {
-  const rootDir = path19.resolve(options.rootDir ?? process.cwd());
+  const rootDir = path21.resolve(options.rootDir ?? process.cwd());
   const handoff = buildOrchestratorHandoff({ ...options, rootDir });
-  const absolutePath = path19.join(rootDir, ORCHESTRATOR_HANDOFF_RELATIVE_PATH);
-  fs20.mkdirSync(path19.dirname(absolutePath), { recursive: true });
-  fs20.writeFileSync(absolutePath, `${JSON.stringify(handoff, null, 2)}
+  const absolutePath = path21.join(rootDir, ORCHESTRATOR_HANDOFF_RELATIVE_PATH);
+  fs22.mkdirSync(path21.dirname(absolutePath), { recursive: true });
+  fs22.writeFileSync(absolutePath, `${JSON.stringify(handoff, null, 2)}
 `, "utf8");
   return {
     handoff,
@@ -18686,11 +18851,11 @@ function writeOrchestratorHandoff(options) {
   };
 }
 function readWorkflowState(rootDir) {
-  const workflowPath = path19.join(rootDir, ".snipara", "workflow", "current.json");
-  if (!fs20.existsSync(workflowPath)) {
+  const workflowPath = path21.join(rootDir, ".snipara", "workflow", "current.json");
+  if (!fs22.existsSync(workflowPath)) {
     return null;
   }
-  const parsed = JSON.parse(fs20.readFileSync(workflowPath, "utf8"));
+  const parsed = JSON.parse(fs22.readFileSync(workflowPath, "utf8"));
   const phases = Array.isArray(parsed.phases) ? parsed.phases.filter(isRecord10).map((phase, index) => normalizeWorkflowPhase(phase, index)) : [];
   const currentPhase = phases.find((phase) => phase.id === parsed.currentPhaseId);
   const runtimeBindings = Array.isArray(parsed.runtime?.sandbox?.bindings) ? parsed.runtime?.sandbox?.bindings.filter(isRecord10) : [];
@@ -18837,9 +19002,9 @@ async function appendJournalCheckpoint(payload) {
 }
 
 // src/commands/coding-ledger.ts
-var fs21 = __toESM(require("fs"));
-var path20 = __toESM(require("path"));
-var import_node_crypto8 = require("crypto");
+var fs23 = __toESM(require("fs"));
+var path22 = __toESM(require("path"));
+var import_node_crypto10 = require("crypto");
 var import_node_child_process8 = require("child_process");
 var CODING_INTELLIGENCE_LEDGER_VERSION = "snipara.coding_intelligence_ledger.v0";
 var MAX_SECTION_ITEMS = 24;
@@ -18883,7 +19048,7 @@ function isRecord11(value) {
 function createRedactor2(rootDir) {
   const patterns = /* @__PURE__ */ new Set();
   let redactedValueCount = 0;
-  const repoPath = path20.resolve(rootDir);
+  const repoPath = path22.resolve(rootDir);
   function redact(value) {
     let result = truncateText(String(value ?? ""));
     const matchedPatterns = [];
@@ -18929,7 +19094,7 @@ function createRedactor2(rootDir) {
   };
 }
 function buildCodingIntelligenceLedger(options = {}) {
-  const rootDir = path20.resolve(options.dir ?? process.cwd());
+  const rootDir = path22.resolve(options.dir ?? process.cwd());
   const input = mergeInputs(readInputFile(options.fromFile, rootDir), options.input);
   const redactor = createRedactor2(rootDir);
   const prompt2 = buildPrompt(input, options, redactor);
@@ -18990,9 +19155,9 @@ async function codingLedgerExportCommand(options) {
   const ledger = buildCodingIntelligenceLedger(options);
   const content = JSON.stringify(ledger, null, 2);
   if (options.output) {
-    const absolute = path20.resolve(options.dir ?? process.cwd(), options.output);
-    fs21.mkdirSync(path20.dirname(absolute), { recursive: true });
-    fs21.writeFileSync(absolute, `${content}
+    const absolute = path22.resolve(options.dir ?? process.cwd(), options.output);
+    fs23.mkdirSync(path22.dirname(absolute), { recursive: true });
+    fs23.writeFileSync(absolute, `${content}
 `, "utf8");
     if (!options.json) {
       console.log(`Wrote coding intelligence ledger: ${absolute}`);
@@ -19189,8 +19354,8 @@ function readInputFile(filePath, rootDir) {
   if (!filePath) {
     return {};
   }
-  const absolute = path20.resolve(rootDir, filePath);
-  const parsed = JSON.parse(fs21.readFileSync(absolute, "utf8"));
+  const absolute = path22.resolve(rootDir, filePath);
+  const parsed = JSON.parse(fs23.readFileSync(absolute, "utf8"));
   if (!isRecord11(parsed)) {
     throw new Error("coding ledger --from-file must contain a JSON object.");
   }
@@ -19295,7 +19460,7 @@ function itemId(section, index, value) {
   return `${section}:${stableHash([section, String(index), value]).slice(0, 16)}`;
 }
 function stableHash(parts) {
-  return (0, import_node_crypto8.createHash)("sha256").update(parts.join("\0")).digest("hex");
+  return (0, import_node_crypto10.createHash)("sha256").update(parts.join("\0")).digest("hex");
 }
 function stringValue5(value) {
   if (typeof value === "string") {
@@ -19389,11 +19554,11 @@ function removeUndefined(value) {
 }
 
 // src/commands/decision-apply.ts
-var fs22 = __toESM(require("fs"));
-var path21 = __toESM(require("path"));
+var fs24 = __toESM(require("fs"));
+var path23 = __toESM(require("path"));
 var DECISION_APPLY_LEDGER_VERSION = "snipara.decision_apply_ledger.v0";
-var DECISION_APPLY_RELATIVE_DIR = path21.join(".snipara", "policy-ledger", "applied");
-var POLICY_DRAFT_RELATIVE_DIR = path21.join(".snipara", "policies", "drafts");
+var DECISION_APPLY_RELATIVE_DIR = path23.join(".snipara", "policy-ledger", "applied");
+var POLICY_DRAFT_RELATIVE_DIR = path23.join(".snipara", "policies", "drafts");
 function buildDecisionApplyReport(options = {}) {
   const cwd = options.cwd ?? process.cwd();
   const dryRun = options.dryRun ?? true;
@@ -19542,12 +19707,12 @@ function summarizeDecisionApplyItems(items, written) {
   };
 }
 function writeAppliedDecisionRecord(item, cwd) {
-  fs22.mkdirSync(appliedDecisionDir(cwd), { recursive: true });
+  fs24.mkdirSync(appliedDecisionDir(cwd), { recursive: true });
   let policyDraftPath;
   if (item.policyDraftPath) {
     const absoluteDraftPath = policyDraftPathFor(cwd, item.requestId);
-    fs22.mkdirSync(path21.dirname(absoluteDraftPath), { recursive: true });
-    fs22.writeFileSync(
+    fs24.mkdirSync(path23.dirname(absoluteDraftPath), { recursive: true });
+    fs24.writeFileSync(
       absoluteDraftPath,
       `${stableDecisionJsonStringify({
         schemaVersion: "snipara.project_policy_draft.v0",
@@ -19592,7 +19757,7 @@ function writeAppliedDecisionRecord(item, cwd) {
     policyDraftPath,
     caveats: item.caveats
   };
-  fs22.writeFileSync(
+  fs24.writeFileSync(
     appliedDecisionPath(cwd, item.requestId),
     `${stableDecisionJsonStringify(record2)}
 `,
@@ -19601,36 +19766,36 @@ function writeAppliedDecisionRecord(item, cwd) {
 }
 function readAppliedDecisionRecord(cwd, requestId) {
   const filePath = appliedDecisionPath(cwd, requestId);
-  if (!fs22.existsSync(filePath)) {
+  if (!fs24.existsSync(filePath)) {
     return void 0;
   }
-  const parsed = JSON.parse(fs22.readFileSync(filePath, "utf8"));
+  const parsed = JSON.parse(fs24.readFileSync(filePath, "utf8"));
   return parsed.schemaVersion === DECISION_APPLY_LEDGER_VERSION ? parsed : void 0;
 }
 function appliedDecisionDir(cwd) {
-  return path21.join(cwd, DECISION_APPLY_RELATIVE_DIR);
+  return path23.join(cwd, DECISION_APPLY_RELATIVE_DIR);
 }
 function appliedDecisionPath(cwd, requestId) {
-  return path21.join(appliedDecisionDir(cwd), `${sanitizeFileStem(requestId)}.json`);
+  return path23.join(appliedDecisionDir(cwd), `${sanitizeFileStem(requestId)}.json`);
 }
 function policyDraftPathFor(cwd, requestId) {
-  return path21.join(cwd, POLICY_DRAFT_RELATIVE_DIR, `${sanitizeFileStem(requestId)}.json`);
+  return path23.join(cwd, POLICY_DRAFT_RELATIVE_DIR, `${sanitizeFileStem(requestId)}.json`);
 }
 function sanitizeFileStem(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 160) || "decision";
 }
 function toProjectRelativePath2(absolutePath, cwd) {
-  const relative15 = path21.relative(cwd, absolutePath).replace(/\\/g, "/");
-  return relative15.startsWith(".") ? relative15 : `.${path21.sep}${relative15}`.replace(/\\/g, "/");
+  const relative15 = path23.relative(cwd, absolutePath).replace(/\\/g, "/");
+  return relative15.startsWith(".") ? relative15 : `.${path23.sep}${relative15}`.replace(/\\/g, "/");
 }
 
 // src/commands/collaboration.ts
 var import_node_child_process9 = require("child_process");
-var import_node_crypto9 = require("crypto");
-var fs23 = __toESM(require("fs"));
+var import_node_crypto11 = require("crypto");
+var fs25 = __toESM(require("fs"));
 var os7 = __toESM(require("os"));
-var path22 = __toESM(require("path"));
-var COLLABORATION_STATE_RELATIVE_PATH = path22.join(
+var path24 = __toESM(require("path"));
+var COLLABORATION_STATE_RELATIVE_PATH = path24.join(
   ".snipara",
   "collaboration",
   "session.json"
@@ -19725,16 +19890,16 @@ function createEmptyCollaborationState(now = /* @__PURE__ */ new Date()) {
   };
 }
 function getCollaborationStatePath(rootDir = process.cwd()) {
-  return path22.join(rootDir, COLLABORATION_STATE_RELATIVE_PATH);
+  return path24.join(rootDir, COLLABORATION_STATE_RELATIVE_PATH);
 }
 function loadCollaborationState(rootDir = process.cwd()) {
   const statePath = getCollaborationStatePath(rootDir);
-  if (!fs23.existsSync(statePath)) {
+  if (!fs25.existsSync(statePath)) {
     return createEmptyCollaborationState();
   }
   let parsed;
   try {
-    parsed = JSON.parse(fs23.readFileSync(statePath, "utf8"));
+    parsed = JSON.parse(fs25.readFileSync(statePath, "utf8"));
   } catch {
     return createEmptyCollaborationState();
   }
@@ -19767,15 +19932,15 @@ function saveCollaborationState(state, rootDir = process.cwd()) {
   expireLocalLeases(state);
   expireReviewOnlyAcknowledgements(state);
   const statePath = getCollaborationStatePath(rootDir);
-  fs23.mkdirSync(path22.dirname(statePath), { recursive: true });
+  fs25.mkdirSync(path24.dirname(statePath), { recursive: true });
   const tempPath = `${statePath}.${process.pid}.${Date.now()}.tmp`;
   try {
-    fs23.writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}
+    fs25.writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
-    fs23.renameSync(tempPath, statePath);
+    fs25.renameSync(tempPath, statePath);
   } finally {
-    if (fs23.existsSync(tempPath)) {
-      fs23.unlinkSync(tempPath);
+    if (fs25.existsSync(tempPath)) {
+      fs25.unlinkSync(tempPath);
     }
   }
 }
@@ -19969,7 +20134,7 @@ async function collaborationClaimCommand(options) {
   );
 }
 async function workflowCollaborationStart(options) {
-  const rootDir = path22.resolve(options.rootDir ?? process.cwd());
+  const rootDir = path24.resolve(options.rootDir ?? process.cwd());
   const workSessionId = workflowWorkSessionId(options.workflowId);
   const context = resolveCollaborationContext({
     dir: rootDir,
@@ -20041,7 +20206,7 @@ async function workflowCollaborationStart(options) {
   };
 }
 async function workflowCollaborationRelease(options) {
-  const rootDir = path22.resolve(options.rootDir ?? process.cwd());
+  const rootDir = path24.resolve(options.rootDir ?? process.cwd());
   const context = resolveCollaborationContext({
     dir: rootDir,
     client: "snipara-companion:workflow"
@@ -20660,9 +20825,9 @@ function readGitChangedFiles(rootDir, args) {
   return output ? normalizeFiles(output.split(/\r?\n/)) : [];
 }
 function resolveRepoRoot3(cwd) {
-  const resolved = path22.resolve(cwd);
+  const resolved = path24.resolve(cwd);
   const gitRoot = readGitValue4(resolved, ["rev-parse", "--show-toplevel"]);
-  return gitRoot ? path22.resolve(gitRoot) : resolved;
+  return gitRoot ? path24.resolve(gitRoot) : resolved;
 }
 function deriveGuardProfileResources(profile, files) {
   const resources = [];
@@ -20939,26 +21104,26 @@ ${nextBlock}`);
 }
 function resolveGitHooksDir2(repoRoot) {
   const gitHooksPath = readGitValue4(repoRoot, ["rev-parse", "--git-path", "hooks"]);
-  const hooksDir = path22.resolve(repoRoot, gitHooksPath ?? path22.join(".git", "hooks"));
-  const huskyUserHooksDir = path22.dirname(hooksDir);
-  if (path22.basename(hooksDir) === "_" && path22.basename(huskyUserHooksDir) === ".husky" && fs23.existsSync(path22.join(hooksDir, "h"))) {
+  const hooksDir = path24.resolve(repoRoot, gitHooksPath ?? path24.join(".git", "hooks"));
+  const huskyUserHooksDir = path24.dirname(hooksDir);
+  if (path24.basename(hooksDir) === "_" && path24.basename(huskyUserHooksDir) === ".husky" && fs25.existsSync(path24.join(hooksDir, "h"))) {
     return huskyUserHooksDir;
   }
   return hooksDir;
 }
 function installManagedCollaborationGitHook(repoRoot, hookName, options) {
   const hooksDir = resolveGitHooksDir2(repoRoot);
-  const hookPath = path22.join(hooksDir, hookName);
-  const currentContent = fs23.existsSync(hookPath) ? fs23.readFileSync(hookPath, "utf8") : null;
+  const hookPath = path24.join(hooksDir, hookName);
+  const currentContent = fs25.existsSync(hookPath) ? fs25.readFileSync(hookPath, "utf8") : null;
   const block = buildCollaborationGitHookBlock(hookName);
   const nextContent = mergeManagedCollaborationHookBlock(hookName, currentContent, block);
   const action = currentContent === null ? "created" : currentContent === nextContent ? "unchanged" : "updated";
   if (!options.dryRun && action !== "unchanged") {
-    fs23.mkdirSync(hooksDir, { recursive: true });
-    fs23.writeFileSync(hookPath, nextContent, "utf8");
-    fs23.chmodSync(hookPath, 493);
-  } else if (!options.dryRun && fs23.existsSync(hookPath)) {
-    fs23.chmodSync(hookPath, fs23.statSync(hookPath).mode | 493);
+    fs25.mkdirSync(hooksDir, { recursive: true });
+    fs25.writeFileSync(hookPath, nextContent, "utf8");
+    fs25.chmodSync(hookPath, 493);
+  } else if (!options.dryRun && fs25.existsSync(hookPath)) {
+    fs25.chmodSync(hookPath, fs25.statSync(hookPath).mode | 493);
   }
   return { hook: hookName, path: hookPath, action, content: nextContent };
 }
@@ -21370,7 +21535,7 @@ function printGuardActionCards(cards) {
   }
 }
 function buildLocalSessionId(context, task, files) {
-  const hash = (0, import_node_crypto9.createHash)("sha1").update([context.actor.actorId, context.branch ?? "", task ?? "", files.join(",")].join("\n")).digest("hex").slice(0, 12);
+  const hash = (0, import_node_crypto11.createHash)("sha1").update([context.actor.actorId, context.branch ?? "", task ?? "", files.join(",")].join("\n")).digest("hex").slice(0, 12);
   return `local_${hash}`;
 }
 function normalizeFiles(files) {
@@ -21475,7 +21640,7 @@ function fingerprintReviewOnlyGuardEvaluation(evaluation) {
     workSessionId: conflict.workSessionId ?? null,
     reason: conflict.reason
   })).sort((a, b) => JSON.stringify(a).localeCompare(JSON.stringify(b)));
-  return (0, import_node_crypto9.createHash)("sha256").update(JSON.stringify(findings)).digest("hex");
+  return (0, import_node_crypto11.createHash)("sha256").update(JSON.stringify(findings)).digest("hex");
 }
 function persistReviewOnlyAcknowledgement(state, profile, action, findingFingerprint, now = /* @__PURE__ */ new Date()) {
   invalidateReviewOnlyAcknowledgements(state, profile, action);
@@ -21554,7 +21719,7 @@ function normalizeResourceId(kind, id) {
   return normalized;
 }
 function normalizeRepoPath3(value) {
-  return value.trim().split(path22.sep).join("/").replace(/^\.?\//, "");
+  return value.trim().split(path24.sep).join("/").replace(/^\.?\//, "");
 }
 function normalizeOptionalString3(value) {
   const normalized = typeof value === "string" ? value.trim() : "";
@@ -21601,15 +21766,15 @@ function ensureTrailingNewline3(value) {
 `;
 }
 function sleep2(ms) {
-  return new Promise((resolve25) => setTimeout(resolve25, ms));
+  return new Promise((resolve26) => setTimeout(resolve26, ms));
 }
 
 // src/commands/team-sync.ts
-var fs24 = __toESM(require("fs"));
-var path23 = __toESM(require("path"));
+var fs26 = __toESM(require("fs"));
+var path25 = __toESM(require("path"));
 var import_node_child_process10 = require("child_process");
-var import_node_crypto10 = require("crypto");
-var TEAM_SYNC_STATE_RELATIVE_PATH = path23.join(".snipara", "team-sync", "session.json");
+var import_node_crypto12 = require("crypto");
+var TEAM_SYNC_STATE_RELATIVE_PATH = path25.join(".snipara", "team-sync", "session.json");
 var TEAM_SYNC_STALE_WORK_MS = 48 * 60 * 60 * 1e3;
 var TEAM_SYNC_AUTO_ARCHIVE_WORK_MS = 14 * 24 * 60 * 60 * 1e3;
 function buildTeamSyncStartWorkRecord(input) {
@@ -21813,10 +21978,10 @@ function autoArchiveTeamSyncState(rootDir = process.cwd(), now = /* @__PURE__ */
 }
 function loadTeamSyncState(rootDir = process.cwd()) {
   const statePath = getTeamSyncStatePath(rootDir);
-  if (!fs24.existsSync(statePath)) {
+  if (!fs26.existsSync(statePath)) {
     return createEmptyTeamSyncState();
   }
-  const parsed = JSON.parse(fs24.readFileSync(statePath, "utf8"));
+  const parsed = JSON.parse(fs26.readFileSync(statePath, "utf8"));
   return {
     schemaVersion: "snipara.team-sync.v1",
     updatedAt: typeof parsed.updatedAt === "string" ? parsed.updatedAt : (/* @__PURE__ */ new Date()).toISOString(),
@@ -21826,12 +21991,12 @@ function loadTeamSyncState(rootDir = process.cwd()) {
 }
 function saveTeamSyncState(state, rootDir = process.cwd()) {
   const statePath = getTeamSyncStatePath(rootDir);
-  fs24.mkdirSync(path23.dirname(statePath), { recursive: true });
-  fs24.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}
+  fs26.mkdirSync(path25.dirname(statePath), { recursive: true });
+  fs26.writeFileSync(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
 function getTeamSyncStatePath(rootDir = process.cwd()) {
-  return path23.join(rootDir, TEAM_SYNC_STATE_RELATIVE_PATH);
+  return path25.join(rootDir, TEAM_SYNC_STATE_RELATIVE_PATH);
 }
 async function createTeamSyncStartWorkPayload(rootDir, options) {
   const state = loadTeamSyncState(rootDir);
@@ -22026,12 +22191,12 @@ async function createTeamSyncHandoffPayload(rootDir, options) {
   };
 }
 function readWorkflowSnapshot(rootDir) {
-  const statePath = path23.join(rootDir, ".snipara", "workflow", "current.json");
-  if (!fs24.existsSync(statePath)) {
+  const statePath = path25.join(rootDir, ".snipara", "workflow", "current.json");
+  if (!fs26.existsSync(statePath)) {
     return void 0;
   }
   try {
-    const parsed = JSON.parse(fs24.readFileSync(statePath, "utf8"));
+    const parsed = JSON.parse(fs26.readFileSync(statePath, "utf8"));
     const currentPhaseId = typeof parsed.currentPhaseId === "string" ? parsed.currentPhaseId : void 0;
     const currentPhase = Array.isArray(parsed.phases) ? parsed.phases.find((phase) => phase.id === currentPhaseId) : void 0;
     return {
@@ -22304,7 +22469,7 @@ function redactHandoffText(value, rootDir) {
   let result = value;
   const aliases = /* @__PURE__ */ new Set([rootDir]);
   try {
-    aliases.add(fs24.realpathSync(rootDir));
+    aliases.add(fs26.realpathSync(rootDir));
   } catch {
   }
   for (const alias of aliases) {
@@ -22333,21 +22498,21 @@ function sanitizeHandoffArtifact(artifact, rootDir) {
   return sanitizeHandoffValue(artifact, rootDir);
 }
 function canonicalizePathForBoundary(value) {
-  let current = path23.resolve(value);
+  let current = path25.resolve(value);
   const suffix = [];
-  while (!fs24.existsSync(current)) {
-    const parent = path23.dirname(current);
+  while (!fs26.existsSync(current)) {
+    const parent = path25.dirname(current);
     if (parent === current) {
       break;
     }
-    suffix.unshift(path23.basename(current));
+    suffix.unshift(path25.basename(current));
     current = parent;
   }
   try {
-    current = fs24.realpathSync(current);
+    current = fs26.realpathSync(current);
   } catch {
   }
-  return path23.join(current, ...suffix);
+  return path25.join(current, ...suffix);
 }
 function markdownList(values) {
   return values.map((value) => `- ${value}`).join("\n");
@@ -22420,18 +22585,18 @@ function writeAgenticHandoffArtifact(rootDir, output, artifact) {
   if (!output) {
     return void 0;
   }
-  const outputPath = path23.resolve(rootDir, output);
-  const relative15 = path23.relative(
+  const outputPath = path25.resolve(rootDir, output);
+  const relative15 = path25.relative(
     canonicalizePathForBoundary(rootDir),
     canonicalizePathForBoundary(outputPath)
   );
-  if (!relative15 || relative15.startsWith("..") || path23.isAbsolute(relative15) || relative15 === ".git" || relative15.startsWith(`.git${path23.sep}`)) {
+  if (!relative15 || relative15.startsWith("..") || path25.isAbsolute(relative15) || relative15 === ".git" || relative15.startsWith(`.git${path25.sep}`)) {
     throw new Error("Handoff output must stay inside the project directory and outside .git.");
   }
-  fs24.mkdirSync(path23.dirname(outputPath), { recursive: true });
+  fs26.mkdirSync(path25.dirname(outputPath), { recursive: true });
   const content = outputPath.toLowerCase().endsWith(".json") ? `${JSON.stringify(artifact, null, 2)}
 ` : buildAgenticHandoffMarkdown(artifact);
-  fs24.writeFileSync(outputPath, content, "utf8");
+  fs26.writeFileSync(outputPath, content, "utf8");
   return outputPath;
 }
 async function agenticHandoffCommand(options) {
@@ -23174,7 +23339,7 @@ function readHostedContext(rootDir) {
   };
 }
 function resolveRootDir(dir) {
-  return path23.resolve(dir ?? process.cwd());
+  return path25.resolve(dir ?? process.cwd());
 }
 function matchesCompletionEvidence(item, evidence) {
   if (matchesDirectCompletionEvidence(item, evidence)) {
@@ -23393,7 +23558,7 @@ function formatError2(error) {
   return error instanceof Error ? error.message : String(error);
 }
 function buildRecordId(prefix, createdAt, summary, files) {
-  const hash = (0, import_node_crypto10.createHash)("sha1").update([createdAt, summary, files.join(",")].join("\n")).digest("hex").slice(0, 10);
+  const hash = (0, import_node_crypto12.createHash)("sha1").update([createdAt, summary, files.join(",")].join("\n")).digest("hex").slice(0, 10);
   return `${prefix}_${hash}`;
 }
 
@@ -24298,12 +24463,12 @@ function printKeyValue(label, value) {
 }
 
 // src/commands/final-commit-report.ts
-var import_node_crypto11 = require("crypto");
+var import_node_crypto13 = require("crypto");
 var import_node_child_process12 = require("child_process");
-var fs26 = __toESM(require("fs"));
-var path25 = __toESM(require("path"));
+var fs28 = __toESM(require("fs"));
+var path27 = __toESM(require("path"));
 var FINAL_COMMIT_REPORT_VERSION = "snipara.final_commit_report.v1";
-var FINAL_COMMIT_REPORT_RELATIVE_PATH = path25.join(
+var FINAL_COMMIT_REPORT_RELATIVE_PATH = path27.join(
   ".snipara",
   "workflow",
   "final-report.json"
@@ -24445,7 +24610,7 @@ function whyCaptureRationale(receipt) {
   return receipt.previewCandidates.map((candidate) => candidate.rationale).find(Boolean);
 }
 function buildFinalCommitReport(input) {
-  const cwd = path25.resolve(input.cwd ?? process.cwd());
+  const cwd = path27.resolve(input.cwd ?? process.cwd());
   const phases = (input.state?.phases ?? []).map((phase) => ({
     id: phase.id,
     title: phase.title,
@@ -24568,18 +24733,18 @@ function buildFinalCommitReport(input) {
   };
 }
 function writeFinalCommitReport(report, cwd = process.cwd()) {
-  const outputPath = path25.join(cwd, FINAL_COMMIT_REPORT_RELATIVE_PATH);
+  const outputPath = path27.join(cwd, FINAL_COMMIT_REPORT_RELATIVE_PATH);
   try {
-    fs26.mkdirSync(path25.dirname(outputPath), { recursive: true });
+    fs28.mkdirSync(path27.dirname(outputPath), { recursive: true });
     const content = `${JSON.stringify(report, null, 2)}
 `;
-    fs26.writeFileSync(outputPath, content, "utf8");
+    fs28.writeFileSync(outputPath, content, "utf8");
     return {
       status: "written",
       version: FINAL_COMMIT_REPORT_VERSION,
       path: outputPath,
       relativePath: FINAL_COMMIT_REPORT_RELATIVE_PATH,
-      hash: `sha256:${(0, import_node_crypto11.createHash)("sha256").update(content).digest("hex")}`
+      hash: `sha256:${(0, import_node_crypto13.createHash)("sha256").update(content).digest("hex")}`
     };
   } catch (error) {
     return {
@@ -24651,9 +24816,9 @@ function formatFinalCommitReport(report) {
 
 // src/commands/run.ts
 var import_node_child_process14 = require("child_process");
-var import_node_crypto12 = require("crypto");
-var fs28 = __toESM(require("fs"));
-var path27 = __toESM(require("path"));
+var import_node_crypto14 = require("crypto");
+var fs30 = __toESM(require("fs"));
+var path29 = __toESM(require("path"));
 var import_chalk8 = __toESM(require("chalk"));
 
 // src/commands/intelligence.ts
@@ -26751,7 +26916,7 @@ function buildProjectIntelligenceRunEnvelope(startedAt = /* @__PURE__ */ new Dat
   const codexSessionId = stringValue10(process.env.CODEX_SESSION_ID)?.slice(0, 200);
   return {
     version: "project-intelligence.judgment-run-envelope.v1",
-    runId: sniparaSessionId ?? codexSessionId ?? `judgment-run:${(0, import_node_crypto12.randomUUID)()}`,
+    runId: sniparaSessionId ?? codexSessionId ?? `judgment-run:${(0, import_node_crypto14.randomUUID)()}`,
     identitySource: sniparaSessionId ? "snipara_session" : codexSessionId ? "codex_session" : "generated",
     startedAt: startedAt.toISOString()
   };
@@ -26792,8 +26957,8 @@ function packageReviewCommand3() {
 function readOutcomeReceipts(files) {
   const receipts = [];
   for (const file of normalizeStringList5(files)) {
-    const resolved = path27.resolve(process.cwd(), file);
-    const parsed = JSON.parse(fs28.readFileSync(resolved, "utf8"));
+    const resolved = path29.resolve(process.cwd(), file);
+    const parsed = JSON.parse(fs30.readFileSync(resolved, "utf8"));
     receipts.push(...outcomeReceiptsFromUnknown(parsed));
   }
   return receipts;
@@ -27693,12 +27858,12 @@ async function projectIntelligenceRunCommand(options) {
 }
 
 // src/commands/agent-context.ts
-var fs29 = __toESM(require("fs"));
-var path28 = __toESM(require("path"));
+var fs31 = __toESM(require("fs"));
+var path30 = __toESM(require("path"));
 var AGENT_CONTEXT_MANIFEST_DEFAULT_PATH = "snipara.agent-context.json";
 function readManifest2(manifestPath2) {
   try {
-    return JSON.parse(fs29.readFileSync(manifestPath2, "utf8"));
+    return JSON.parse(fs31.readFileSync(manifestPath2, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Unable to read Agent Context manifest ${manifestPath2}: ${message}`);
@@ -27714,15 +27879,15 @@ function localSourceFinding(sourceId, sourcePath, summary) {
   };
 }
 function buildLocalAgentContextValidationReport(options) {
-  const cwd = path28.resolve(options.cwd ?? process.cwd());
+  const cwd = path30.resolve(options.cwd ?? process.cwd());
   const report = validateAgentContextManifest({
     manifest: options.manifest,
     generatedAt: options.generatedAt
   });
   if (!report.manifest) return report;
   const localFindings = report.manifest.sources.flatMap((source2) => {
-    const absolutePath = path28.resolve(cwd, source2.path);
-    if (!fs29.existsSync(absolutePath)) {
+    const absolutePath = path30.resolve(cwd, source2.path);
+    if (!fs31.existsSync(absolutePath)) {
       return [
         localSourceFinding(
           source2.id,
@@ -27731,7 +27896,7 @@ function buildLocalAgentContextValidationReport(options) {
         )
       ];
     }
-    if (!fs29.statSync(absolutePath).isFile()) {
+    if (!fs31.statSync(absolutePath).isFile()) {
       return [
         localSourceFinding(
           source2.id,
@@ -27750,10 +27915,10 @@ function buildLocalAgentContextValidationReport(options) {
   };
 }
 function manifestPath(cwd, candidate) {
-  return path28.resolve(cwd, candidate ?? AGENT_CONTEXT_MANIFEST_DEFAULT_PATH);
+  return path30.resolve(cwd, candidate ?? AGENT_CONTEXT_MANIFEST_DEFAULT_PATH);
 }
 function resolveLocalAgentContext(options) {
-  const cwd = path28.resolve(options.cwd ?? process.cwd());
+  const cwd = path30.resolve(options.cwd ?? process.cwd());
   const resolvedManifestPath = manifestPath(cwd, options.manifest);
   const manifest = readManifest2(resolvedManifestPath);
   const validation = buildLocalAgentContextValidationReport({ cwd, manifest });
@@ -27762,7 +27927,7 @@ function resolveLocalAgentContext(options) {
     throw new Error(`Invalid Agent Context manifest. ${errors}`.trim());
   }
   return {
-    manifestPath: path28.relative(cwd, resolvedManifestPath) || path28.basename(resolvedManifestPath),
+    manifestPath: path30.relative(cwd, resolvedManifestPath) || path30.basename(resolvedManifestPath),
     resolution: resolveAgentContext({
       manifest,
       agent: options.agent,
@@ -27838,14 +28003,14 @@ function formatAgentContextResolution(resolution) {
   return lines.join("\n");
 }
 async function agentContextValidateCommand(options = {}) {
-  const cwd = path28.resolve(options.cwd ?? process.cwd());
+  const cwd = path30.resolve(options.cwd ?? process.cwd());
   const resolvedManifestPath = manifestPath(cwd, options.manifest);
   const report = buildLocalAgentContextValidationReport({
     cwd,
     manifest: readManifest2(resolvedManifestPath)
   });
   console.log(
-    options.json ? stableDecisionJsonStringify(report) : formatValidationReport(report, path28.relative(cwd, resolvedManifestPath))
+    options.json ? stableDecisionJsonStringify(report) : formatValidationReport(report, path30.relative(cwd, resolvedManifestPath))
   );
   if (report.status === "invalid") {
     process.exitCode = 1;
@@ -27882,7 +28047,7 @@ var FINAL_COMMIT_SUMMARY_MAX_CHARS = 1200;
 var FINAL_COMMIT_RETRY_SUMMARY_MAX_CHARS = 600;
 var DEFAULT_ADAPTIVE_ROUTING_CATALOG_LIMIT = 20;
 var DEFAULT_LOCAL_ORCHESTRATOR_TIMEOUT_MS = 8e3;
-var ADAPTIVE_ROUTING_POLICY_RELATIVE_PATH2 = path29.join(".snipara", "adaptive-routing.json");
+var ADAPTIVE_ROUTING_POLICY_RELATIVE_PATH2 = path31.join(".snipara", "adaptive-routing.json");
 var MEMORY_DECISION_PRODUCER_ACTIONS = /* @__PURE__ */ new Set([
   "accept",
   "reject",
@@ -27953,11 +28118,11 @@ var REUPLOAD_REASONS = /* @__PURE__ */ new Set([
   "source_modified_after_upload",
   "source_hash_changed"
 ]);
-var WORKFLOW_STATE_RELATIVE_PATH = path29.join(".snipara", "workflow", "current.json");
-var WORKFLOW_PLANS_RELATIVE_DIR = path29.join(".snipara", "workflow", "plans");
+var WORKFLOW_STATE_RELATIVE_PATH = path31.join(".snipara", "workflow", "current.json");
+var WORKFLOW_PLANS_RELATIVE_DIR = path31.join(".snipara", "workflow", "plans");
 var PRODUCER_LOOP_ARTIFACT_VERSION = "snipara.producer_loop_artifact.v0";
 var PRODUCER_LOOP_REPORT_VERSION = "snipara.producer_loop_report.v0";
-var PRODUCER_LOOP_RELATIVE_DIR = path29.join(".snipara", "producer-loop");
+var PRODUCER_LOOP_RELATIVE_DIR = path31.join(".snipara", "producer-loop");
 var PRODUCER_LOOP_MIN_REVIEW_SAMPLE_SIZE = 5;
 var WORKFLOW_PLAN_PRESET_IDS = [
   "memory-backend-unification",
@@ -28049,7 +28214,7 @@ function parseJsonRecord(value, label) {
   return parsed;
 }
 function readJsonRecord3(file, label) {
-  return parseJsonRecord(fs30.readFileSync(file, "utf-8"), label);
+  return parseJsonRecord(fs32.readFileSync(file, "utf-8"), label);
 }
 function parseCsv(value) {
   if (!value) {
@@ -28093,7 +28258,7 @@ function optionalReindexMode(value) {
   return value === "incremental" || value === "full" ? value : void 0;
 }
 function inferDocumentFormat(filePath) {
-  return DOCUMENT_SYNC_FORMATS[path29.extname(filePath).toLowerCase()];
+  return DOCUMENT_SYNC_FORMATS[path31.extname(filePath).toLowerCase()];
 }
 function normalizeDocumentKind(value) {
   const normalized = normalizeEnum(value);
@@ -28126,7 +28291,7 @@ function contentBufferForHash(content) {
   return Buffer.from(content, "utf8");
 }
 function hashContent(content) {
-  return (0, import_node_crypto13.createHash)("sha256").update(contentBufferForHash(content)).digest("hex");
+  return (0, import_node_crypto15.createHash)("sha256").update(contentBufferForHash(content)).digest("hex");
 }
 function toPreview(value, maxLength = 160) {
   if (typeof value === "string") {
@@ -28373,7 +28538,7 @@ function buildPlanRelevanceWarnings(plan, options) {
       if (/^(?:https?:)?\/\//i.test(fileHint)) {
         return false;
       }
-      return !fs30.existsSync(path29.resolve(options.cwd, fileHint));
+      return !fs32.existsSync(path31.resolve(options.cwd, fileHint));
     });
     if (missingHints.length > 0) {
       warnings.push(
@@ -28934,12 +29099,12 @@ function buildGeneratedWorkflowPlanDocument(plan, fallbackGoal) {
 }
 function defaultGeneratedPlanFilePath(query) {
   const filename = `${sanitizeWorkflowId(query, "snipara-plan")}-plan.json`;
-  return path29.join(process.cwd(), WORKFLOW_PLANS_RELATIVE_DIR, filename);
+  return path31.join(process.cwd(), WORKFLOW_PLANS_RELATIVE_DIR, filename);
 }
 function writeGeneratedWorkflowPlanFile(plan, fallbackGoal, outputFile) {
-  const outputPath = path29.resolve(outputFile ?? defaultGeneratedPlanFilePath(fallbackGoal));
-  fs30.mkdirSync(path29.dirname(outputPath), { recursive: true });
-  fs30.writeFileSync(
+  const outputPath = path31.resolve(outputFile ?? defaultGeneratedPlanFilePath(fallbackGoal));
+  fs32.mkdirSync(path31.dirname(outputPath), { recursive: true });
+  fs32.writeFileSync(
     outputPath,
     `${JSON.stringify(buildGeneratedWorkflowPlanDocument(plan, fallbackGoal), null, 2)}
 `,
@@ -28947,7 +29112,7 @@ function writeGeneratedWorkflowPlanFile(plan, fallbackGoal, outputFile) {
   );
   return {
     path: outputPath,
-    relativePath: path29.relative(process.cwd(), outputPath) || path29.basename(outputPath)
+    relativePath: path31.relative(process.cwd(), outputPath) || path31.basename(outputPath)
   };
 }
 function booleanValue4(value) {
@@ -29364,15 +29529,15 @@ function buildWorkflowPlanPresetDocument(preset, goal) {
   }
 }
 function defaultWorkflowPlanOutputPath(preset, cwd = process.cwd()) {
-  return path29.resolve(cwd, WORKFLOW_PLANS_RELATIVE_DIR, `${preset}-plan.json`);
+  return path31.resolve(cwd, WORKFLOW_PLANS_RELATIVE_DIR, `${preset}-plan.json`);
 }
 function toProjectRelativePath3(absolutePath, cwd = process.cwd()) {
-  const relative15 = path29.relative(cwd, absolutePath);
+  const relative15 = path31.relative(cwd, absolutePath);
   return relative15 && !relative15.startsWith("..") ? relative15 : absolutePath;
 }
 function buildWorkflowPlanScaffold(preset, options = {}) {
-  const cwd = path29.resolve(options.cwd ?? process.cwd());
-  const outputPath = path29.resolve(options.outputPath ?? defaultWorkflowPlanOutputPath(preset, cwd));
+  const cwd = path31.resolve(options.cwd ?? process.cwd());
+  const outputPath = path31.resolve(options.outputPath ?? defaultWorkflowPlanOutputPath(preset, cwd));
   const plan = buildWorkflowPlanPresetDocument(preset, options.goal);
   return {
     preset,
@@ -29383,18 +29548,18 @@ function buildWorkflowPlanScaffold(preset, options = {}) {
   };
 }
 function readWorkflowPlanFile(planFile, fallbackGoal) {
-  const content = fs30.readFileSync(planFile, "utf-8");
+  const content = fs32.readFileSync(planFile, "utf-8");
   if (planFile.toLowerCase().endsWith(".json")) {
     return normalizeWorkflowPlanInput(JSON.parse(content), fallbackGoal);
   }
   return normalizeWorkflowPlanInput(content, fallbackGoal);
 }
 function readWorkflowPlanMode(planFile) {
-  if (!planFile || !planFile.toLowerCase().endsWith(".json") || !fs30.existsSync(planFile)) {
+  if (!planFile || !planFile.toLowerCase().endsWith(".json") || !fs32.existsSync(planFile)) {
     return void 0;
   }
   try {
-    const parsed = JSON.parse(fs30.readFileSync(planFile, "utf-8"));
+    const parsed = JSON.parse(fs32.readFileSync(planFile, "utf-8"));
     return normalizeWorkflowCoordinationMode(parsed.mode);
   } catch {
     return void 0;
@@ -29411,7 +29576,7 @@ function inferWorkflowCoordinationMode(options) {
   return readWorkflowPlanMode(options.planFile) ?? (options.planFile ? "full" : "standard");
 }
 function getWorkflowStatePath(cwd = process.cwd()) {
-  return path29.join(cwd, WORKFLOW_STATE_RELATIVE_PATH);
+  return path31.join(cwd, WORKFLOW_STATE_RELATIVE_PATH);
 }
 function normalizeManagedWorkflowTaskState(task, phase, index, fallbackStatus) {
   const status = normalizeTaskStatus(task.status ?? fallbackStatus);
@@ -29542,10 +29707,10 @@ function normalizeManagedWorkflowRuntimeState(runtime) {
 }
 function readWorkflowState2(cwd = process.cwd()) {
   const statePath = getWorkflowStatePath(cwd);
-  if (!fs30.existsSync(statePath)) {
+  if (!fs32.existsSync(statePath)) {
     return void 0;
   }
-  const parsed = JSON.parse(fs30.readFileSync(statePath, "utf-8"));
+  const parsed = JSON.parse(fs32.readFileSync(statePath, "utf-8"));
   if (!Array.isArray(parsed.phases)) {
     throw new Error(`${WORKFLOW_STATE_RELATIVE_PATH} is not a valid Snipara workflow state file`);
   }
@@ -29562,14 +29727,14 @@ function readRequiredWorkflowState() {
 }
 function writeWorkflowState(state) {
   const statePath = getWorkflowStatePath();
-  fs30.mkdirSync(path29.dirname(statePath), { recursive: true });
+  fs32.mkdirSync(path31.dirname(statePath), { recursive: true });
   const normalizedState = normalizeManagedWorkflowState(state);
   const normalized = {
     ...normalizedState,
     schemaVersion: "snipara.workflow.v2",
     runtime: normalizeManagedWorkflowRuntimeState(normalizedState.runtime)
   };
-  fs30.writeFileSync(statePath, `${JSON.stringify(normalized, null, 2)}
+  fs32.writeFileSync(statePath, `${JSON.stringify(normalized, null, 2)}
 `, "utf-8");
 }
 function sortJsonValue4(value) {
@@ -29592,7 +29757,7 @@ function hashJsonValue(value) {
   return `sha256:${hashContent(stableJsonStringify(value))}`;
 }
 function getProducerLoopDir(cwd = process.cwd()) {
-  return path29.join(cwd, PRODUCER_LOOP_RELATIVE_DIR);
+  return path31.join(cwd, PRODUCER_LOOP_RELATIVE_DIR);
 }
 function buildProducerLoopArtifactId(options) {
   const source2 = [
@@ -29705,9 +29870,9 @@ function writeProducerLoopArtifact(options) {
     const artifact = buildProducerLoopArtifact(options);
     const artifactHash = hashJsonValue(artifact);
     const fileName = `${artifact.generatedAt.replace(/[:.]/g, "-")}-${artifact.artifactId}.json`;
-    const outputPath = path29.join(getProducerLoopDir(), fileName);
-    fs30.mkdirSync(path29.dirname(outputPath), { recursive: true });
-    fs30.writeFileSync(outputPath, stableJsonStringify(artifact), "utf-8");
+    const outputPath = path31.join(getProducerLoopDir(), fileName);
+    fs32.mkdirSync(path31.dirname(outputPath), { recursive: true });
+    fs32.writeFileSync(outputPath, stableJsonStringify(artifact), "utf-8");
     return {
       status: "written",
       schemaVersion: PRODUCER_LOOP_ARTIFACT_VERSION,
@@ -29760,7 +29925,7 @@ function stringArrayValue(value) {
 function summarizeProducerLoopArtifactFile(filePath, cwd) {
   const relativePath2 = toProjectRelativePath3(filePath, cwd);
   try {
-    const content = fs30.readFileSync(filePath, "utf-8");
+    const content = fs32.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(content);
     if (!isRecord19(parsed)) {
       throw new Error("artifact must be a JSON object");
@@ -29826,10 +29991,10 @@ function summarizeProducerLoopArtifactFile(filePath, cwd) {
 }
 function listProducerLoopArtifactFiles(cwd) {
   const dir = getProducerLoopDir(cwd);
-  if (!fs30.existsSync(dir)) {
+  if (!fs32.existsSync(dir)) {
     return [];
   }
-  return fs30.readdirSync(dir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => path29.join(dir, fileName)).sort();
+  return fs32.readdirSync(dir).filter((fileName) => fileName.endsWith(".json")).map((fileName) => path31.join(dir, fileName)).sort();
 }
 function producerLoopCalibrationStatus(sampleSize, reviewedSampleSize, minReviewSampleSize) {
   if (sampleSize === 0) {
@@ -29840,8 +30005,8 @@ function producerLoopCalibrationStatus(sampleSize, reviewedSampleSize, minReview
   }
   return "reviewable_sample_set";
 }
-var WORKER_RECEIPT_RELATIVE_DIR = path29.join(".snipara", "orchestrator", "executions");
-var WORKER_REVIEW_RELATIVE_DIR = path29.join(".snipara", "orchestrator", "reviews");
+var WORKER_RECEIPT_RELATIVE_DIR = path31.join(".snipara", "orchestrator", "executions");
+var WORKER_REVIEW_RELATIVE_DIR = path31.join(".snipara", "orchestrator", "reviews");
 var REQUIRED_WORKER_RECEIPT_FAMILIES = [
   "handoffReceiptId",
   "claimId",
@@ -29850,18 +30015,18 @@ var REQUIRED_WORKER_RECEIPT_FAMILIES = [
   "brainUpdateReceiptId"
 ];
 function listJsonFiles(relativeDir, cwd) {
-  const directory = path29.join(cwd, relativeDir);
-  if (!fs30.existsSync(directory)) {
+  const directory = path31.join(cwd, relativeDir);
+  if (!fs32.existsSync(directory)) {
     return [];
   }
-  return fs30.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path29.join(directory, entry.name)).sort();
+  return fs32.readdirSync(directory, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => path31.join(directory, entry.name)).sort();
 }
 function readWorkerReviewFiles(cwd) {
   const reviews = /* @__PURE__ */ new Map();
   const invalid = [];
   for (const filePath of listJsonFiles(WORKER_REVIEW_RELATIVE_DIR, cwd)) {
     try {
-      const parsed = JSON.parse(fs30.readFileSync(filePath, "utf-8"));
+      const parsed = JSON.parse(fs32.readFileSync(filePath, "utf-8"));
       if (!isRecord19(parsed)) {
         throw new Error("review must be a JSON object");
       }
@@ -29893,7 +30058,7 @@ function summarizeWorkerExecutionReceipts(cwd) {
   const samples = [];
   for (const filePath of listJsonFiles(WORKER_RECEIPT_RELATIVE_DIR, cwd)) {
     try {
-      const parsed = JSON.parse(fs30.readFileSync(filePath, "utf-8"));
+      const parsed = JSON.parse(fs32.readFileSync(filePath, "utf-8"));
       if (!isRecord19(parsed)) {
         throw new Error("receipt must be a JSON object");
       }
@@ -29989,7 +30154,7 @@ function buildWorkerTrustRows(samples, minReviewSampleSize) {
   );
 }
 function buildProducerLoopReport(options = {}) {
-  const cwd = path29.resolve(options.cwd ?? process.cwd());
+  const cwd = path31.resolve(options.cwd ?? process.cwd());
   const minReviewSampleSize = Math.max(
     1,
     Math.floor(options.minReviewSampleSize ?? PRODUCER_LOOP_MIN_REVIEW_SAMPLE_SIZE)
@@ -30110,22 +30275,22 @@ function resolveProducerLoopReviewTarget(cwd, selector, latest) {
     return latestArtifact.path;
   }
   const directCandidates = [
-    path29.resolve(cwd, normalizedSelector),
-    path29.resolve(cwd, PRODUCER_LOOP_RELATIVE_DIR, normalizedSelector)
+    path31.resolve(cwd, normalizedSelector),
+    path31.resolve(cwd, PRODUCER_LOOP_RELATIVE_DIR, normalizedSelector)
   ];
-  const directMatch = directCandidates.find((candidate) => fs30.existsSync(candidate));
+  const directMatch = directCandidates.find((candidate) => fs32.existsSync(candidate));
   if (directMatch) {
     return directMatch;
   }
   const normalizedPathSelector = normalizedSelector.replace(/\\/g, "/").replace(/^\.\//, "");
   const matches = files.filter((filePath) => {
     const relativePath2 = toProjectRelativePath3(filePath, cwd).replace(/\\/g, "/");
-    const basename12 = path29.basename(filePath);
+    const basename12 = path31.basename(filePath);
     if (basename12 === normalizedSelector || relativePath2 === normalizedPathSelector || relativePath2.replace(/^\.\//, "") === normalizedPathSelector) {
       return true;
     }
     try {
-      const parsed = JSON.parse(fs30.readFileSync(filePath, "utf-8"));
+      const parsed = JSON.parse(fs32.readFileSync(filePath, "utf-8"));
       return isRecord19(parsed) && stringValue11(parsed.artifactId) === normalizedSelector;
     } catch {
       return false;
@@ -30142,7 +30307,7 @@ function resolveProducerLoopReviewTarget(cwd, selector, latest) {
   return matches[0];
 }
 function readProducerLoopArtifactForReview(filePath) {
-  const parsed = JSON.parse(fs30.readFileSync(filePath, "utf-8"));
+  const parsed = JSON.parse(fs32.readFileSync(filePath, "utf-8"));
   if (!isRecord19(parsed)) {
     throw new Error("artifact must be a JSON object");
   }
@@ -30197,7 +30362,7 @@ function applyProducerLoopArtifactReview(artifact, options) {
   };
 }
 function reviewProducerLoopArtifact(options) {
-  const cwd = path29.resolve(options.cwd ?? process.cwd());
+  const cwd = path31.resolve(options.cwd ?? process.cwd());
   const targetPath = resolveProducerLoopReviewTarget(cwd, options.artifact, options.latest);
   const artifact = readProducerLoopArtifactForReview(targetPath);
   const rawOutcome = stringValue11(options.outcome);
@@ -30217,8 +30382,8 @@ function reviewProducerLoopArtifact(options) {
     ...outcome ? { outcome } : {},
     notes: options.notes ?? []
   });
-  fs30.writeFileSync(targetPath, stableJsonStringify(reviewed), "utf-8");
-  const content = fs30.readFileSync(targetPath, "utf-8");
+  fs32.writeFileSync(targetPath, stableJsonStringify(reviewed), "utf-8");
+  const content = fs32.readFileSync(targetPath, "utf-8");
   return {
     status: "reviewed",
     schemaVersion: PRODUCER_LOOP_ARTIFACT_VERSION,
@@ -30967,8 +31132,8 @@ async function workflowScaffoldCommand(options) {
     goal: options.goal,
     outputPath: options.output
   });
-  fs30.mkdirSync(path29.dirname(scaffold.outputPath), { recursive: true });
-  fs30.writeFileSync(`${scaffold.outputPath}`, `${JSON.stringify(scaffold.plan, null, 2)}
+  fs32.mkdirSync(path31.dirname(scaffold.outputPath), { recursive: true });
+  fs32.writeFileSync(`${scaffold.outputPath}`, `${JSON.stringify(scaffold.plan, null, 2)}
 `, "utf8");
   if (options.json) {
     printJson2({
@@ -31062,17 +31227,17 @@ function nextEligibleWorkflowTask(state, phase) {
 }
 var DEFAULT_AGENT_CONTEXT_AGENT = "snipara-code";
 function agentContextManifestConfig(cwd = process.cwd()) {
-  const manifestPath2 = path29.resolve(cwd, "snipara.agent-context.json");
-  if (!fs30.existsSync(manifestPath2)) return void 0;
+  const manifestPath2 = path31.resolve(cwd, "snipara.agent-context.json");
+  if (!fs32.existsSync(manifestPath2)) return void 0;
   try {
-    const parsed = JSON.parse(fs30.readFileSync(manifestPath2, "utf8"));
+    const parsed = JSON.parse(fs32.readFileSync(manifestPath2, "utf8"));
     const agentId = process.env.SNIPARA_AGENT_ID?.trim() || DEFAULT_AGENT_CONTEXT_AGENT;
     if (!parsed.agents || !Object.prototype.hasOwnProperty.call(parsed.agents, agentId)) {
       return void 0;
     }
     return {
       agentId,
-      manifest: path29.relative(cwd, manifestPath2) || path29.basename(manifestPath2)
+      manifest: path31.relative(cwd, manifestPath2) || path31.basename(manifestPath2)
     };
   } catch {
     return void 0;
@@ -31245,7 +31410,7 @@ function findSandboxRuntimeBinding(state, phaseId) {
 function defaultSandboxSessionId(state, phase) {
   const workflowSlug = sanitizeWorkflowId(state.workflowId, "workflow").slice(0, 24);
   const phaseSlug = sanitizeWorkflowId(phase.id, "phase").slice(0, 24);
-  const digest = (0, import_node_crypto13.createHash)("sha1").update(`${state.workflowId}:${phase.id}`).digest("hex").slice(0, 10);
+  const digest = (0, import_node_crypto15.createHash)("sha1").update(`${state.workflowId}:${phase.id}`).digest("hex").slice(0, 10);
   return `sandbox-${workflowSlug}-${phaseSlug}-${digest}`.slice(0, 96);
 }
 function ensureSandboxRuntimeBinding(state, phase, now) {
@@ -31806,10 +31971,10 @@ function readGitNulList(args, cwd) {
   return output.split("\0").map((item) => item.trim()).filter(Boolean);
 }
 function readGitRepoRoot(cwd = process.cwd()) {
-  return path29.resolve(runGitText(["rev-parse", "--show-toplevel"], cwd) ?? cwd);
+  return path31.resolve(runGitText(["rev-parse", "--show-toplevel"], cwd) ?? cwd);
 }
 function normalizeRepoFilePath(value) {
-  return value.split(path29.sep).join("/").replace(/^\/+/, "");
+  return value.split(path31.sep).join("/").replace(/^\/+/, "");
 }
 function resolveWorkflowImpactBaseRef(repoRoot, base) {
   const explicitBase = base?.trim();
@@ -31868,7 +32033,7 @@ function parseDirtyFileFromStatusLine(line) {
   return renamedPath ? normalizeRepoFilePath(renamedPath.replace(/^"|"$/g, "")) : void 0;
 }
 function isLocalImpactCodeFile(filePath) {
-  return [".ts", ".tsx", ".mts", ".cts", ".py", ".pyi", ".go"].includes(path29.extname(filePath));
+  return [".ts", ".tsx", ".mts", ".cts", ".py", ".pyi", ".go"].includes(path31.extname(filePath));
 }
 function completedWorkflowPhasesForImpact(state, changedFiles) {
   const changedFileSet = new Set(changedFiles);
@@ -32787,12 +32952,12 @@ function readLocalAdaptiveRoutingProjectPolicy() {
   if (!workspaceRoot2) {
     return null;
   }
-  const policyPath = path29.join(workspaceRoot2, ADAPTIVE_ROUTING_POLICY_RELATIVE_PATH2);
-  if (!fs30.existsSync(policyPath)) {
+  const policyPath = path31.join(workspaceRoot2, ADAPTIVE_ROUTING_POLICY_RELATIVE_PATH2);
+  if (!fs32.existsSync(policyPath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs30.readFileSync(policyPath, "utf8"));
+    const parsed = JSON.parse(fs32.readFileSync(policyPath, "utf8"));
     if (!isRecord19(parsed)) {
       return null;
     }
@@ -33261,8 +33426,8 @@ function enrichAdaptiveRoutingWithLocalOrchestrator(routing, options, cwd = proc
     };
   }
 }
-function printUploadResult(path44, result) {
-  printKeyValue2("Uploaded:", path44);
+function printUploadResult(path46, result) {
+  printKeyValue2("Uploaded:", path46);
   printCompactObject(result, ["message", "document_id", "documentId", "version", "status"]);
   console.log("");
   printJson2(result);
@@ -33607,9 +33772,9 @@ function printOrchestrateResult(result) {
   }
   printJson2(result);
 }
-function printLoadDocumentResult(path44, result) {
+function printLoadDocumentResult(path46, result) {
   printKeyValue2("Tool:", "snipara_load_document");
-  printKeyValue2("Path:", path44);
+  printKeyValue2("Path:", path46);
   console.log("");
   if (typeof result === "string") {
     console.log(result.trim());
@@ -33749,7 +33914,7 @@ async function uploadCommand(options) {
   const inferred = inferDocumentFormat(options.path) ?? (options.file ? inferDocumentFormat(options.file) : void 0);
   const kind = normalizeDocumentKind(options.kind) ?? inferred?.kind;
   const format = normalizeDocumentFormat(options.format) ?? inferred?.format;
-  const content = options.content ?? (options.file ? kind === "BINARY" ? `base64:${fs30.readFileSync(options.file).toString("base64")}` : fs30.readFileSync(options.file, "utf-8") : void 0);
+  const content = options.content ?? (options.file ? kind === "BINARY" ? `base64:${fs32.readFileSync(options.file).toString("base64")}` : fs32.readFileSync(options.file, "utf-8") : void 0);
   if (!content) {
     throw new Error("Provide either --content or --file");
   }
@@ -33825,7 +33990,7 @@ async function businessCollectionEnsureCommand(options) {
 }
 async function businessCollectionUploadCommand(options) {
   ensureConfigured();
-  const content = options.content ?? (options.file ? fs30.readFileSync(options.file, "utf-8") : void 0);
+  const content = options.content ?? (options.file ? fs32.readFileSync(options.file, "utf-8") : void 0);
   if (!content) {
     throw new Error("Provide either --content or --file");
   }
@@ -33937,30 +34102,30 @@ function normalizeSyncDocumentsPayload(payload) {
   };
 }
 function toUploadPath(filePath, rootDir, prefix) {
-  const relative15 = path29.relative(rootDir, filePath).split(path29.sep).join("/");
+  const relative15 = path31.relative(rootDir, filePath).split(path31.sep).join("/");
   const trimmedPrefix = prefix?.replace(/^\/+|\/+$/g, "");
   return trimmedPrefix ? `${trimmedPrefix}/${relative15}` : relative15;
 }
 function collectDirectoryDocuments(options) {
-  const rootDir = path29.resolve(options.dir);
+  const rootDir = path31.resolve(options.dir);
   const documents = [];
   function visit(directory) {
-    for (const entry of fs30.readdirSync(directory, { withFileTypes: true })) {
-      const entryPath = path29.join(directory, entry.name);
+    for (const entry of fs32.readdirSync(directory, { withFileTypes: true })) {
+      const entryPath = path31.join(directory, entry.name);
       if (entry.isDirectory()) {
         if (options.recursive) {
           visit(entryPath);
         }
         continue;
       }
-      if (!entry.isFile() || !DEFAULT_SYNC_EXTENSIONS.has(path29.extname(entry.name).toLowerCase())) {
+      if (!entry.isFile() || !DEFAULT_SYNC_EXTENSIONS.has(path31.extname(entry.name).toLowerCase())) {
         continue;
       }
       const documentFormat = inferDocumentFormat(entry.name);
       if (!documentFormat) {
         continue;
       }
-      const rawContent = fs30.readFileSync(entryPath);
+      const rawContent = fs32.readFileSync(entryPath);
       const content = documentFormat.kind === "BINARY" ? `base64:${rawContent.toString("base64")}` : rawContent.toString("utf-8");
       documents.push({
         path: toUploadPath(entryPath, rootDir, options.prefix),
@@ -33985,7 +34150,7 @@ function collectSyncDocumentsInput(options) {
     throw new Error("Provide either --file or --dir");
   }
   if (options.file) {
-    const payload = JSON.parse(fs30.readFileSync(options.file, "utf-8"));
+    const payload = JSON.parse(fs32.readFileSync(options.file, "utf-8"));
     return normalizeSyncDocumentsPayload(payload);
   }
   return {
@@ -34128,7 +34293,7 @@ function normalizeOnboardFolderMode(value) {
   throw new Error("Onboard mode must be one of: auto, business_context, code_project, mixed");
 }
 function toPosixPath(filePath) {
-  return filePath.split(path29.sep).join("/");
+  return filePath.split(path31.sep).join("/");
 }
 function firstPathSegment(filePath) {
   return filePath.split("/")[0]?.toLowerCase() ?? "";
@@ -34138,31 +34303,31 @@ function hasBusinessKeyword(filePath) {
   return BUSINESS_PATH_KEYWORDS.some((keyword) => lower.includes(keyword));
 }
 function isBusinessLookingFile(file) {
-  return BUSINESS_MARKER_EXTENSIONS.has(path29.extname(file.path).toLowerCase()) || hasBusinessKeyword(file.path);
+  return BUSINESS_MARKER_EXTENSIONS.has(path31.extname(file.path).toLowerCase()) || hasBusinessKeyword(file.path);
 }
 function scanOnboardFolder(options) {
-  const rootDir = path29.resolve(options.dir);
-  if (!fs30.existsSync(rootDir)) {
+  const rootDir = path31.resolve(options.dir);
+  if (!fs32.existsSync(rootDir)) {
     throw new Error(`Directory does not exist: ${options.dir}`);
   }
-  if (!fs30.statSync(rootDir).isDirectory()) {
+  if (!fs32.statSync(rootDir).isDirectory()) {
     throw new Error(`Expected a directory: ${options.dir}`);
   }
   const files = [];
   function visit(directory) {
-    for (const entry of fs30.readdirSync(directory, { withFileTypes: true })) {
+    for (const entry of fs32.readdirSync(directory, { withFileTypes: true })) {
       if (entry.isDirectory()) {
         if (options.recursive && !ONBOARD_IGNORED_DIRS.has(entry.name)) {
-          visit(path29.join(directory, entry.name));
+          visit(path31.join(directory, entry.name));
         }
         continue;
       }
       if (!entry.isFile()) {
         continue;
       }
-      const absolutePath = path29.join(directory, entry.name);
-      const stat = fs30.statSync(absolutePath);
-      const relativePath2 = toPosixPath(path29.relative(rootDir, absolutePath));
+      const absolutePath = path31.join(directory, entry.name);
+      const stat = fs32.statSync(absolutePath);
+      const relativePath2 = toPosixPath(path31.relative(rootDir, absolutePath));
       const format = inferDocumentFormat(entry.name);
       files.push({
         absolutePath,
@@ -34190,13 +34355,13 @@ function classifyOnboardFolder(rootDir, files, overrideMode = "auto") {
   let businessScore = 0;
   let codeSourceFiles = 0;
   let supportedPlainDocuments = 0;
-  if (fs30.existsSync(path29.join(rootDir, ".git"))) {
+  if (fs32.existsSync(path31.join(rootDir, ".git"))) {
     codeScore += 4;
     addSignal2(codeSignals, ".git directory");
   }
   for (const file of files) {
-    const base = path29.basename(file.path);
-    const ext = path29.extname(file.path).toLowerCase();
+    const base = path31.basename(file.path);
+    const ext = path31.extname(file.path).toLowerCase();
     const firstSegment = firstPathSegment(file.path);
     if (CODE_MARKER_FILES.has(base)) {
       codeScore += 3;
@@ -34273,10 +34438,10 @@ function inferOnboardContextLane(file, mode) {
   if (hasBusinessKeyword(file.path)) {
     return "business_context";
   }
-  if (REPO_DOC_FILES.has(path29.basename(file.path))) {
+  if (REPO_DOC_FILES.has(path31.basename(file.path))) {
     return "repo_docs";
   }
-  const ext = path29.extname(file.path).toLowerCase();
+  const ext = path31.extname(file.path).toLowerCase();
   if ([".docx", ".pdf", ".pptx", ".vsdx"].includes(ext)) {
     return "business_context";
   }
@@ -34304,7 +34469,7 @@ function buildOnboardSyncManifestPayload(result) {
   };
 }
 function buildOnboardFolderManifest(options) {
-  const rootDir = path29.resolve(options.dir);
+  const rootDir = path31.resolve(options.dir);
   const recursive = options.recursive ?? true;
   const files = scanOnboardFolder({ dir: rootDir, recursive });
   const modeOverride = normalizeOnboardFolderMode(options.mode);
@@ -34335,7 +34500,7 @@ function buildOnboardFolderManifest(options) {
     options.clientId ? { clientId: options.clientId } : void 0
   );
   const documents = supportedFiles.map((file) => {
-    const rawContent = fs30.readFileSync(file.absolutePath);
+    const rawContent = fs32.readFileSync(file.absolutePath);
     const content = file.kind === "BINARY" ? `base64:${rawContent.toString("base64")}` : rawContent.toString("utf-8");
     const lane = inferOnboardContextLane(file, classification.mode);
     const metadata = mergeRecords(metadataDefaults, {
@@ -34633,7 +34798,7 @@ async function syncDocumentsCommand(options) {
 async function onboardFolderCommand(options) {
   const manifest = buildOnboardFolderManifest(options);
   if (options.writeManifest) {
-    fs30.writeFileSync(
+    fs32.writeFileSync(
       options.writeManifest,
       `${JSON.stringify(buildOnboardSyncManifestPayload(manifest), null, 2)}
 `,
@@ -35228,7 +35393,7 @@ function startManagedWorkflowState(options) {
       `Active workflow '${existing.workflowId}' already exists. Use --force to replace ${WORKFLOW_STATE_RELATIVE_PATH}.`
     );
   }
-  const goal = options.goal ?? (options.planFile ? `Workflow from ${path29.basename(options.planFile)}` : void 0);
+  const goal = options.goal ?? (options.planFile ? `Workflow from ${path31.basename(options.planFile)}` : void 0);
   if (!goal) {
     throw new Error("Provide --goal or --plan-file");
   }
@@ -35246,7 +35411,7 @@ function startManagedWorkflowState(options) {
     status: "active",
     currentPhaseId: phases[0]?.id,
     planSource: options.planFile ? "file" : "inline",
-    ...options.planFile ? { planFile: path29.resolve(options.planFile) } : {},
+    ...options.planFile ? { planFile: path31.resolve(options.planFile) } : {},
     createdAt: now,
     updatedAt: now,
     phases,
@@ -36380,7 +36545,7 @@ function localWorkspacePathAliases() {
   const cwd = process.cwd();
   const aliases = /* @__PURE__ */ new Set([cwd]);
   try {
-    aliases.add(fs30.realpathSync(cwd));
+    aliases.add(fs32.realpathSync(cwd));
   } catch {
   }
   for (const alias of [...aliases]) {
@@ -36398,9 +36563,9 @@ function redactTimelineText(value, maxLength = 180) {
 }
 function redactTimelineFile(file) {
   const workspaceAlias = localWorkspacePathAliases().find(
-    (alias) => path29.isAbsolute(file) && file.startsWith(alias)
+    (alias) => path31.isAbsolute(file) && file.startsWith(alias)
   );
-  const relative15 = workspaceAlias ? path29.relative(workspaceAlias, file) : file;
+  const relative15 = workspaceAlias ? path31.relative(workspaceAlias, file) : file;
   if (relative15.startsWith(".snipara/") || relative15 === ".snipara") {
     return "[local-state]";
   }
@@ -37806,12 +37971,12 @@ function emptySessionMemoriesResult() {
   };
 }
 function readLocalJsonFile(relativePath2) {
-  const absolutePath = path29.join(process.cwd(), relativePath2);
-  if (!fs30.existsSync(absolutePath)) {
+  const absolutePath = path31.join(process.cwd(), relativePath2);
+  if (!fs32.existsSync(absolutePath)) {
     return null;
   }
   try {
-    const parsed = JSON.parse(fs30.readFileSync(absolutePath, "utf-8"));
+    const parsed = JSON.parse(fs32.readFileSync(absolutePath, "utf-8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -37821,14 +37986,14 @@ function summarizeSourceSnapshot(snapshot) {
   if (!snapshot) {
     return {
       status: "missing",
-      snapshotPath: path29.join(".snipara", "source", "latest.json"),
+      snapshotPath: path31.join(".snipara", "source", "latest.json"),
       nextAction: "Run snipara-companion source sync --json after meaningful local code or docs movement."
     };
   }
   const summary = snapshot.summary && typeof snapshot.summary === "object" && !Array.isArray(snapshot.summary) ? snapshot.summary : {};
   return {
     status: "present",
-    snapshotPath: path29.join(".snipara", "source", "latest.json"),
+    snapshotPath: path31.join(".snipara", "source", "latest.json"),
     generatedAt: snapshot.generatedAt,
     revision: snapshot.revision,
     totalFiles: summary.totalFiles,
@@ -37862,7 +38027,7 @@ function summarizeTeamSyncForContinuity() {
   const summary = buildTeamSyncSummary(state);
   const latestHandoff = state.handoffs.at(-1);
   return {
-    statePath: path29.relative(process.cwd(), getTeamSyncStatePath()),
+    statePath: path31.relative(process.cwd(), getTeamSyncStatePath()),
     activeWorkCount: summary.activeWorkCount,
     staleWorkCount: summary.staleWorkCount,
     completedWorkCount: summary.completedWorkCount,
@@ -37880,7 +38045,7 @@ function buildCompanionContinuityPayload(args) {
   const config = args.configured ? loadConfig() : null;
   const workflow2 = readWorkflowState2();
   const sessionSnapshot = readSessionSnapshot();
-  const sourceSnapshot = readLocalJsonFile(path29.join(".snipara", "source", "latest.json"));
+  const sourceSnapshot = readLocalJsonFile(path31.join(".snipara", "source", "latest.json"));
   return {
     version: COMPANION_CONTINUITY_CONTRACT_VERSION,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -37892,9 +38057,9 @@ function buildCompanionContinuityPayload(args) {
     } : null,
     artifacts: {
       workflowStatePath: WORKFLOW_STATE_RELATIVE_PATH,
-      teamSyncStatePath: path29.relative(process.cwd(), getTeamSyncStatePath()),
-      sessionSnapshotPath: path29.join(".snipara", "activity", "session.json"),
-      sourceSnapshotPath: path29.join(".snipara", "source", "latest.json")
+      teamSyncStatePath: path31.relative(process.cwd(), getTeamSyncStatePath()),
+      sessionSnapshotPath: path31.join(".snipara", "activity", "session.json"),
+      sourceSnapshotPath: path31.join(".snipara", "source", "latest.json")
     },
     bootstrap: args.bootstrap,
     bootstrapQuality: args.bootstrapQuality,
@@ -38632,12 +38797,12 @@ async function sourceWatchCommand(options = {}) {
       if (stopping) {
         break;
       }
-      await new Promise((resolve25) => {
-        resolveWait = resolve25;
+      await new Promise((resolve26) => {
+        resolveWait = resolve26;
         activeTimer = setTimeout(() => {
           activeTimer = null;
           resolveWait = null;
-          resolve25();
+          resolve26();
         }, intervalMs);
       });
     }
@@ -38903,7 +39068,7 @@ async function docsBootstrapCommand(options = {}) {
 var import_fs7 = __toESM(require("fs"));
 var import_path7 = __toESM(require("path"));
 var import_node_child_process16 = require("child_process");
-var import_node_crypto14 = require("crypto");
+var import_node_crypto16 = require("crypto");
 var import_chalk12 = __toESM(require("chalk"));
 var CONTROLLED_WORKER_EXECUTIONS_DIR = import_path7.default.join(".snipara", "worker-executions");
 var UNIFIED_RECEIPTS_DIR = import_path7.default.join(".snipara", "unified-receipts");
@@ -39171,7 +39336,7 @@ function pathFingerprint(workspaceRoot2, relativePath2) {
     const stat = import_fs7.default.lstatSync(candidate);
     if (stat.isSymbolicLink()) return `symlink:${import_fs7.default.readlinkSync(candidate)}`;
     if (!stat.isFile()) return `mode:${stat.mode}:size:${stat.size}`;
-    return `file:${stat.mode}:${(0, import_node_crypto14.createHash)("sha256").update(import_fs7.default.readFileSync(candidate)).digest("hex")}`;
+    return `file:${stat.mode}:${(0, import_node_crypto16.createHash)("sha256").update(import_fs7.default.readFileSync(candidate)).digest("hex")}`;
   } catch {
     return "missing";
   }
@@ -39546,8 +39711,8 @@ function printJson5(value) {
 }
 
 // src/commands/agent-readiness.ts
-var fs35 = __toESM(require("fs"));
-var path34 = __toESM(require("path"));
+var fs37 = __toESM(require("fs"));
+var path36 = __toESM(require("path"));
 var TARGETS = {
   codex: {
     label: "Codex",
@@ -39602,18 +39767,18 @@ function recordList2(value) {
 }
 function safeReadJson2(filePath) {
   try {
-    const parsed = JSON.parse(fs35.readFileSync(filePath, "utf8"));
+    const parsed = JSON.parse(fs37.readFileSync(filePath, "utf8"));
     return isRecord21(parsed) ? parsed : void 0;
   } catch {
     return void 0;
   }
 }
 function relativePath(rootDir, filePath) {
-  const relative15 = path34.relative(rootDir, filePath);
+  const relative15 = path36.relative(rootDir, filePath);
   return relative15 && !relative15.startsWith("..") ? relative15 : filePath;
 }
 function collectAgentReadinessLocalSignals(rootDir = process.cwd()) {
-  const workflowPath = path34.join(rootDir, ".snipara", "workflow", "current.json");
+  const workflowPath = path36.join(rootDir, ".snipara", "workflow", "current.json");
   const workflowJson = safeReadJson2(workflowPath);
   const phases = recordList2(workflowJson?.phases);
   const workflow2 = {
@@ -39625,7 +39790,7 @@ function collectAgentReadinessLocalSignals(rootDir = process.cwd()) {
     completedPhases: phases.filter((phase) => phase.status === "completed").length,
     pendingPhases: phases.filter((phase) => phase.status === "pending").length
   };
-  const teamSyncPath = path34.join(rootDir, ".snipara", "team-sync", "session.json");
+  const teamSyncPath = path36.join(rootDir, ".snipara", "team-sync", "session.json");
   const teamSyncJson = safeReadJson2(teamSyncPath);
   const work = recordList2(teamSyncJson?.work);
   const handoffs = recordList2(teamSyncJson?.handoffs);
@@ -39640,9 +39805,9 @@ function collectAgentReadinessLocalSignals(rootDir = process.cwd()) {
     latestActiveSummary: stringValue14(latestActive?.summary),
     latestHandoffSummary: stringValue14(latestHandoff?.summary)
   };
-  const agentsPath = path34.join(rootDir, "AGENTS.md");
+  const agentsPath = path36.join(rootDir, "AGENTS.md");
   const projectInstructions = {
-    present: fs35.existsSync(agentsPath),
+    present: fs37.existsSync(agentsPath),
     path: relativePath(rootDir, agentsPath)
   };
   return { workflow: workflow2, teamSync: teamSync2, projectInstructions };
@@ -39963,15 +40128,15 @@ function formatAgentReadinessAuditReport(report) {
   return lines.join("\n");
 }
 function writeReport(outputPath, report) {
-  const absolute = path34.resolve(outputPath);
-  fs35.mkdirSync(path34.dirname(absolute), { recursive: true });
+  const absolute = path36.resolve(outputPath);
+  fs37.mkdirSync(path36.dirname(absolute), { recursive: true });
   const content = outputPath.endsWith(".json") ? `${JSON.stringify(report, null, 2)}
 ` : `${formatAgentReadinessAuditReport(report)}
 `;
-  fs35.writeFileSync(absolute, content, "utf8");
+  fs37.writeFileSync(absolute, content, "utf8");
 }
 async function agentReadinessAuditCommand(options) {
-  const cwd = path34.resolve(options.dir ?? process.cwd());
+  const cwd = path36.resolve(options.dir ?? process.cwd());
   const report = buildAgentReadinessAuditReport({
     ...options,
     cwd,
@@ -39988,8 +40153,8 @@ async function agentReadinessAuditCommand(options) {
 }
 
 // src/commands/lead-plan.ts
-var fs36 = __toESM(require("fs"));
-var path35 = __toESM(require("path"));
+var fs38 = __toESM(require("fs"));
+var path37 = __toESM(require("path"));
 
 // src/commands/execution-receipts.ts
 var ENGINEERING_LEAD_PROOF_VERIFICATION_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
@@ -41233,7 +41398,7 @@ function applyReconciliationToPlan(plan, reconciliation) {
   };
 }
 function readJsonFile3(filePath) {
-  const parsed = JSON.parse(fs36.readFileSync(path35.resolve(filePath), "utf8"));
+  const parsed = JSON.parse(fs38.readFileSync(path37.resolve(filePath), "utf8"));
   if (!isRecord22(parsed)) {
     throw new Error(`${filePath} must contain a JSON object`);
   }
@@ -41419,16 +41584,16 @@ function formatCompanionEngineeringLeadPlanReport(report) {
   return lines.join("\n");
 }
 function writeReport2(outputPath, report) {
-  const absolute = path35.resolve(outputPath);
-  fs36.mkdirSync(path35.dirname(absolute), { recursive: true });
+  const absolute = path37.resolve(outputPath);
+  fs38.mkdirSync(path37.dirname(absolute), { recursive: true });
   const content = outputPath.endsWith(".json") ? `${JSON.stringify(report, null, 2)}
 ` : `${formatCompanionEngineeringLeadPlanReport(report)}
 `;
-  fs36.writeFileSync(absolute, content, "utf8");
+  fs38.writeFileSync(absolute, content, "utf8");
 }
 function defaultJsonOutputPath(cwd, report) {
   const timestamp = report.generatedAt.replace(/[:.]/g, "-");
-  return path35.join(
+  return path37.join(
     cwd,
     ".snipara",
     "lead-plans",
@@ -41436,7 +41601,7 @@ function defaultJsonOutputPath(cwd, report) {
   );
 }
 async function leadPlanCommand(options) {
-  const cwd = path35.resolve(options.dir ?? process.cwd());
+  const cwd = path37.resolve(options.dir ?? process.cwd());
   const report = buildCompanionEngineeringLeadPlanReport({
     ...options,
     cwd,
@@ -41451,11 +41616,11 @@ async function leadPlanCommand(options) {
       JSON.stringify(
         {
           ...report,
-          outputPath: writtenOutput ? path35.resolve(writtenOutput) : void 0,
-          relativeOutputPath: writtenOutput ? path35.relative(cwd, path35.resolve(writtenOutput)) : void 0,
-          nextCommand: writtenOutput ? `snipara-orchestrator team-sync gate --plan ${path35.relative(
+          outputPath: writtenOutput ? path37.resolve(writtenOutput) : void 0,
+          relativeOutputPath: writtenOutput ? path37.relative(cwd, path37.resolve(writtenOutput)) : void 0,
+          nextCommand: writtenOutput ? `snipara-orchestrator team-sync gate --plan ${path37.relative(
             cwd,
-            path35.resolve(writtenOutput)
+            path37.resolve(writtenOutput)
           )} --json` : void 0
         },
         null,
@@ -41468,11 +41633,11 @@ async function leadPlanCommand(options) {
 }
 
 // src/commands/feature.ts
-var fs37 = __toESM(require("fs"));
-var path36 = __toESM(require("path"));
+var fs39 = __toESM(require("fs"));
+var path38 = __toESM(require("path"));
 var import_chalk14 = __toESM(require("chalk"));
 var FEATURE_WORK_ITEM_VERSION = "snipara.feature_work_item.v1";
-var FEATURE_DEFAULT_OUTPUT_DIR = path36.join("docs", "specs");
+var FEATURE_DEFAULT_OUTPUT_DIR = path38.join("docs", "specs");
 function compact(value) {
   return (value ?? "").trim().replace(/\s+/g, " ");
 }
@@ -41491,34 +41656,34 @@ function normalizeFeatureSlug(value) {
 }
 function resolveFeatureArtifactPaths(slug2, options = {}) {
   const normalizedSlug = normalizeFeatureSlug(slug2);
-  const cwd = path36.resolve(options.cwd ?? process.cwd());
+  const cwd = path38.resolve(options.cwd ?? process.cwd());
   const workspaceRoot2 = findWorkspaceRoot(cwd, true) ?? cwd;
   const outputDir = options.outputDir ?? FEATURE_DEFAULT_OUTPUT_DIR;
-  const root = path36.resolve(workspaceRoot2, outputDir, normalizedSlug);
+  const root = path38.resolve(workspaceRoot2, outputDir, normalizedSlug);
   return {
     root,
-    manifest: path36.join(root, "feature.json"),
-    spec: path36.join(root, "spec.md"),
-    plan: path36.join(root, "plan.md"),
-    tasks: path36.join(root, "tasks.md"),
-    workflowPlan: path36.join(root, "workflow-plan.json")
+    manifest: path38.join(root, "feature.json"),
+    spec: path38.join(root, "spec.md"),
+    plan: path38.join(root, "plan.md"),
+    tasks: path38.join(root, "tasks.md"),
+    workflowPlan: path38.join(root, "workflow-plan.json")
   };
 }
 function readJsonFile4(filePath) {
-  return JSON.parse(fs37.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs39.readFileSync(filePath, "utf8"));
 }
 function writeJsonFile4(filePath, value) {
-  fs37.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+  fs39.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 function ensureParent(filePath) {
-  fs37.mkdirSync(path36.dirname(filePath), { recursive: true });
+  fs39.mkdirSync(path38.dirname(filePath), { recursive: true });
 }
 function assertWritable(filePath, force, allowGeneratedPlaceholder = false) {
-  if (!fs37.existsSync(filePath) || force) {
+  if (!fs39.existsSync(filePath) || force) {
     return;
   }
-  if (allowGeneratedPlaceholder && isGeneratedPlaceholder(fs37.readFileSync(filePath, "utf8"))) {
+  if (allowGeneratedPlaceholder && isGeneratedPlaceholder(fs39.readFileSync(filePath, "utf8"))) {
     return;
   }
   throw new Error(
@@ -41528,7 +41693,7 @@ function assertWritable(filePath, force, allowGeneratedPlaceholder = false) {
 function writeArtifact(filePath, content, force, allowGeneratedPlaceholder = false) {
   assertWritable(filePath, force, allowGeneratedPlaceholder);
   ensureParent(filePath);
-  fs37.writeFileSync(filePath, content.endsWith("\n") ? content : `${content}
+  fs39.writeFileSync(filePath, content.endsWith("\n") ? content : `${content}
 `, "utf8");
 }
 function isGeneratedPlaceholder(content) {
@@ -41556,14 +41721,14 @@ function createManifest(options, paths) {
     },
     status: {
       spec: compact(options.goal).length > 0 ? "ready" : "draft",
-      plan: fs37.existsSync(paths.plan) && !isGeneratedPlaceholder(fs37.readFileSync(paths.plan, "utf8")) ? "ready" : "missing",
-      tasks: fs37.existsSync(paths.tasks) && !isGeneratedPlaceholder(fs37.readFileSync(paths.tasks, "utf8")) ? "ready" : "missing"
+      plan: fs39.existsSync(paths.plan) && !isGeneratedPlaceholder(fs39.readFileSync(paths.plan, "utf8")) ? "ready" : "missing",
+      tasks: fs39.existsSync(paths.tasks) && !isGeneratedPlaceholder(fs39.readFileSync(paths.tasks, "utf8")) ? "ready" : "missing"
     }
   };
 }
 function readManifest3(paths) {
-  if (!fs37.existsSync(paths.manifest)) {
-    throw new Error(`Feature '${path36.basename(paths.root)}' is not initialized at ${paths.root}.`);
+  if (!fs39.existsSync(paths.manifest)) {
+    throw new Error(`Feature '${path38.basename(paths.root)}' is not initialized at ${paths.root}.`);
   }
   const manifest = readJsonFile4(paths.manifest);
   if (manifest.schemaVersion !== FEATURE_WORK_ITEM_VERSION) {
@@ -41783,11 +41948,11 @@ function featureInitCommand(options) {
   if (!normalizedGoal) {
     throw new Error("Feature initialization requires --goal.");
   }
-  if (fs37.existsSync(paths.manifest) && !options.force) {
+  if (fs39.existsSync(paths.manifest) && !options.force) {
     throw new Error(`Feature already exists at ${paths.root}. Use --force to reinitialize it.`);
   }
   const manifest = createManifest(options, paths);
-  fs37.mkdirSync(paths.root, { recursive: true });
+  fs39.mkdirSync(paths.root, { recursive: true });
   writeManifest(paths, manifest);
   writeArtifact(paths.spec, buildFeatureSpecMarkdown(manifest), Boolean(options.force));
   writeArtifact(paths.plan, renderPlanPlaceholder(manifest), Boolean(options.force));
@@ -41803,7 +41968,7 @@ function featureInitCommand(options) {
 }
 function featureSpecifyCommand(options) {
   const paths = resolveFeatureArtifactPaths(options.slug, options);
-  const existing = fs37.existsSync(paths.manifest) ? readManifest3(paths) : void 0;
+  const existing = fs39.existsSync(paths.manifest) ? readManifest3(paths) : void 0;
   const manifest = createManifest(
     {
       ...options,
@@ -41819,10 +41984,10 @@ function featureSpecifyCommand(options) {
   if (!manifest.goal) {
     throw new Error("Feature specification requires --goal when no existing manifest is present.");
   }
-  if (fs37.existsSync(paths.spec) && !options.force && !isGeneratedPlaceholder(fs37.readFileSync(paths.spec, "utf8"))) {
+  if (fs39.existsSync(paths.spec) && !options.force && !isGeneratedPlaceholder(fs39.readFileSync(paths.spec, "utf8"))) {
     throw new Error(`Refusing to overwrite existing specification: ${paths.spec}. Use --force.`);
   }
-  fs37.mkdirSync(paths.root, { recursive: true });
+  fs39.mkdirSync(paths.root, { recursive: true });
   writeArtifact(paths.spec, buildFeatureSpecMarkdown(manifest), Boolean(options.force), true);
   manifest.updatedAt = nowIso2();
   writeManifest(paths, manifest);
@@ -41837,7 +42002,7 @@ function featureSpecifyCommand(options) {
 async function featurePlanCommand(options) {
   const paths = resolveFeatureArtifactPaths(options.slug, options);
   const manifest = readManifest3(paths);
-  if (!fs37.existsSync(paths.spec)) {
+  if (!fs39.existsSync(paths.spec)) {
     throw new Error(`Missing specification: ${paths.spec}`);
   }
   if (!isConfigured({ cwd: options.cwd })) {
@@ -41845,7 +42010,7 @@ async function featurePlanCommand(options) {
       "Hosted planning requires Companion configuration. Run 'snipara-companion init' first."
     );
   }
-  const spec = fs37.readFileSync(paths.spec, "utf8");
+  const spec = fs39.readFileSync(paths.spec, "utf8");
   const query = buildPlanQuery(manifest, spec);
   const result = await createClient(3e4, { cwd: options.cwd }).plan(query, options.maxTokens);
   const quality = validatePlanResult(result, { query, cwd: options.cwd ?? process.cwd() });
@@ -41879,11 +42044,11 @@ async function featurePlanCommand(options) {
 function featureTasksCommand(options) {
   const paths = resolveFeatureArtifactPaths(options.slug, options);
   const manifest = readManifest3(paths);
-  const useLocalPlan = Boolean(options.fromPlan) || !fs37.existsSync(paths.workflowPlan);
-  if (useLocalPlan && (!fs37.existsSync(paths.plan) || isGeneratedPlaceholder(fs37.readFileSync(paths.plan, "utf8")))) {
+  const useLocalPlan = Boolean(options.fromPlan) || !fs39.existsSync(paths.workflowPlan);
+  if (useLocalPlan && (!fs39.existsSync(paths.plan) || isGeneratedPlaceholder(fs39.readFileSync(paths.plan, "utf8")))) {
     throw new Error(`Missing workflow plan: ${paths.workflowPlan}. Run feature plan first.`);
   }
-  const plan = useLocalPlan ? buildLocalWorkflowPlan(manifest, fs37.readFileSync(paths.plan, "utf8")) : readJsonFile4(paths.workflowPlan);
+  const plan = useLocalPlan ? buildLocalWorkflowPlan(manifest, fs39.readFileSync(paths.plan, "utf8")) : readJsonFile4(paths.workflowPlan);
   if (!Array.isArray(plan.steps) || plan.steps.length === 0) {
     throw new Error(`Workflow plan has no executable phases: ${paths.workflowPlan}`);
   }
@@ -41921,7 +42086,7 @@ async function featureStartCommand(options) {
     outputDir: options.outputDir
   });
   const manifest = readManifest3(paths);
-  if (manifest.status.tasks !== "ready" || !fs37.existsSync(paths.tasks)) {
+  if (manifest.status.tasks !== "ready" || !fs39.existsSync(paths.tasks)) {
     throw new Error(
       `Tasks are not ready. Run 'snipara-companion feature tasks ${manifest.slug}' first.`
     );
@@ -41958,9 +42123,9 @@ function featureStatusCommand(options) {
 }
 
 // src/commands/outcome-capture.ts
-var fs38 = __toESM(require("fs"));
-var path37 = __toESM(require("path"));
-var import_node_crypto15 = require("crypto");
+var fs40 = __toESM(require("fs"));
+var path39 = __toESM(require("path"));
+var import_node_crypto17 = require("crypto");
 var WHY_OUTCOME_CAPTURE_VERSION = "snipara.why_outcome_capture.v1";
 var DEFAULT_MAX_CANDIDATES = 20;
 var MAX_EVENTS = 50;
@@ -42040,7 +42205,7 @@ function buildWhyOutcomeCaptureReport(options) {
   };
 }
 async function outcomeCapturePreviewCommand(options) {
-  const rootDir = path37.resolve(options.dir ?? process.cwd());
+  const rootDir = path39.resolve(options.dir ?? process.cwd());
   const workflowFile = typeof options.fromWorkflow === "string" ? options.fromWorkflow : options.fromWorkflow ? ".snipara/workflow/current.json" : void 0;
   const workflow2 = workflowFile ? readWorkflowSnapshot2(rootDir, workflowFile) : void 0;
   const workflowEvents = workflow2 ? buildWorkflowOutcomeEvents(workflow2, rootDir) : [];
@@ -42477,8 +42642,8 @@ function normalizeStringList6(value) {
   return values.flatMap((item) => String(item).split("\n")).map((item) => item.trim()).filter(Boolean).slice(0, MAX_LIST_ITEMS4);
 }
 function readEventsFromFile(filePath, cwd = process.cwd()) {
-  const resolved = path37.resolve(cwd, filePath);
-  const parsed = JSON.parse(fs38.readFileSync(resolved, "utf8"));
+  const resolved = path39.resolve(cwd, filePath);
+  const parsed = JSON.parse(fs40.readFileSync(resolved, "utf8"));
   if (Array.isArray(parsed)) {
     return parsed;
   }
@@ -42495,8 +42660,8 @@ function readEventsFromFile(filePath, cwd = process.cwd()) {
   return [];
 }
 function readWorkflowSnapshot2(rootDir, filePath) {
-  const resolved = path37.resolve(rootDir, filePath);
-  const parsed = JSON.parse(fs38.readFileSync(resolved, "utf8"));
+  const resolved = path39.resolve(rootDir, filePath);
+  const parsed = JSON.parse(fs40.readFileSync(resolved, "utf8"));
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
     throw new Error("Workflow snapshot must be a JSON object.");
   }
@@ -42539,12 +42704,12 @@ function buildWorkflowOutcomeEvents(workflow2, rootDir) {
   });
 }
 function projectRelativeWorkflowFile(value, rootDir) {
-  const absolute = path37.resolve(rootDir, value);
-  const relative15 = path37.relative(rootDir, absolute);
-  if (!relative15 || relative15.startsWith("..") || path37.isAbsolute(relative15)) {
+  const absolute = path39.resolve(rootDir, value);
+  const relative15 = path39.relative(rootDir, absolute);
+  if (!relative15 || relative15.startsWith("..") || path39.isAbsolute(relative15)) {
     return null;
   }
-  return relative15.split(path37.sep).join("/");
+  return relative15.split(path39.sep).join("/");
 }
 function boundedWorkflowValue(value, fallback) {
   if (typeof value !== "string" || !value.trim()) return fallback;
@@ -42554,7 +42719,7 @@ function isRecord23(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
 function stableHash2(parts) {
-  return (0, import_node_crypto15.createHash)("sha256").update(parts.join("\0")).digest("hex");
+  return (0, import_node_crypto17.createHash)("sha256").update(parts.join("\0")).digest("hex");
 }
 function uniqueStrings24(values) {
   return Array.from(new Set(values.filter(Boolean)));
@@ -42998,17 +43163,17 @@ async function realityCheckCommand(options) {
 }
 
 // src/commands/context-control.ts
-var fs40 = __toESM(require("fs"));
-var path39 = __toESM(require("path"));
+var fs42 = __toESM(require("fs"));
+var path41 = __toESM(require("path"));
 var import_node_child_process18 = require("child_process");
 var import_chalk16 = __toESM(require("chalk"));
-var CONTEXT_CONTROL_RELATIVE_DIR = path39.join(".snipara", "context-control");
-var CONTEXT_CONTROL_PLANS_RELATIVE_DIR = path39.join(CONTEXT_CONTROL_RELATIVE_DIR, "plans");
-var CONTEXT_CONTROL_APPLIED_RELATIVE_DIR = path39.join(
+var CONTEXT_CONTROL_RELATIVE_DIR = path41.join(".snipara", "context-control");
+var CONTEXT_CONTROL_PLANS_RELATIVE_DIR = path41.join(CONTEXT_CONTROL_RELATIVE_DIR, "plans");
+var CONTEXT_CONTROL_APPLIED_RELATIVE_DIR = path41.join(
   CONTEXT_CONTROL_RELATIVE_DIR,
   "applied"
 );
-var CONTEXT_CONTROL_STATE_RELATIVE_DIR = path39.join(CONTEXT_CONTROL_RELATIVE_DIR, "state");
+var CONTEXT_CONTROL_STATE_RELATIVE_DIR = path41.join(CONTEXT_CONTROL_RELATIVE_DIR, "state");
 var PROJECT_CONTEXT_MANIFEST_DEFAULT_PATH = "snipara.project-context.json";
 var DEFAULT_PLAN_SUMMARY = "Record local context-control state";
 function runGit4(args, cwd, options = {}) {
@@ -43046,10 +43211,10 @@ function resolveGitDriftScopePaths(cwd) {
   const scopePaths = [
     PROJECT_CONTEXT_MANIFEST_DEFAULT_PATH,
     CONTEXT_CONTROL_RELATIVE_DIR,
-    path39.join(".snipara", "decisions")
+    path41.join(".snipara", "decisions")
   ];
   const manifestPath2 = resolveManifestPath(cwd);
-  if (!fs40.existsSync(manifestPath2)) {
+  if (!fs42.existsSync(manifestPath2)) {
     return normalizeScopePaths(scopePaths, cwd);
   }
   const manifestRead = readJsonFileSafe(manifestPath2);
@@ -43076,16 +43241,16 @@ function slugify2(value) {
   return slug2 || "context-control-state";
 }
 function toProjectRelativePath4(absolutePath, cwd) {
-  const relative15 = path39.relative(cwd, absolutePath);
+  const relative15 = path41.relative(cwd, absolutePath);
   return relative15 && !relative15.startsWith("..") ? relative15 : absolutePath;
 }
 function normalizeProjectRelativePath(filePath, cwd) {
-  const absolute = path39.isAbsolute(filePath) ? filePath : path39.resolve(cwd, filePath);
-  return toProjectRelativePath4(absolute, cwd).split(path39.sep).join("/");
+  const absolute = path41.isAbsolute(filePath) ? filePath : path41.resolve(cwd, filePath);
+  return toProjectRelativePath4(absolute, cwd).split(path41.sep).join("/");
 }
 function assertContextControlTarget(target, cwd) {
   const relative15 = normalizeProjectRelativePath(target, cwd);
-  if (path39.isAbsolute(relative15) || relative15.startsWith("../") || relative15 === ".." || !relative15.startsWith(".snipara/context-control/")) {
+  if (path41.isAbsolute(relative15) || relative15.startsWith("../") || relative15 === ".." || !relative15.startsWith(".snipara/context-control/")) {
     throw new Error(
       `Context-control apply can only write under ${CONTEXT_CONTROL_RELATIVE_DIR}; got ${target}`
     );
@@ -43093,18 +43258,18 @@ function assertContextControlTarget(target, cwd) {
   return relative15;
 }
 function defaultTargetPath(summary) {
-  return path39.join(CONTEXT_CONTROL_STATE_RELATIVE_DIR, `${slugify2(summary)}.json`);
+  return path41.join(CONTEXT_CONTROL_STATE_RELATIVE_DIR, `${slugify2(summary)}.json`);
 }
 function receiptPathFor(receipt, cwd) {
-  return path39.resolve(cwd, CONTEXT_CONTROL_APPLIED_RELATIVE_DIR, `${receipt.receiptId}.json`);
+  return path41.resolve(cwd, CONTEXT_CONTROL_APPLIED_RELATIVE_DIR, `${receipt.receiptId}.json`);
 }
 function writeStableJsonFile(filePath, value) {
-  fs40.mkdirSync(path39.dirname(filePath), { recursive: true });
-  fs40.writeFileSync(filePath, `${stableDecisionJsonStringify(value)}
+  fs42.mkdirSync(path41.dirname(filePath), { recursive: true });
+  fs42.writeFileSync(filePath, `${stableDecisionJsonStringify(value)}
 `, "utf8");
 }
 function readJsonFile5(filePath) {
-  return JSON.parse(fs40.readFileSync(filePath, "utf8"));
+  return JSON.parse(fs42.readFileSync(filePath, "utf8"));
 }
 function buildStateOperation(options) {
   const target = assertContextControlTarget(
@@ -43128,10 +43293,10 @@ function buildStateOperation(options) {
   };
 }
 function resolveManifestPath(cwd, manifest) {
-  return path39.resolve(cwd, manifest ?? PROJECT_CONTEXT_MANIFEST_DEFAULT_PATH);
+  return path41.resolve(cwd, manifest ?? PROJECT_CONTEXT_MANIFEST_DEFAULT_PATH);
 }
 function buildLocalProjectContextValidationReport(options = {}) {
-  const cwd = path39.resolve(options.cwd ?? process.cwd());
+  const cwd = path41.resolve(options.cwd ?? process.cwd());
   const manifestPath2 = resolveManifestPath(cwd, options.manifest);
   const manifest = readJsonFile5(manifestPath2);
   return validateProjectContextManifest({
@@ -43142,7 +43307,7 @@ function buildLocalProjectContextValidationReport(options = {}) {
 function buildManifestOperation(options) {
   const relativeManifestPath = toProjectRelativePath4(options.manifestPath, options.cwd);
   const target = assertContextControlTarget(
-    options.target ?? path39.join(CONTEXT_CONTROL_STATE_RELATIVE_DIR, "project-context-manifest.json"),
+    options.target ?? path41.join(CONTEXT_CONTROL_STATE_RELATIVE_DIR, "project-context-manifest.json"),
     options.cwd
   );
   return {
@@ -43161,7 +43326,7 @@ function buildManifestOperation(options) {
   };
 }
 function buildLocalContextMutationPlan(options = {}) {
-  const cwd = path39.resolve(options.cwd ?? process.cwd());
+  const cwd = path41.resolve(options.cwd ?? process.cwd());
   const now = options.now ?? /* @__PURE__ */ new Date();
   const manifestPath2 = options.manifest ? resolveManifestPath(cwd, options.manifest) : void 0;
   const validation = manifestPath2 ? buildLocalProjectContextValidationReport({ cwd, manifest: manifestPath2, now }) : void 0;
@@ -43208,15 +43373,15 @@ function buildLocalContextMutationPlan(options = {}) {
     approvalRequired: options.approvalRequired ?? true,
     expiresAt: options.expiresAt
   });
-  const planPath = options.output ? path39.resolve(cwd, options.output) : void 0;
+  const planPath = options.output ? path41.resolve(cwd, options.output) : void 0;
   if (planPath) {
     writeStableJsonFile(planPath, plan);
   }
   return { plan, ...planPath ? { planPath } : {} };
 }
 function applyLocalContextMutationPlan(options) {
-  const cwd = path39.resolve(options.cwd ?? process.cwd());
-  const planPath = path39.resolve(cwd, options.plan);
+  const cwd = path41.resolve(options.cwd ?? process.cwd());
+  const planPath = path41.resolve(cwd, options.plan);
   const rawPlan = readJsonFile5(planPath);
   if (!isContextMutationPlan(rawPlan)) {
     throw new Error(`Invalid context mutation plan: ${options.plan}`);
@@ -43296,7 +43461,7 @@ function applyLocalContextMutationPlan(options) {
     baseRevisionAtApply: currentRevision
   });
   const receiptPath = receiptPathFor(pendingReceipt, cwd);
-  if (fs40.existsSync(receiptPath)) {
+  if (fs42.existsSync(receiptPath)) {
     const receipt2 = buildContextMutationApplyReceipt({
       plan,
       appliedAt: options.now,
@@ -43333,8 +43498,8 @@ function applyLocalContextMutationPlan(options) {
       });
       continue;
     }
-    const absoluteTarget = path39.resolve(cwd, target);
-    if (operation.mode === "create" && fs40.existsSync(absoluteTarget)) {
+    const absoluteTarget = path41.resolve(cwd, target);
+    if (operation.mode === "create" && fs42.existsSync(absoluteTarget)) {
       throw new Error(`Refusing to overwrite existing context-control file: ${target}`);
     }
     writeStableJsonFile(absoluteTarget, operation.content ?? {});
@@ -43368,8 +43533,8 @@ function applyLocalContextMutationPlan(options) {
   };
 }
 function listJsonFiles2(dir) {
-  if (!fs40.existsSync(dir)) return [];
-  return fs40.readdirSync(dir).filter((name) => name.endsWith(".json")).map((name) => path39.join(dir, name)).sort((left, right) => left.localeCompare(right));
+  if (!fs42.existsSync(dir)) return [];
+  return fs42.readdirSync(dir).filter((name) => name.endsWith(".json")).map((name) => path41.join(dir, name)).sort((left, right) => left.localeCompare(right));
 }
 function readJsonFileSafe(filePath) {
   try {
@@ -43447,8 +43612,8 @@ function collectGitDriftSignals(cwd) {
   return [dirtySignal, upstreamSignal];
 }
 function collectWorkflowDriftSignals(cwd) {
-  const workflowPath = path39.join(cwd, ".snipara", "workflow", "current.json");
-  if (!fs40.existsSync(workflowPath)) {
+  const workflowPath = path41.join(cwd, ".snipara", "workflow", "current.json");
+  if (!fs42.existsSync(workflowPath)) {
     return [
       {
         id: "workflow-state-missing",
@@ -43493,7 +43658,7 @@ function collectWorkflowDriftSignals(cwd) {
   ];
 }
 function collectDecisionDriftSignals(cwd) {
-  const pendingDir = path39.join(cwd, ".snipara", "decisions", "pending");
+  const pendingDir = path41.join(cwd, ".snipara", "decisions", "pending");
   const pending = listJsonFiles2(pendingDir).map((file) => toProjectRelativePath4(file, cwd));
   return [
     pending.length > 0 ? {
@@ -43518,8 +43683,8 @@ function collectDecisionDriftSignals(cwd) {
   ];
 }
 function collectContextControlDriftSignals(cwd) {
-  const planFiles = listJsonFiles2(path39.join(cwd, CONTEXT_CONTROL_PLANS_RELATIVE_DIR));
-  const receiptFiles = listJsonFiles2(path39.join(cwd, CONTEXT_CONTROL_APPLIED_RELATIVE_DIR));
+  const planFiles = listJsonFiles2(path41.join(cwd, CONTEXT_CONTROL_PLANS_RELATIVE_DIR));
+  const receiptFiles = listJsonFiles2(path41.join(cwd, CONTEXT_CONTROL_APPLIED_RELATIVE_DIR));
   const receiptPlanHashes = new Set(
     receiptFiles.map((file) => readJsonFileSafe(file).value).filter(isContextMutationApplyReceipt).map((receipt) => receipt.planHash)
   );
@@ -43542,7 +43707,7 @@ function collectContextControlDriftSignals(cwd) {
     const read = readJsonFileSafe(file);
     if (!read.value || !isContextMutationPlan(read.value)) {
       return {
-        id: `context-control-plan-invalid-${path39.basename(file, ".json")}`,
+        id: `context-control-plan-invalid-${path41.basename(file, ".json")}`,
         surface: "context_control",
         state: "UNKNOWN",
         summary: "A saved context mutation plan is invalid or unreadable.",
@@ -43591,7 +43756,7 @@ function collectContextControlDriftSignals(cwd) {
 function collectProjectContextManifestDriftSignals(cwd) {
   const manifestPath2 = resolveManifestPath(cwd);
   const relative15 = toProjectRelativePath4(manifestPath2, cwd);
-  if (!fs40.existsSync(manifestPath2)) {
+  if (!fs42.existsSync(manifestPath2)) {
     return [
       {
         id: "project-context-manifest-missing",
@@ -43647,7 +43812,7 @@ function collectProjectContextManifestDriftSignals(cwd) {
   ];
 }
 function buildLocalProjectDriftReport(options = {}) {
-  const cwd = path39.resolve(options.cwd ?? process.cwd());
+  const cwd = path41.resolve(options.cwd ?? process.cwd());
   return buildProjectDriftReport({
     generatedAt: options.now,
     signals: [
@@ -43794,23 +43959,23 @@ function resolveHostedContextSources(cwd, manifestPath2, report) {
   if (!report.manifest || report.status === "invalid") {
     throw new Error("ProjectContext manifest is invalid; run context-control validate first.");
   }
-  const workspaceRoot2 = fs40.realpathSync(cwd);
+  const workspaceRoot2 = fs42.realpathSync(cwd);
   return report.manifest.sources.map((source2) => {
-    const candidate = path39.resolve(cwd, source2.path);
-    if (!fs40.existsSync(candidate)) {
+    const candidate = path41.resolve(cwd, source2.path);
+    if (!fs42.existsSync(candidate)) {
       throw new Error(`ProjectContext source is missing: ${source2.path}`);
     }
-    if (fs40.lstatSync(candidate).isSymbolicLink()) {
+    if (fs42.lstatSync(candidate).isSymbolicLink()) {
       throw new Error(`ProjectContext source symlinks are not allowed: ${source2.path}`);
     }
-    const canonical = fs40.realpathSync(candidate);
-    if (canonical !== workspaceRoot2 && !canonical.startsWith(`${workspaceRoot2}${path39.sep}`)) {
+    const canonical = fs42.realpathSync(candidate);
+    if (canonical !== workspaceRoot2 && !canonical.startsWith(`${workspaceRoot2}${path41.sep}`)) {
       throw new Error(`ProjectContext source escapes the workspace: ${source2.path}`);
     }
-    if (!fs40.statSync(canonical).isFile()) {
+    if (!fs42.statSync(canonical).isFile()) {
       throw new Error(`ProjectContext source must be a file: ${source2.path}`);
     }
-    const content = fs40.readFileSync(canonical, "utf8");
+    const content = fs42.readFileSync(canonical, "utf8");
     if (Buffer.byteLength(content, "utf8") > 1e6) {
       throw new Error(`ProjectContext source exceeds 1 MB: ${source2.path}`);
     }
@@ -43831,7 +43996,7 @@ async function contextControlHostedDiffCommand(options) {
     plan: response.plan
   };
   if (options.output) {
-    const planPath = path39.resolve(cwd, options.output);
+    const planPath = path41.resolve(cwd, options.output);
     writeStableJsonFile(planPath, response.plan);
     result.planPath = toProjectRelativePath4(planPath, cwd);
   }
@@ -43903,11 +44068,11 @@ async function contextControlHostedDiffCommand(options) {
 }
 async function contextControlHostedApplyCommand(options) {
   const cwd = process.cwd();
-  const rawPlan = readJsonFile5(path39.resolve(cwd, options.plan));
+  const rawPlan = readJsonFile5(path41.resolve(cwd, options.plan));
   if (!isHostedContextControlPlan(rawPlan)) {
     throw new Error(`Invalid hosted Context Control plan: ${options.plan}`);
   }
-  const approval = options.approval ? readJsonFile5(path39.resolve(cwd, options.approval)) : void 0;
+  const approval = options.approval ? readJsonFile5(path41.resolve(cwd, options.approval)) : void 0;
   const response = await createClient(12e4, { cwd }).applyHostedContextControl({
     plan: rawPlan,
     approval
@@ -43920,7 +44085,7 @@ async function contextControlHostedApplyCommand(options) {
     receipt: response.receipt
   };
   if (options.output) {
-    const receiptPath = path39.resolve(cwd, options.output);
+    const receiptPath = path41.resolve(cwd, options.output);
     writeStableJsonFile(receiptPath, response.receipt);
     result.receiptPath = toProjectRelativePath4(receiptPath, cwd);
   }
@@ -43944,16 +44109,16 @@ function uniqueStrings25(values) {
 }
 
 // src/commands/agent-context-evidence.ts
-var fs41 = __toESM(require("fs"));
-var path40 = __toESM(require("path"));
-var AGENT_CONTEXT_EVIDENCE_DEFAULT_LEDGER = path40.join(
+var fs43 = __toESM(require("fs"));
+var path42 = __toESM(require("path"));
+var AGENT_CONTEXT_EVIDENCE_DEFAULT_LEDGER = path42.join(
   ".snipara",
   "agent-context",
   "evidence.jsonl"
 );
 function readJson(filePath, label) {
   try {
-    return JSON.parse(fs41.readFileSync(filePath, "utf8"));
+    return JSON.parse(fs43.readFileSync(filePath, "utf8"));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Unable to read ${label} ${filePath}: ${message}`);
@@ -43961,7 +44126,7 @@ function readJson(filePath, label) {
 }
 function readManifest4(cwd, candidate) {
   return readJson(
-    path40.resolve(cwd, candidate ?? AGENT_CONTEXT_MANIFEST_DEFAULT_PATH),
+    path42.resolve(cwd, candidate ?? AGENT_CONTEXT_MANIFEST_DEFAULT_PATH),
     "Agent Context manifest"
   );
 }
@@ -43979,8 +44144,8 @@ function receiptHash(receipt) {
   return hashDecisionJsonValue(base);
 }
 function readAgentContextEvidenceLedger(ledgerPath) {
-  if (!fs41.existsSync(ledgerPath)) return [];
-  const content = fs41.readFileSync(ledgerPath, "utf8").trim();
+  if (!fs43.existsSync(ledgerPath)) return [];
+  const content = fs43.readFileSync(ledgerPath, "utf8").trim();
   if (!content) return [];
   return content.split("\n").map((line, index) => {
     let candidate;
@@ -44006,23 +44171,23 @@ function writeJsonOutput(value, outputPath, force = false) {
     console.log(content.trimEnd());
     return void 0;
   }
-  if (fs41.existsSync(outputPath) && !force) {
+  if (fs43.existsSync(outputPath) && !force) {
     throw new Error(
       `Refusing to overwrite existing file ${outputPath}; pass --force to replace it.`
     );
   }
-  fs41.mkdirSync(path40.dirname(outputPath), { recursive: true });
-  fs41.writeFileSync(outputPath, content, "utf8");
+  fs43.mkdirSync(path42.dirname(outputPath), { recursive: true });
+  fs43.writeFileSync(outputPath, content, "utf8");
   return outputPath;
 }
 function safeWorkflowReference(value, cwd) {
   if (typeof value !== "string" || !value.trim()) return void 0;
   const candidate = value.trim();
   if (/^[a-z][a-z0-9+.-]*:\/\//i.test(candidate)) return candidate;
-  const absolute = path40.isAbsolute(candidate) ? candidate : path40.resolve(cwd, candidate);
-  const relative15 = path40.relative(cwd, absolute);
-  if (!relative15 || relative15.startsWith("..") || path40.isAbsolute(relative15)) return void 0;
-  return relative15.replaceAll(path40.sep, "/");
+  const absolute = path42.isAbsolute(candidate) ? candidate : path42.resolve(cwd, candidate);
+  const relative15 = path42.relative(cwd, absolute);
+  if (!relative15 || relative15.startsWith("..") || path42.isAbsolute(relative15)) return void 0;
+  return relative15.replaceAll(path42.sep, "/");
 }
 function collectWorkflowProofRefs(workflow2, cwd) {
   if (!workflow2 || typeof workflow2 !== "object" || Array.isArray(workflow2)) {
@@ -44115,7 +44280,7 @@ function formatStatus(report, ledgerPath) {
   return lines.join("\n");
 }
 async function agentContextEvidenceTemplateCommand(options) {
-  const cwd = path40.resolve(options.cwd ?? process.cwd());
+  const cwd = path42.resolve(options.cwd ?? process.cwd());
   const manifest = validatedManifest(cwd, options.manifest);
   const resolution = resolveAgentContext({
     manifest,
@@ -44123,19 +44288,19 @@ async function agentContextEvidenceTemplateCommand(options) {
     task: options.task
   });
   const template = buildAgentContextEvidenceTemplate(resolution);
-  const outputPath = options.output ? path40.resolve(cwd, options.output) : void 0;
+  const outputPath = options.output ? path42.resolve(cwd, options.output) : void 0;
   const written = writeJsonOutput(template, outputPath, Boolean(options.force));
   if (written && !options.json) {
-    console.log(`Wrote AC-1 evidence template: ${path40.relative(cwd, written)}`);
+    console.log(`Wrote AC-1 evidence template: ${path42.relative(cwd, written)}`);
     console.log("Complete the task evidence and proofRefs before recording it.");
   }
 }
 async function agentContextEvidenceCollectCommand(options) {
-  const cwd = path40.resolve(options.cwd ?? process.cwd());
+  const cwd = path42.resolve(options.cwd ?? process.cwd());
   const manifest = validatedManifest(cwd, options.manifest);
-  const workflowPath = path40.resolve(
+  const workflowPath = path42.resolve(
     cwd,
-    options.workflow ?? path40.join(".snipara", "workflow", "current.json")
+    options.workflow ?? path42.join(".snipara", "workflow", "current.json")
   );
   const workflow2 = readJson(workflowPath, "workflow state");
   const workflowGoal = workflow2 && typeof workflow2 === "object" && !Array.isArray(workflow2) ? workflow2.goal : void 0;
@@ -44145,19 +44310,19 @@ async function agentContextEvidenceCollectCommand(options) {
   }
   const resolution = resolveAgentContext({ manifest, agent: options.agent, task });
   const draft = workflowDraftEvidence(buildAgentContextEvidenceTemplate(resolution), workflow2, cwd);
-  const outputPath = options.output ? path40.resolve(cwd, options.output) : void 0;
+  const outputPath = options.output ? path42.resolve(cwd, options.output) : void 0;
   const written = writeJsonOutput(draft, outputPath, Boolean(options.force));
   if (written && !options.json) {
-    console.log(`Wrote AC-1 evidence draft from workflow: ${path40.relative(cwd, written)}`);
+    console.log(`Wrote AC-1 evidence draft from workflow: ${path42.relative(cwd, written)}`);
     console.log(
       "Review usedSourceIds, executedRecallKeys, contextEffect, and capabilityAssessment before recording it."
     );
   }
 }
 async function agentContextEvidenceRecordCommand(options) {
-  const cwd = path40.resolve(options.cwd ?? process.cwd());
+  const cwd = path42.resolve(options.cwd ?? process.cwd());
   const manifest = validatedManifest(cwd, options.manifest);
-  const evidencePath = path40.resolve(cwd, options.from);
+  const evidencePath = path42.resolve(cwd, options.from);
   const evidence = readJson(evidencePath, "AC-1 evidence input");
   if (!evidence || typeof evidence !== "object" || Array.isArray(evidence)) {
     throw new Error("AC-1 evidence input must be a JSON object.");
@@ -44169,25 +44334,25 @@ async function agentContextEvidenceRecordCommand(options) {
   }
   const resolution = resolveAgentContext({ manifest, agent, task });
   const receipt = buildAgentContextEvidenceReceipt({ resolution, evidence });
-  const ledgerPath = path40.resolve(cwd, options.ledger ?? AGENT_CONTEXT_EVIDENCE_DEFAULT_LEDGER);
+  const ledgerPath = path42.resolve(cwd, options.ledger ?? AGENT_CONTEXT_EVIDENCE_DEFAULT_LEDGER);
   const existing = readAgentContextEvidenceLedger(ledgerPath);
   if (existing.some((candidate) => candidate.taskId === receipt.taskId)) {
     throw new Error(`Evidence taskId already exists in the ledger: ${receipt.taskId}.`);
   }
-  fs41.mkdirSync(path40.dirname(ledgerPath), { recursive: true });
-  fs41.appendFileSync(ledgerPath, `${JSON.stringify(receipt)}
+  fs43.mkdirSync(path42.dirname(ledgerPath), { recursive: true });
+  fs43.appendFileSync(ledgerPath, `${JSON.stringify(receipt)}
 `, "utf8");
   if (options.json) {
     console.log(JSON.stringify(receipt, null, 2));
   } else {
     console.log(`Recorded AC-1 evidence: ${receipt.taskId}`);
-    console.log(`Ledger: ${path40.relative(cwd, ledgerPath)}`);
+    console.log(`Ledger: ${path42.relative(cwd, ledgerPath)}`);
     console.log(`Receipt: ${receipt.receiptHash}`);
   }
   return receipt;
 }
 async function agentContextEvidenceStatusCommand(options = {}) {
-  const cwd = path40.resolve(options.cwd ?? process.cwd());
+  const cwd = path42.resolve(options.cwd ?? process.cwd());
   const validation = buildLocalAgentContextValidationReport({
     cwd,
     manifest: readManifest4(cwd, options.manifest)
@@ -44197,7 +44362,7 @@ async function agentContextEvidenceStatusCommand(options = {}) {
     throw new Error(`Invalid Agent Context manifest. ${errors}`.trim());
   }
   const manifest = validation.manifest;
-  const ledgerPath = path40.resolve(cwd, options.ledger ?? AGENT_CONTEXT_EVIDENCE_DEFAULT_LEDGER);
+  const ledgerPath = path42.resolve(cwd, options.ledger ?? AGENT_CONTEXT_EVIDENCE_DEFAULT_LEDGER);
   const receipts = readAgentContextEvidenceLedger(ledgerPath);
   const report = buildAgentContextEvidenceReport({
     receipts,
@@ -44205,7 +44370,7 @@ async function agentContextEvidenceStatusCommand(options = {}) {
     manifestHash: validation.manifestHash
   });
   console.log(
-    options.json ? JSON.stringify(report, null, 2) : formatStatus(report, path40.relative(cwd, ledgerPath))
+    options.json ? JSON.stringify(report, null, 2) : formatStatus(report, path42.relative(cwd, ledgerPath))
   );
   if (options.enforce && report.status !== "ready") process.exitCode = 1;
   return report;
@@ -44213,12 +44378,12 @@ async function agentContextEvidenceStatusCommand(options = {}) {
 
 // src/commands/references.ts
 var crypto7 = __toESM(require("crypto"));
-var fs42 = __toESM(require("fs"));
-var path41 = __toESM(require("path"));
+var fs44 = __toESM(require("fs"));
+var path43 = __toESM(require("path"));
 var import_chalk17 = __toESM(require("chalk"));
 var MANIFEST_VERSION2 = "snipara.references.v1";
-var DEFAULT_MANIFEST_PATH = path41.join(".snipara", "references", "manifest.json");
-var DEFAULT_SNAPSHOT_DIR = path41.join(".snipara", "references", "snapshots");
+var DEFAULT_MANIFEST_PATH = path43.join(".snipara", "references", "manifest.json");
+var DEFAULT_SNAPSHOT_DIR = path43.join(".snipara", "references", "snapshots");
 var DEFAULT_DESTINATION_PREFIX = "external-references";
 var DEFAULT_SCAN_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".txt", ".rst"]);
 var DEFAULT_IGNORE_DIRS = /* @__PURE__ */ new Set([
@@ -44294,27 +44459,27 @@ function sanitizeSegment(value, fallback) {
   return sanitized || fallback;
 }
 function toRelative(root, file) {
-  return path41.relative(root, file).split(path41.sep).join("/");
+  return path43.relative(root, file).split(path43.sep).join("/");
 }
 function ensureParentDir(file) {
-  fs42.mkdirSync(path41.dirname(file), { recursive: true });
+  fs44.mkdirSync(path43.dirname(file), { recursive: true });
 }
 function walkFiles(root, extensions, maxFiles, files = []) {
   if (files.length >= maxFiles) {
     return files;
   }
-  for (const entry of fs42.readdirSync(root, { withFileTypes: true })) {
+  for (const entry of fs44.readdirSync(root, { withFileTypes: true })) {
     if (files.length >= maxFiles) {
       break;
     }
-    const fullPath = path41.join(root, entry.name);
+    const fullPath = path43.join(root, entry.name);
     if (entry.isDirectory()) {
       if (!DEFAULT_IGNORE_DIRS.has(entry.name)) {
         walkFiles(fullPath, extensions, maxFiles, files);
       }
       continue;
     }
-    if (entry.isFile() && extensions.has(path41.extname(entry.name).toLowerCase())) {
+    if (entry.isFile() && extensions.has(path43.extname(entry.name).toLowerCase())) {
       files.push(fullPath);
     }
   }
@@ -44324,7 +44489,7 @@ function collectReferenceItems(root, files, allowDomains, denyDomains) {
   const byUrl = /* @__PURE__ */ new Map();
   const discoveredAt = (/* @__PURE__ */ new Date()).toISOString();
   for (const file of files) {
-    const content = fs42.readFileSync(file, "utf-8");
+    const content = fs44.readFileSync(file, "utf-8");
     const lines = content.split(/\r?\n/);
     const markdownLink = /\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g;
     const bareUrl = /https?:\/\/[^\s<>"'`]+/g;
@@ -44369,8 +44534,8 @@ function collectReferenceItems(root, files, allowDomains, denyDomains) {
   return Array.from(byUrl.values()).sort((a, b) => a.normalizedUrl.localeCompare(b.normalizedUrl));
 }
 function scanReferences(options = {}) {
-  const root = path41.resolve(options.root ?? process.cwd());
-  const outputPath = path41.resolve(root, options.output ?? DEFAULT_MANIFEST_PATH);
+  const root = path43.resolve(options.root ?? process.cwd());
+  const outputPath = path43.resolve(root, options.output ?? DEFAULT_MANIFEST_PATH);
   const allowDomains = normalizeList(options.allowDomain);
   const denyDomains = normalizeList(options.denyDomain);
   const extensions = new Set(
@@ -44390,7 +44555,7 @@ function scanReferences(options = {}) {
     items
   };
   ensureParentDir(outputPath);
-  fs42.writeFileSync(outputPath, `${JSON.stringify(manifest, null, 2)}
+  fs44.writeFileSync(outputPath, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
   return {
     manifest,
@@ -44404,7 +44569,7 @@ function scanReferences(options = {}) {
   };
 }
 function readManifest5(file) {
-  const manifest = JSON.parse(fs42.readFileSync(file, "utf-8"));
+  const manifest = JSON.parse(fs44.readFileSync(file, "utf-8"));
   if (manifest.version !== MANIFEST_VERSION2 || !Array.isArray(manifest.items)) {
     throw new Error(`${file} is not a ${MANIFEST_VERSION2} manifest`);
   }
@@ -44472,8 +44637,8 @@ async function fetchReference(item, outputDir, destinationPrefix, timeoutMs, max
       slugSource,
       item.id
     )}-${item.id}.md`;
-    const snapshotPath = path41.resolve(outputDir, fileName);
-    const destinationPath = path41.posix.join(
+    const snapshotPath = path43.resolve(outputDir, fileName);
+    const destinationPath = path43.posix.join(
       destinationPrefix.replace(/^\/+|\/+$/g, "") || DEFAULT_DESTINATION_PREFIX,
       fileName
     );
@@ -44489,7 +44654,7 @@ async function fetchReference(item, outputDir, destinationPrefix, timeoutMs, max
       bodyHash: hash
     });
     ensureParentDir(snapshotPath);
-    fs42.writeFileSync(snapshotPath, markdown, "utf-8");
+    fs44.writeFileSync(snapshotPath, markdown, "utf-8");
     return {
       item,
       fetchedAt,
@@ -44518,14 +44683,14 @@ function selectItems(manifest, options, allowDomains) {
   return typeof options.max === "number" && options.max > 0 ? selected.slice(0, options.max) : selected;
 }
 async function ingestReferences(options = {}) {
-  const manifestPath2 = path41.resolve(options.manifest ?? DEFAULT_MANIFEST_PATH);
+  const manifestPath2 = path43.resolve(options.manifest ?? DEFAULT_MANIFEST_PATH);
   const manifest = readManifest5(manifestPath2);
-  const root = manifest.root ? path41.resolve(manifest.root) : process.cwd();
+  const root = manifest.root ? path43.resolve(manifest.root) : process.cwd();
   const allowDomains = normalizeList([
     ...manifest.allowDomains ?? [],
     ...options.allowDomain ?? []
   ]);
-  const outputDir = path41.resolve(root, options.outputDir ?? DEFAULT_SNAPSHOT_DIR);
+  const outputDir = path43.resolve(root, options.outputDir ?? DEFAULT_SNAPSHOT_DIR);
   const destinationPrefix = options.destinationPrefix ?? DEFAULT_DESTINATION_PREFIX;
   const items = selectItems(manifest, options, allowDomains);
   const summary = {
@@ -44552,7 +44717,7 @@ async function ingestReferences(options = {}) {
         options.maxBytes ?? 512 * 1024
       );
       summary.fetched += 1;
-      item.latestSnapshotPath = path41.relative(root, snapshot.snapshotPath).split(path41.sep).join("/");
+      item.latestSnapshotPath = path43.relative(root, snapshot.snapshotPath).split(path43.sep).join("/");
       item.latestFetchStatus = snapshot.status;
       item.latestFetchAt = snapshot.fetchedAt;
       item.latestContentHash = snapshot.contentHash;
@@ -44599,7 +44764,7 @@ async function ingestReferences(options = {}) {
       });
     }
   }
-  fs42.writeFileSync(manifestPath2, `${JSON.stringify(manifest, null, 2)}
+  fs44.writeFileSync(manifestPath2, `${JSON.stringify(manifest, null, 2)}
 `, "utf-8");
   if (options.reindex && client) {
     await client.reindex({ kind: "doc", mode: "incremental" });
@@ -44651,8 +44816,8 @@ async function referencesIngestCommand(options) {
 }
 
 // src/commands/policy-ledger-sync.ts
-var fs43 = __toESM(require("fs"));
-var path42 = __toESM(require("path"));
+var fs45 = __toESM(require("fs"));
+var path44 = __toESM(require("path"));
 var POLICY_LEDGER_SYNC_REPORT_VERSION = "snipara.workflow_policy_ledger_sync.v0";
 function buildPolicyLedgerSyncReport(options = {}) {
   const cwd = options.cwd ?? process.cwd();
@@ -44719,7 +44884,7 @@ function collectPolicyLedgerSyncArtifacts(cwd = process.cwd()) {
       applyState: applyItem?.state ?? "manual_follow_up_required",
       humanChoice: record2.response.choice,
       summary: record2.request.evidence.summary,
-      sourcePath: path42.join(
+      sourcePath: path44.join(
         ".snipara",
         "decisions",
         "resolved",
@@ -44729,10 +44894,10 @@ function collectPolicyLedgerSyncArtifacts(cwd = process.cwd()) {
       payload: record2
     };
   });
-  const applyArtifacts = readJsonFiles(path42.join(cwd, DECISION_APPLY_RELATIVE_DIR), cwd).map(
+  const applyArtifacts = readJsonFiles(path44.join(cwd, DECISION_APPLY_RELATIVE_DIR), cwd).map(
     ({ parsed, relativePath: relativePath2 }) => ({
       kind: "apply_receipt",
-      requestId: stringField(parsed, "requestId") ?? path42.basename(relativePath2, ".json"),
+      requestId: stringField(parsed, "requestId") ?? path44.basename(relativePath2, ".json"),
       fingerprint: stringField(parsed, "fingerprint"),
       title: stringField(parsed, "question") ?? stringField(parsed, "decision") ?? "Applied decision",
       status: statusForChoiceClass(stringField(parsed, "choiceClass")),
@@ -44744,10 +44909,10 @@ function collectPolicyLedgerSyncArtifacts(cwd = process.cwd()) {
       payload: parsed
     })
   );
-  const draftArtifacts = readJsonFiles(path42.join(cwd, POLICY_DRAFT_RELATIVE_DIR), cwd).map(
+  const draftArtifacts = readJsonFiles(path44.join(cwd, POLICY_DRAFT_RELATIVE_DIR), cwd).map(
     ({ parsed, relativePath: relativePath2 }) => ({
       kind: "policy_draft",
-      requestId: stringField(parsed, "requestId") ?? path42.basename(relativePath2, ".json"),
+      requestId: stringField(parsed, "requestId") ?? path44.basename(relativePath2, ".json"),
       fingerprint: stringField(parsed, "fingerprint"),
       title: stringField(parsed, "title") ?? "Policy draft",
       status: "modified",
@@ -44799,12 +44964,12 @@ function statusForChoiceClass(choiceClass) {
   return "modified";
 }
 function readJsonFiles(directory, cwd) {
-  if (!fs43.existsSync(directory)) {
+  if (!fs45.existsSync(directory)) {
     return [];
   }
-  return fs43.readdirSync(directory).filter((fileName) => fileName.endsWith(".json")).sort().map((fileName) => {
-    const filePath = path42.join(directory, fileName);
-    const parsed = JSON.parse(fs43.readFileSync(filePath, "utf8"));
+  return fs45.readdirSync(directory).filter((fileName) => fileName.endsWith(".json")).sort().map((fileName) => {
+    const filePath = path44.join(directory, fileName);
+    const parsed = JSON.parse(fs45.readFileSync(filePath, "utf8"));
     return { parsed, relativePath: toProjectRelativePath5(filePath, cwd) };
   });
 }
@@ -44813,8 +44978,8 @@ function stringField(value, key) {
   return typeof field === "string" && field.trim() ? field : void 0;
 }
 function toProjectRelativePath5(absolutePath, cwd) {
-  const relative15 = path42.relative(cwd, absolutePath).replace(/\\/g, "/");
-  return relative15.startsWith(".") ? relative15 : `.${path42.sep}${relative15}`.replace(/\\/g, "/");
+  const relative15 = path44.relative(cwd, absolutePath).replace(/\\/g, "/");
+  return relative15.startsWith(".") ? relative15 : `.${path44.sep}${relative15}`.replace(/\\/g, "/");
 }
 
 // src/commands/htask.ts
@@ -45399,8 +45564,24 @@ program.command("post-tool").description("Track file access (PostToolUse hook)")
     packResult: Boolean(options.packResult)
   });
 });
-program.command("session-end").description("Persist session context (Stop hook)").action(async () => {
-  await sessionEndCommand();
+program.command("session-end").description("Persist a session checkpoint with a verifiable journal receipt (Stop hook)").option("--summary <summary>", "Bounded session summary to preserve").option("--summary-stdin", "Read the session summary from stdin").option("--files <files...>", "Files represented by this checkpoint").option("--session-id <sessionId>", "Host session id; do not rotate the workspace session").option("--retry <receipt>", "Retry a retained local checkpoint receipt").option("--json", "Print the persistence receipt as JSON").action(async (options) => {
+  if (options.retry && (options.summary || options.summaryStdin || options.files)) {
+    throw new Error("--retry cannot be combined with new checkpoint content");
+  }
+  let summary = options.summary;
+  if (options.summaryStdin) {
+    if (summary !== void 0) throw new Error("Choose --summary or --summary-stdin");
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of process.stdin) {
+      const buffer = Buffer.from(chunk);
+      bytes += buffer.length;
+      if (bytes > 128e3) throw new Error("Session summary exceeds 128000 bytes");
+      chunks.push(buffer);
+    }
+    summary = Buffer.concat(chunks).toString("utf8");
+  }
+  await sessionEndCommand({ ...options, summary });
 });
 program.command("session").description("Session management").addCommand(
   new import_commander.Command("status").description("Show session status").action(async () => {