@mrciphersmith/keryx 0.2.74 → 0.2.76

package/dist/cli.js

@@ -11214,9 +11214,9 @@ function resolvePointer(doc, fragment) {
   if (!fragment.startsWith("/")) {
     throw new Error(`Unsupported JSON Pointer fragment (must start with "/"): ${fragment}`);
   }
-  const segments2 = fragment.split("/").slice(1).map(decodePointerSegment);
+  const segments = fragment.split("/").slice(1).map(decodePointerSegment);
   let node = doc;
-  for (const segment of segments2) {
+  for (const segment of segments) {
     if (node === null || typeof node !== "object" || Array.isArray(node)) {
       throw new Error(`Pointer segment "${segment}" not resolvable in fragment #${fragment}`);
     }
@@ -12495,12 +12495,12 @@ class FakeProvider {
     }
     const { attemptId } = opts;
     let sequence = 0;
-    const emit = (body) => ({
+    const emit2 = (body) => ({
       ...body,
       sequence: sequence++,
       attemptId
     });
-    yield emit({ kind: "model_start" });
+    yield emit2({ kind: "model_start" });
     for (const raw of transcript.events) {
       const payload = raw.payload ?? {};
       switch (raw.kind) {
@@ -12513,13 +12513,13 @@ class FakeProvider {
           if (extensions !== undefined) {
             body.unknownExtensions = extensions;
           }
-          yield emit(body);
+          yield emit2(body);
           break;
         }
         case "tool_call": {
           const input2 = payload.input;
           if (!isPlainObject6(input2)) {
-            yield emit({
+            yield emit2({
               kind: "provider_error",
               error: {
                 kind: "malformed",
@@ -12538,21 +12538,21 @@ class FakeProvider {
           if (typeof payload.toolName === "string") {
             startBody.toolName = payload.toolName;
           }
-          yield emit(startBody);
-          yield emit(endBody);
+          yield emit2(startBody);
+          yield emit2(endBody);
           break;
         }
         case "finish": {
           const usage = payload.usage;
           if (isPlainObject6(usage)) {
-            yield emit({ kind: "usage_update", usage: mapUsage(usage) });
+            yield emit2({ kind: "usage_update", usage: mapUsage(usage) });
           }
           const body = { kind: "model_end" };
           const extensions = extractUnknownExtensions(payload);
           if (extensions !== undefined) {
             body.unknownExtensions = extensions;
           }
-          yield emit(body);
+          yield emit2(body);
           break;
         }
         case "error": {
@@ -12561,7 +12561,7 @@ class FakeProvider {
             retryable: payload.retryable,
             message: payload.message
           };
-          yield emit({ kind: "provider_error", error });
+          yield emit2({ kind: "provider_error", error });
           return;
         }
       }
@@ -13660,7 +13660,10 @@ async function runModelTurn(input2) {
   let reasoning = false;
   const startedAt = performance.now();
   let firstByteAt;
-  for await (const event of port.stream(request, { attemptId: request.requestId })) {
+  for await (const event of port.stream(request, {
+    attemptId: request.requestId,
+    ...input2.signal !== undefined ? { signal: input2.signal } : {}
+  })) {
     if (firstByteAt === undefined) {
       firstByteAt = performance.now();
     }
@@ -13849,14 +13852,14 @@ function hasUnquotedMetacharacter(command) {
   return state.unbalanced || state.metacharacter;
 }
 function splitSegments(command) {
-  const segments2 = [];
+  const segments = [];
   let buf = "";
   let pending;
   let quote;
   const flush = (next) => {
     const raw = buf.trim();
     if (raw.length > 0) {
-      segments2.push({
+      segments.push({
         raw,
         words: splitWords(raw),
         ...pending !== undefined ? { precededBy: pending } : {}
@@ -13898,7 +13901,7 @@ function splitSegments(command) {
     buf += ch;
   }
   flush();
-  return segments2;
+  return segments;
 }
 function separatorAt(ch, next) {
   if (ch === "&" && next === "&")
@@ -14002,18 +14005,18 @@ function classifySegment(seg) {
 function classifyCommand2(command) {
   if (command.trim().length === 0)
     return "shell";
-  const segments2 = splitSegments(command);
-  for (const seg of segments2) {
+  const segments = splitSegments(command);
+  for (const seg of segments) {
     if (classifySegment(seg))
       return "destructive";
   }
-  for (let i = 1;i < segments2.length; i++) {
-    const seg = segments2[i];
+  for (let i = 1;i < segments.length; i++) {
+    const seg = segments[i];
     if (seg.precededBy !== "|")
       continue;
     if (!INTERPRETERS.has(head(seg.words)))
       continue;
-    const upstream = segments2.slice(0, i);
+    const upstream = segments.slice(0, i);
     if (upstream.some((s) => DOWNLOADERS.has(head(s.words))))
       return "destructive";
   }
@@ -16448,7 +16451,13 @@ function writeJsonl(file, history, ts) {
 function redactHistory(history) {
   return history.map((message) => ({
     ...message,
-    content: redactSensitiveText(message.content)
+    content: redactSensitiveText(message.content),
+    ...message.toolCalls === undefined ? {} : {
+      toolCalls: message.toolCalls.map((call) => ({
+        ...call,
+        arguments: redactSensitiveText(call.arguments)
+      }))
+    }
   }));
 }
 function readJsonl2(file) {
@@ -17613,6 +17622,9 @@ async function createProjectSkill(projectRoot, options) {
   if (!await pathExists(metaprojectRoot)) {
     throw new Error("Metaproject is not initialized. Run: keryx init");
   }
+  if (!isRoutableSkillTarget(options.target)) {
+    throw new Error(`keryx skills create: target ${JSON.stringify(options.target)} reads as prose, not a routing key. ` + 'A target is what `keryx skills route` matches against \u2014 a concept ("auth flow"), a symbol (`IResultDqReport`), ' + "or a path (`src/dq/DqScoreCard.tsx`). A sentence matches nothing and verifies as permanently stale.");
+  }
   const moduleName = slugify3(options.module ?? inferModule(options.target));
   const skillName = slugify3(options.name ?? inferSkillName(options.target));
   const format = options.format ?? "auto";
@@ -18605,6 +18617,23 @@ function authorityFor(manifest, subject) {
 function normalizeProposalLifecycleResult(value) {
   return JSON.parse(JSON.stringify(value));
 }
+async function readProposalSecurityGate(cwd, workspaceId, proposalId) {
+  const file = path86.join(cwd, ".metaproject", "workspaces", workspaceId, "proposals", `${proposalId}.json`);
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile44(file, "utf8"));
+  } catch {
+    return;
+  }
+  if (typeof parsed !== "object" || parsed === null)
+    return;
+  const record = parsed;
+  const gate = record.security?.gate;
+  if (gate !== "pass" && gate !== "needs-approval")
+    return;
+  const evidenceRefs = Array.isArray(record.evidence) ? record.evidence.map((entry) => typeof entry === "object" && entry !== null ? entry.uri : undefined).filter((uri) => typeof uri === "string") : [];
+  return { gate, evidenceRefs };
+}
 var ProposalLifecycleError;
 var init_proposal_lifecycle = __esm(() => {
   init_fs();
@@ -18788,13 +18817,16 @@ async function digestLedgerPrefix(handle, byteLength) {
     return digest2;
   const buffer = Buffer.alloc(Math.min(ledgerDigestChunkBytes, byteLength));
   let position = 0;
-  while (position < byteLength) {
+  const maxChunks = Math.ceil(byteLength / buffer.length);
+  for (let chunk = 0;chunk < maxChunks && position < byteLength; chunk += 1) {
     const result = await handle.read(buffer, 0, Math.min(buffer.length, byteLength - position), position);
     if (result.bytesRead === 0)
       return;
     digest2.update(buffer.subarray(0, result.bytesRead));
     position += result.bytesRead;
   }
+  if (position < byteLength)
+    return;
   return digest2;
 }
 function parseCheckpoint(value) {
@@ -29216,6 +29248,32 @@ var init_metaproject_operations = __esm(() => {
 
 // src/wiki/deep-enrich.ts
 import { randomUUID as randomUUID15, createHash as createHash22 } from "crypto";
+function composeAbortSignals(external, timeout) {
+  if (external === undefined) {
+    return { signal: timeout, dispose: () => {} };
+  }
+  const controller = new AbortController;
+  const abortFrom = (signal) => {
+    if (!controller.signal.aborted) {
+      controller.abort(signal.reason);
+    }
+  };
+  const onExternalAbort = () => abortFrom(external);
+  const onTimeoutAbort = () => abortFrom(timeout);
+  external.addEventListener("abort", onExternalAbort, { once: true });
+  timeout.addEventListener("abort", onTimeoutAbort, { once: true });
+  if (external.aborted)
+    abortFrom(external);
+  if (timeout.aborted)
+    abortFrom(timeout);
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      external.removeEventListener("abort", onExternalAbort);
+      timeout.removeEventListener("abort", onTimeoutAbort);
+    }
+  };
+}
 function errorMessage2(cause) {
   return cause instanceof Error ? cause.message : String(cause);
 }
@@ -29254,6 +29312,9 @@ async function enrichPageDeep(input2) {
   const idSeq = input2.idSeq ?? (() => randomUUID15());
   const clock = input2.clock ?? (() => new Date().toISOString());
   const toolCalls = [];
+  if (input2.signal?.aborted) {
+    return { fallback: true, reason: "deep enrich cancelled", toolCalls };
+  }
   try {
     const env = envWithSavedApiKeys(input2.env ?? process.env);
     const credentialAvailable = hasCredential(input2.provider, env);
@@ -29329,6 +29390,7 @@ async function enrichPageDeep(input2) {
     let assistant = "";
     let pending;
     const abort = new AbortController;
+    const composed = composeAbortSignals(input2.signal, abort.signal);
     const io = {
       write: (s) => {
         assistant += s;
@@ -29360,11 +29422,12 @@ async function enrichPageDeep(input2) {
     };
     const history = [];
     const userLine = buildDeepUserPrompt(input2.page, input2.original, input2.extraInstruction);
-    const turn = runAgentTurn(io, deps, history, userLine, { signal: abort.signal });
+    const turn = runAgentTurn(io, deps, history, userLine, { signal: composed.signal });
     const deadlineMs = spawned.reservation.maxRuntimeMs;
     if (deadlineMs <= 0) {
       abort.abort();
       turn.catch(() => {});
+      composed.dispose();
       releaseBudget();
       return {
         fallback: true,
@@ -29376,16 +29439,31 @@ async function enrichPageDeep(input2) {
     const expired = new Promise((resolve2) => {
       timer = setTimeout(() => resolve2("timeout"), deadlineMs);
     });
+    let onExternalAbort;
+    const cancelled = new Promise((resolve2) => {
+      if (input2.signal === undefined)
+        return;
+      onExternalAbort = () => resolve2("cancelled");
+      if (input2.signal.aborted) {
+        onExternalAbort();
+      } else {
+        input2.signal.addEventListener("abort", onExternalAbort, { once: true });
+      }
+    });
     let outcome;
     try {
-      outcome = await Promise.race([turn.then(() => "done"), expired]);
+      outcome = await Promise.race([turn.then(() => "done"), expired, cancelled]);
     } finally {
       if (timer !== undefined)
         clearTimeout(timer);
+      if (onExternalAbort !== undefined) {
+        input2.signal?.removeEventListener("abort", onExternalAbort);
+      }
     }
     if (outcome === "timeout") {
       abort.abort();
       turn.catch(() => {});
+      composed.dispose();
       releaseBudget();
       const partial = assistant.trim();
       return {
@@ -29395,7 +29473,15 @@ async function enrichPageDeep(input2) {
         toolCalls
       };
     }
+    composed.dispose();
     releaseBudget();
+    if (outcome === "cancelled" || input2.signal?.aborted) {
+      return {
+        fallback: true,
+        reason: "deep enrich cancelled",
+        toolCalls
+      };
+    }
     const raw = assistant.trim().length > 0 ? assistant.trim() : history.filter((m) => m.role === "assistant").map((m) => m.content).join(`
 `).trim();
     if (raw.length === 0) {
@@ -29582,6 +29668,9 @@ function isWikiEnrichIntent(line) {
   if (t.length === 0) {
     return false;
   }
+  if (/^keryx\s+wiki\s+enrich(?:\s|$)/.test(t)) {
+    return false;
+  }
   const ru = t.includes("\u0432\u0438\u043A\u0438") && (t.includes("\u043E\u0431\u043E\u0433\u0430\u0442") || t.includes("\u043E\u0431\u043E\u0433\u0430\u0449"));
   const en = /\benrich\b/.test(t) && /\bwiki\b/.test(t) || /\bwiki\s+enrich\b/.test(t);
   return ru || en;
@@ -29860,6 +29949,7 @@ async function wikiEnrich(input2) {
     enriched: 0,
     dryRun: 0,
     skipped: 0,
+    cancelled: 0,
     failed: 0
   };
   if (input2.refreshGraph) {
@@ -29900,9 +29990,15 @@ async function wikiEnrich(input2) {
     pageResults = await mapPool(pages, concurrency, async (page, i) => {
       const index = i + 1;
       const status = page.status ?? "draft";
+      if (input2.signal?.aborted) {
+        return { path: page.relativePath, action: "cancelled", reason: "enrichment cancelled" };
+      }
       onPage({ index, total, path: page.relativePath, status, phase: "start" });
       try {
         const originalRaw = await readFile62(page.absolutePath, "utf8");
+        if (input2.signal?.aborted) {
+          return { path: page.relativePath, action: "cancelled", reason: "enrichment cancelled" };
+        }
         const ensured = ensureWikiFrontmatter(originalRaw, {
           title: page.title,
           pageType: page.pageType
@@ -29919,8 +30015,12 @@ async function wikiEnrich(input2) {
           env,
           ...input2.fetch ? { fetch: input2.fetch } : {},
           ...input2.baseUrl !== undefined ? { baseUrl: input2.baseUrl } : {},
-          ...input2.providerFactory ? { providerFactory: input2.providerFactory } : {}
+          ...input2.providerFactory ? { providerFactory: input2.providerFactory } : {},
+          ...input2.signal !== undefined ? { signal: input2.signal } : {}
         });
+        if (input2.signal?.aborted) {
+          return { path: page.relativePath, action: "cancelled", reason: "enrichment cancelled" };
+        }
         if (turn.error) {
           onPage({ index, total, path: page.relativePath, status, phase: "failed" });
           return {
@@ -29957,7 +30057,16 @@ async function wikiEnrich(input2) {
         const output2 = enriched.endsWith(`
 `) ? enriched : `${enriched}
 `;
-        const materialized = prepareOutputForPersistence(await guardOutput({ cwd: input2.cwd, content: output2, target: "wiki", source: "generated", path: page.relativePath }), output2);
+        const materialized = prepareOutputForPersistence(await (input2.guardOutput ?? guardOutput)({
+          cwd: input2.cwd,
+          content: output2,
+          target: "wiki",
+          source: "generated",
+          path: page.relativePath
+        }), output2);
+        if (input2.signal?.aborted) {
+          return { path: page.relativePath, action: "cancelled", reason: "enrichment cancelled" };
+        }
         if (!materialized.allowed) {
           onPage({ index, total, path: page.relativePath, status, phase: "failed" });
           return { path: page.relativePath, action: "failed", reason: materialized.reason };
@@ -30009,6 +30118,8 @@ async function wikiEnrich(input2) {
       }
     } else if (entry.action === "dry-run") {
       result.dryRun += 1;
+    } else if (entry.action === "cancelled") {
+      result.cancelled += 1;
     } else if (entry.action === "failed") {
       result.failed += 1;
       resumeState.failed.push({ path: entry.path, reason: entry.reason ?? "failed" });
@@ -30079,6 +30190,9 @@ function finalizeEnrichedText(original, rawText, options) {
 async function finishSuccess(ctx, page, originalRaw, content, keyFiles, extra) {
   const index = ctx.pageIndex(page.relativePath);
   const status = page.status ?? "draft";
+  if (ctx.input.signal?.aborted) {
+    return { path: page.relativePath, action: "cancelled", reason: "enrichment cancelled", tier: extra.tier };
+  }
   const nodeHash = keyFiles.length > 0 ? await computePageNodeHash(ctx.cwd, keyFiles, ctx.graph) : undefined;
   if (ctx.input.dryRun) {
     ctx.onPage({ index, total: ctx.total, path: page.relativePath, status, phase: "done" });
@@ -30095,7 +30209,16 @@ async function finishSuccess(ctx, page, originalRaw, content, keyFiles, extra) {
   const output2 = content.endsWith(`
 `) ? content : `${content}
 `;
-  const materialized = prepareOutputForPersistence(await guardOutput({ cwd: ctx.cwd, content: output2, target: "wiki", source: "generated", path: page.relativePath }), output2);
+  const materialized = prepareOutputForPersistence(await (ctx.input.guardOutput ?? guardOutput)({
+    cwd: ctx.cwd,
+    content: output2,
+    target: "wiki",
+    source: "generated",
+    path: page.relativePath
+  }), output2);
+  if (ctx.input.signal?.aborted) {
+    return { path: page.relativePath, action: "cancelled", reason: "enrichment cancelled", tier: extra.tier };
+  }
   if (!materialized.allowed) {
     ctx.onPage({ index, total: ctx.total, path: page.relativePath, status, phase: "failed" });
     return {
@@ -30128,6 +30251,9 @@ async function runDeepSingle(ctx, item) {
   const { page, original, originalRaw, keyFiles } = item;
   const index = ctx.pageIndex(page.relativePath);
   const status = page.status ?? "draft";
+  if (ctx.input.signal?.aborted) {
+    return { path: page.relativePath, action: "cancelled", reason: "enrichment cancelled", tier: "deep" };
+  }
   ctx.onPage({ index, total: ctx.total, path: page.relativePath, status, phase: "model" });
   try {
     const deepResult = await enrichPageDeep({
@@ -30140,11 +30266,15 @@ async function runDeepSingle(ctx, item) {
       model: ctx.model,
       maxToolCalls: ctx.wikiConfig.rlm.deep.maxToolCalls,
       maxRuntimeMs: ctx.wikiConfig.rlm.deep.maxRuntimeMs,
+      ...ctx.input.signal !== undefined ? { signal: ctx.input.signal } : {},
       env: ctx.env,
       ...ctx.input.fetch ? { fetch: ctx.input.fetch } : {},
       ...ctx.input.baseUrl !== undefined ? { baseUrl: ctx.input.baseUrl } : {},
       ...ctx.input.providerFactory ? { providerFactory: ctx.input.providerFactory } : {}
     });
+    if (ctx.input.signal?.aborted) {
+      return { path: page.relativePath, action: "cancelled", reason: "enrichment cancelled", tier: "deep" };
+    }
     const deepToolCalls = deepResult.toolCalls.length;
     let rawText = null;
     if ("enriched" in deepResult) {
@@ -30222,9 +30352,9 @@ function batchGroupKey(item) {
   const primaryKeyFile = item.keyFiles[0];
   if (primaryKeyFile !== undefined) {
     const dir = primaryKeyFile.split("/").slice(0, -1).join("/");
-    const segments2 = dir.split("/").filter((segment) => segment.length > 0);
-    if (segments2.length > 0) {
-      return segments2.slice(0, 2).join("/");
+    const segments = dir.split("/").filter((segment) => segment.length > 0);
+    if (segments.length > 0) {
+      return segments.slice(0, 2).join("/");
     }
   }
   return item.page.pageType;
@@ -30261,6 +30391,14 @@ function groupLightPagesIntoBatches(items, batchConfig, tokenBudget) {
   return batches;
 }
 async function runLightBatch(ctx, items) {
+  if (ctx.input.signal?.aborted) {
+    return items.map((item) => ({
+      path: item.page.relativePath,
+      action: "cancelled",
+      reason: "enrichment cancelled",
+      tier: "light"
+    }));
+  }
   for (const item of items) {
     ctx.onPage({
       index: ctx.pageIndex(item.page.relativePath),
@@ -30285,7 +30423,8 @@ async function runLightBatch(ctx, items) {
       env: ctx.env,
       ...ctx.input.fetch ? { fetch: ctx.input.fetch } : {},
       ...ctx.input.baseUrl !== undefined ? { baseUrl: ctx.input.baseUrl } : {},
-      ...ctx.input.providerFactory ? { providerFactory: ctx.input.providerFactory } : {}
+      ...ctx.input.providerFactory ? { providerFactory: ctx.input.providerFactory } : {},
+      ...ctx.input.signal !== undefined ? { signal: ctx.input.signal } : {}
     });
   } catch (cause) {
     const reason = cause instanceof Error ? cause.message : String(cause);
@@ -30305,6 +30444,14 @@ async function runLightBatch(ctx, items) {
       };
     });
   }
+  if (ctx.input.signal?.aborted) {
+    return items.map((item) => ({
+      path: item.page.relativePath,
+      action: "cancelled",
+      reason: "enrichment cancelled",
+      tier: "light"
+    }));
+  }
   if (turn.error) {
     const errorReason = `${turn.error.kind}: ${turn.error.message}`;
     return items.map((item) => {
@@ -30368,8 +30515,18 @@ async function runLightBatch(ctx, items) {
 }
 async function runRlmPipeline(ctxInput) {
   const { pages, wikiConfig, input: input2 } = ctxInput;
+  const cancelled = () => pages.map((page) => ({ path: page.relativePath, action: "cancelled", reason: "enrichment cancelled" }));
+  if (input2.signal?.aborted) {
+    return cancelled();
+  }
   const graph = await loadGraph(ctxInput.cwd);
+  if (input2.signal?.aborted) {
+    return cancelled();
+  }
   const gdgraphConfig = await loadGdgraphConfig(ctxInput.cwd);
+  if (input2.signal?.aborted) {
+    return cancelled();
+  }
   const fileNodes = graph.nodes.filter((node) => node.kind === "file").map((node) => node.path);
   const rankEdges = buildRankEdges(graph, gdgraphConfig);
   const ranked = personalizedPageRank(fileNodes, rankEdges, {
@@ -30400,11 +30557,21 @@ async function runRlmPipeline(ctxInput) {
   };
   const prepared = [];
   for (const page of pages) {
+    if (input2.signal?.aborted) {
+      return cancelled();
+    }
     const index = pageIndex(page.relativePath);
     const status = page.status ?? "draft";
     ctx.onPage({ index, total: ctx.total, path: page.relativePath, status, phase: "start" });
+    if (input2.signal?.aborted) {
+      return cancelled();
+    }
+    input2.onRlmPreparation?.(page.relativePath);
     try {
       const originalRaw = await readFile62(page.absolutePath, "utf8");
+      if (input2.signal?.aborted) {
+        return cancelled();
+      }
       const ensured = ensureWikiFrontmatter(originalRaw, { title: page.title, pageType: page.pageType });
       const original = ensured.markdown;
       const keyFiles = keyFilesForPage(moduleKeyFilesIndex, page);
@@ -30412,6 +30579,9 @@ async function runRlmPipeline(ctxInput) {
       let unchanged = false;
       if (previousHash !== undefined && keyFiles.length > 0) {
         const currentHash = await computePageNodeHash(ctx.cwd, keyFiles, graph);
+        if (input2.signal?.aborted) {
+          return cancelled();
+        }
         unchanged = isPageUnchangedSinceLastEnrich(page.relativePath, currentHash, resumeState.completedNodeHashes);
       }
       if (unchanged) {
@@ -30445,6 +30615,9 @@ async function runRlmPipeline(ctxInput) {
       const item = { page, original, originalRaw, keyFiles };
       prepared.push({ kind: tier === "deep" ? "deep" : "light", item });
     } catch (cause) {
+      if (input2.signal?.aborted) {
+        return cancelled();
+      }
       ctx.onPage({ index, total: ctx.total, path: page.relativePath, status, phase: "failed" });
       prepared.push({
         kind: "resolved",
@@ -30456,6 +30629,9 @@ async function runRlmPipeline(ctxInput) {
       });
     }
   }
+  if (input2.signal?.aborted) {
+    return cancelled();
+  }
   const units = [];
   let pendingLight = [];
   const flushLight = () => {
@@ -30485,6 +30661,9 @@ async function runRlmPipeline(ctxInput) {
     }
   }
   flushLight();
+  if (input2.signal?.aborted) {
+    return cancelled();
+  }
   const unitResults = await mapPool(units, ctxInput.concurrency, async (unit) => {
     try {
       if (unit.kind === "resolved") {
@@ -30770,12 +30949,12 @@ async function narrate(opts) {
   });
   if (!turn.credentialAvailable) {
     const message2 = formatMissingCredentialHint(turn.provider);
-    emit(asJson, { provider: turn.provider, model: turn.model, credentialAvailable: false, error: message2 }, message2, true);
+    emit2(asJson, { provider: turn.provider, model: turn.model, credentialAvailable: false, error: message2 }, message2, true);
     return;
   }
   if (turn.error) {
     const message2 = `${turn.error.kind}: ${turn.error.message}`;
-    emit(asJson, { provider: turn.provider, model: turn.model, error: message2 }, message2, true);
+    emit2(asJson, { provider: turn.provider, model: turn.model, error: message2 }, message2, true);
     return;
   }
   const text = turn.text.trim();
@@ -30785,7 +30964,7 @@ async function narrate(opts) {
     console.log(text);
   }
 }
-function emit(asJson, payload, message2, isError) {
+function emit2(asJson, payload, message2, isError) {
   if (asJson) {
     console.log(JSON.stringify(payload, null, 2));
   } else if (isError) {
@@ -32875,7 +33054,7 @@ var BUNDLED_GDSKILLS = [
     "Use gdgraph affected context for exported symbols and shared surfaces.",
     "Dispatch specialized review passes conceptually or as separate skill loads.",
     "Report findings first, ordered by severity, with concrete file references."
-  ], ["review code", "full review", "review changes"]),
+  ], ["review", "\u0440\u0435\u0432\u044C\u044E", "review code", "full review", "review changes"]),
   skill("review-logic", "review", ["recommended", "full"], "Review logic correctness, contracts, edge cases, nullability, and async behavior.", [
     "Trace behavior through call sites and affected context.",
     "Look for incorrect assumptions, missing branches, race conditions, and error paths.",
@@ -32890,7 +33069,13 @@ var BUNDLED_GDSKILLS = [
     "Map inputs, trust boundaries, and sensitive outputs.",
     "Check injection, auth, crypto, secrets, and unsafe filesystem/network behavior.",
     "Prioritize exploitable findings with concrete remediation."
-  ], ["security review", "secure code", "vulnerability"]),
+  ], [
+    "security review",
+    "\u043F\u0440\u043E\u0432\u0435\u0440\u044C \u0431\u0435\u0437\u043E\u043F\u0430\u0441\u043D\u043E\u0441\u0442\u044C",
+    "\u0431\u0435\u0437\u043E\u043F\u0430\u0441\u043D\u043E\u0441\u0442\u044C \u043A\u043E\u0434\u0430",
+    "secure code",
+    "vulnerability"
+  ]),
   skill("review-performance", "review", ["recommended", "full"], "Review hot paths, unnecessary work, bundle/perf regressions, blocking operations, and memory risk.", [
     "Find changed hot paths and repeated operations.",
     "Check loops, rendering, async blocking, large imports, and caching behavior.",
@@ -33026,7 +33211,12 @@ var BUNDLED_GDSKILLS = [
     "Detect deployment target and required pre-flight checks.",
     "Run verification before deployment unless explicitly skipped.",
     "Summarize deployment status, rollback path, and health checks."
-  ], ["deploy", "ship", "release"]),
+  ], [
+    "deploy",
+    "deployment",
+    "ship",
+    "release"
+  ]),
   skill("commit", "quality", ["full"], "Prepare conventional commits with scope, summary, and verification notes.", [
     "Inspect staged and unstaged changes.",
     "Group related changes without staging unrelated work.",
@@ -33530,6 +33720,28 @@ async function validateValue(value, schema, valuePath, errors, rootSchema, schem
       message: `Expected array length >= ${schema.minItems}`
     });
   }
+  if (Array.isArray(value) && schema.maxItems !== undefined && value.length > schema.maxItems) {
+    errors.push({
+      path: valuePath,
+      message: `Expected array length <= ${schema.maxItems}`
+    });
+  }
+  if (typeof value === "number" && schema.exclusiveMinimum !== undefined && value <= schema.exclusiveMinimum) {
+    errors.push({
+      path: valuePath,
+      message: `Expected number > ${schema.exclusiveMinimum}`
+    });
+  }
+  if (schema.not !== undefined) {
+    const negated = [];
+    await validateValue(value, schema.not, valuePath, negated, rootSchema, schemaCache);
+    if (negated.length === 0) {
+      errors.push({
+        path: valuePath,
+        message: "Expected value NOT to match the prohibited subschema"
+      });
+    }
+  }
   if (typeof value === "string") {
     if (schema.minLength !== undefined && value.length < schema.minLength) {
       errors.push({
@@ -39475,8 +39687,56 @@ init_guard();
 import { mkdir as mkdir16, readFile as readFile23, writeFile as writeFile18 } from "fs/promises";
 import path46 from "path";
 
+// src/lib/bounded-stdin.ts
+async function readStdinBounded(deadlineMs) {
+  if (process.stdin.isTTY) {
+    return null;
+  }
+  const reader = Bun.stdin.stream().getReader();
+  const timer = setTimeout(() => void reader.cancel().catch(() => {}), deadlineMs);
+  timer.unref?.();
+  const chunks = [];
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (value)
+        chunks.push(Buffer.from(value));
+    }
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timer);
+    reader.releaseLock?.();
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
 // src/ctx/hook-classify.ts
 var ESCAPE_MARKER = /#\s*keryx:raw\b[ \t]*([^\n]*)/i;
+function escapeReasonOf(command) {
+  let quote = null;
+  for (let i = 0;i < command.length; i += 1) {
+    const char = command[i];
+    if (quote) {
+      if (char === quote)
+        quote = null;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (char !== "#")
+      continue;
+    const match = ESCAPE_MARKER.exec(command.slice(i));
+    if (match && match.index === 0) {
+      return (match[1] ?? "").trim();
+    }
+  }
+  return null;
+}
 var LEADING_SKIP = new Set(["sudo", "command", "time", "nice", "env", "builtin"]);
 var ALREADY_ROUTED = new Set(["keryx", "rtk"]);
 var ROUTES = [
@@ -39484,11 +39744,118 @@ var ROUTES = [
   { names: /^(cat|head|tail)$/, suggestion: "keryx ctx read <file> --mode compact" }
 ];
 var GIT_ROUTABLE = /^(diff|log|show)$/;
-function segments(command) {
-  return command.split(/\|\||&&|;|\||\n/).map((s) => s.trim()).filter(Boolean);
+function statements(command) {
+  return command.split(/\|\||&&|;|\n/).map((s) => s.trim()).filter(Boolean);
+}
+function stages(command) {
+  const out = [];
+  for (const statement of statements(command)) {
+    const parts = splitPipeline(statement);
+    parts.forEach((text, index) => {
+      const trimmed = text.trim();
+      if (trimmed)
+        out.push({ text: trimmed, isFirst: index === 0 });
+    });
+  }
+  return out;
+}
+function splitPipeline(statement) {
+  const parts = [];
+  let current = "";
+  let quote = null;
+  for (const char of statement) {
+    if (quote) {
+      if (char === quote)
+        quote = null;
+      current += char;
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      current += char;
+      continue;
+    }
+    if (char === "|") {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  parts.push(current);
+  return parts;
+}
+function stageTokens(stage) {
+  return (stage.match(/'[^']*'|"[^"]*"|\S+/g) ?? []).filter(Boolean);
+}
+var VALUE_FLAGS = {
+  search: new Set(["-e", "--regexp", "-f", "--file", "-m", "--max-count", "-A", "-B", "-C", "--context"]),
+  head: new Set(["-n", "--lines", "-c", "--bytes"]),
+  tail: new Set(["-n", "--lines", "-c", "--bytes"]),
+  sed: new Set(["-e", "--expression", "-f", "--file"]),
+  awk: new Set(["-f", "-v"])
+};
+function valueFlagsFor(command, searchLike) {
+  return searchLike ? VALUE_FLAGS.search : VALUE_FLAGS[command] ?? new Set;
+}
+function readsStdin(tokens, isFirst) {
+  const [command, ...rest] = tokens;
+  if (!command) {
+    return true;
+  }
+  if (/^(find|ls|git)$/.test(command)) {
+    return false;
+  }
+  if (/^(rg|ripgrep)$/.test(command) && isFirst) {
+    return false;
+  }
+  const searchLike = /^(rg|grep|egrep|fgrep|ripgrep)$/.test(command);
+  const valueFlags = valueFlagsFor(command, searchLike);
+  let operandsAllowed = searchLike || /^(sed|awk)$/.test(command) ? 1 : 0;
+  for (let i = 0;i < rest.length; i += 1) {
+    const token = rest[i] ?? "";
+    const [flag, attached] = splitFlagValue(token);
+    if (operandsAllowed > 0 && PATTERN_FLAGS.has(flag)) {
+      operandsAllowed = 0;
+      if (attached === null)
+        i += 1;
+      continue;
+    }
+    if (valueFlags.has(flag)) {
+      if (attached === null)
+        i += 1;
+      continue;
+    }
+    if (token.startsWith("-")) {
+      if (searchLike && isRecursiveFlag(token)) {
+        return false;
+      }
+      continue;
+    }
+    if (operandsAllowed > 0) {
+      operandsAllowed -= 1;
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+var PATTERN_FLAGS = new Set(["-e", "--regexp", "-f", "--file", "--expression"]);
+function splitFlagValue(token) {
+  if (token.startsWith("--")) {
+    const eq = token.indexOf("=");
+    return eq === -1 ? [token, null] : [token.slice(0, eq), token.slice(eq + 1)];
+  }
+  if (token.startsWith("-") && token.length > 2) {
+    return [token.slice(0, 2), token.slice(2)];
+  }
+  return [token, null];
+}
+function isRecursiveFlag(token) {
+  return token === "--recursive" || token === "--dereference-recursive" || /^-[a-zA-Z]*[rR]/.test(token);
 }
 function leadingTokens(segment) {
-  const tokens = segment.split(/\s+/).filter(Boolean);
+  const tokens = stageTokens(segment);
   let i = 0;
   while (i < tokens.length) {
     const token = tokens[i] ?? "";
@@ -39504,12 +39871,15 @@ function classifyCommand(command) {
   if (!command.trim()) {
     return { block: false };
   }
-  const escape = ESCAPE_MARKER.exec(command);
-  if (escape) {
-    return { block: false, escapeReason: (escape[1] ?? "").trim() };
+  const escapeReason = escapeReasonOf(command);
+  if (escapeReason !== null) {
+    return { block: false, escapeReason };
   }
-  for (const segment of segments(command)) {
-    const tokens = leadingTokens(segment);
+  for (const stage of stages(command)) {
+    const tokens = leadingTokens(stage.text);
+    if (readsStdin(tokens, stage.isFirst)) {
+      continue;
+    }
     const first = tokens[0];
     if (!first || ALREADY_ROUTED.has(first)) {
       continue;
@@ -39612,18 +39982,30 @@ function stripFromHookArray(settings, key) {
   removeSentinel(settings);
   return settings;
 }
-function hasManagedInArray(settings, key, command) {
-  const hooks = settings.hooks;
-  const groups = Array.isArray(hooks?.[key]) ? hooks?.[key] : [];
-  return groups.some((g) => {
-    if (!isManagedGroup2(g))
+function groupContainer(settings, runtime) {
+  const container = runtime.groupContainer ? settings[runtime.groupContainer] : settings.hooks;
+  const list2 = container?.[runtime.groupKey];
+  return Array.isArray(list2) ? list2 : [];
+}
+function managedGroupsFor(settings, runtime) {
+  const command = hookCommand(runtime.id);
+  return groupContainer(settings, runtime).filter((group) => {
+    if (!isManagedGroup2(group))
       return false;
-    const inner = g;
-    if (inner.command === command)
-      return true;
-    return Array.isArray(inner.hooks) && inner.hooks.some((h) => h?.command === command);
+    const entry = group;
+    if (runtime.groupShape === "flat") {
+      return entry.command === command;
+    }
+    return Array.isArray(entry.hooks) && entry.hooks.some((hook) => hook?.command === command && hook?.type === "command");
   });
 }
+function hasRunnableGuard(settings, runtime) {
+  return managedGroupsFor(settings, runtime).length > 0;
+}
+function hasStalePreToolUseMatcher(settings, runtime) {
+  const expected = preToolUseMatcher(runtime);
+  return managedGroupsFor(settings, runtime).some((group) => typeof group.matcher !== "string" || group.matcher !== expected);
+}
 function parseJson(payload) {
   try {
     const parsed = JSON.parse(payload);
@@ -39642,6 +40024,22 @@ function parseToolInputCommand(payload) {
   const command = input2.command;
   return typeof command === "string" ? command : null;
 }
+function parseToolName(payload) {
+  const record = parseJson(payload);
+  const name = record?.tool_name;
+  return typeof name === "string" ? name : null;
+}
+function nativeSearchMessage(tool) {
+  return [
+    `[keryx ctx] The \`${tool}\` tool searches project code without the gdctx routing layer.`,
+    `Use instead:  keryx ctx rg "<pattern>" [path]`,
+    `The routed form is compressed and recorded in the routing audit (ctx_used).`,
+    `Structural question (callers, usages, blast radius)? Use gdgraph first.`,
+    `If raw output is genuinely required, run it through Bash with an escape marker:`,
+    `  rg "<pattern>" <path>   # keryx:raw <why raw is needed>`
+  ].join(`
+`);
+}
 function parseCursorCommand(payload) {
   const record = parseJson(payload);
   const command = record?.command;
@@ -39712,41 +40110,73 @@ function antigravityAllow(_c) {
   return { exitCode: 0, stdout: `${JSON.stringify({ allow_tool: true })}
 ` };
 }
-function preToolUseGroup(id) {
+function preToolUseMatcher(runtime) {
+  return ["Bash", ...runtime.nativeSearchTools ?? []].join("|");
+}
+function validatePreToolUse(settings, runtime) {
+  const command = hookCommand(runtime.id);
+  const expected = preToolUseMatcher(runtime);
+  if (!hasRunnableGuard(settings, runtime)) {
+    return [`${runtime.id}: missing PreToolUse(${expected}) guard`];
+  }
+  if (hasStalePreToolUseMatcher(settings, runtime)) {
+    return [
+      `${runtime.id}: PreToolUse guard does not match ${expected}; a tool it should cover bypasses it. ` + `Re-run \`keryx ctx install-hook --runtime ${runtime.id}\`.`
+    ];
+  }
+  return [];
+}
+function describeExistingGuard(settings, runtime) {
+  const command = hookCommand(runtime.id);
+  if (!hasRunnableGuard(settings, runtime))
+    return null;
+  if (!hasStalePreToolUseMatcher(settings, runtime))
+    return null;
+  const found = managedGroupsFor(settings, runtime).map((group) => typeof group.matcher === "string" ? group.matcher : "(no matcher)").join(", ");
+  return `upgraded an existing guard: ${found} -> ${preToolUseMatcher(runtime)}`;
+}
+function preToolUseGroup(runtime) {
   return {
-    matcher: "Bash",
-    hooks: [{ type: "command", command: hookCommand(id) }],
+    matcher: preToolUseMatcher(runtime),
+    hooks: [{ type: "command", command: hookCommand(runtime.id) }],
     [MANAGED_KEY2]: CTX_HOOK_SENTINEL
   };
 }
 var CLAUDE_RUNTIME3 = {
   id: "claude",
-  label: ".claude/settings.json (PreToolUse/Bash)",
+  label: ".claude/settings.json (PreToolUse)",
   confidence: "verified",
+  groupShape: "nested",
+  groupKey: "PreToolUse",
+  nativeSearchTools: ["Grep"],
   parseCommand: parseToolInputCommand,
   block: exitCodeBlock,
   allow: exitCodeAllow,
   locate: (root) => path44.join(root, ".claude", "settings.json"),
-  merge: (s) => mergeIntoHookArray(s, "PreToolUse", preToolUseGroup("claude")),
+  merge: (s) => mergeIntoHookArray(s, "PreToolUse", preToolUseGroup(CLAUDE_RUNTIME3)),
   strip: (s) => stripFromHookArray(s, "PreToolUse"),
-  validate: (s) => hasManagedInArray(s, "PreToolUse", hookCommand("claude")) ? [] : ["claude: missing PreToolUse(Bash) guard"]
+  validate: (s) => validatePreToolUse(s, CLAUDE_RUNTIME3)
 };
 var CODEX_RUNTIME = {
   id: "codex",
-  label: ".codex/hooks.json (PreToolUse/Bash)",
+  label: ".codex/hooks.json (PreToolUse)",
   confidence: "verified",
+  groupShape: "nested",
+  groupKey: "PreToolUse",
   parseCommand: parseToolInputCommand,
   block: exitCodeBlock,
   allow: exitCodeAllow,
   locate: (root) => path44.join(root, ".codex", "hooks.json"),
-  merge: (s) => mergeIntoHookArray(s, "PreToolUse", preToolUseGroup("codex")),
+  merge: (s) => mergeIntoHookArray(s, "PreToolUse", preToolUseGroup(CODEX_RUNTIME)),
   strip: (s) => stripFromHookArray(s, "PreToolUse"),
-  validate: (s) => hasManagedInArray(s, "PreToolUse", hookCommand("codex")) ? [] : ["codex: missing PreToolUse(Bash) guard"]
+  validate: (s) => validatePreToolUse(s, CODEX_RUNTIME)
 };
 var CURSOR_RUNTIME2 = {
   id: "cursor",
   label: ".cursor/hooks.json (beforeShellExecution)",
   confidence: "verified",
+  groupShape: "flat",
+  groupKey: "beforeShellExecution",
   parseCommand: parseCursorCommand,
   block: cursorBlock,
   allow: cursorAllow,
@@ -39759,12 +40189,14 @@ var CURSOR_RUNTIME2 = {
     });
   },
   strip: (s) => stripFromHookArray(s, "beforeShellExecution"),
-  validate: (s) => hasManagedInArray(s, "beforeShellExecution", hookCommand("cursor")) ? [] : ["cursor: missing beforeShellExecution guard"]
+  validate: (s) => hasRunnableGuard(s, CURSOR_RUNTIME2) ? [] : ["cursor: missing beforeShellExecution guard"]
 };
 var WINDSURF_RUNTIME = {
   id: "windsurf",
   label: ".windsurf/hooks.json (pre_run_command)",
   confidence: "verified",
+  groupShape: "flat",
+  groupKey: "pre_run_command",
   parseCommand: parseWindsurfCommand,
   block: exitCodeBlock,
   allow: exitCodeAllow,
@@ -39775,12 +40207,15 @@ var WINDSURF_RUNTIME = {
     [MANAGED_KEY2]: CTX_HOOK_SENTINEL
   }),
   strip: (s) => stripFromHookArray(s, "pre_run_command"),
-  validate: (s) => hasManagedInArray(s, "pre_run_command", hookCommand("windsurf")) ? [] : ["windsurf: missing pre_run_command guard"]
+  validate: (s) => hasRunnableGuard(s, WINDSURF_RUNTIME) ? [] : ["windsurf: missing pre_run_command guard"]
 };
 var ANTIGRAVITY_RUNTIME = {
   id: "antigravity",
   label: ".agents/hooks.json (PreToolUse/run_command)",
   confidence: "experimental",
+  groupShape: "nested",
+  groupKey: "PreToolUse",
+  groupContainer: "keryx-ctx-guard",
   parseCommand: parseAntigravityCommand,
   block: antigravityBlock,
   allow: antigravityAllow,
@@ -39813,12 +40248,7 @@ var ANTIGRAVITY_RUNTIME = {
     removeSentinel(s);
     return s;
   },
-  validate: (s) => {
-    const group = s["keryx-ctx-guard"];
-    const list2 = Array.isArray(group?.PreToolUse) ? group?.PreToolUse : [];
-    const ok = list2.some((g) => isManagedGroup2(g) && Array.isArray(g.hooks) && g.hooks.some((h) => h?.command === hookCommand("antigravity")));
-    return ok ? [] : ["antigravity: missing run_command guard"];
-  }
+  validate: (s) => hasRunnableGuard(s, ANTIGRAVITY_RUNTIME) ? [] : ["antigravity: missing run_command guard"]
 };
 var OPENCODE_PLUGIN = `// keryx gdctx routing guard \u2014 generated by \`keryx ctx install-hook --runtime opencode\`.
 // Bridges OpenCode's tool.execute.before to \`keryx ctx hook opencode\`.
@@ -39841,6 +40271,8 @@ var OPENCODE_RUNTIME2 = {
   id: "opencode",
   label: ".opencode/plugin/keryx-ctx-guard.js",
   confidence: "experimental",
+  groupShape: "nested",
+  groupKey: "PreToolUse",
   parseCommand: parseToolInputCommand,
   block: exitCodeBlock,
   allow: exitCodeAllow,
@@ -39896,15 +40328,9 @@ function resolveRuntimes2(ids) {
   return { runtimes, unknown, unsupported };
 }
 // src/ctx/hook.ts
+var STDIN_DEADLINE_MS = 2000;
 async function readStdin() {
-  if (process.stdin.isTTY) {
-    return "";
-  }
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(Buffer.from(chunk));
-  }
-  return Buffer.concat(chunks).toString("utf8");
+  return await readStdinBounded(STDIN_DEADLINE_MS) ?? "";
 }
 async function runCtxHook(runtimeId) {
   const runtime = getRuntime2(runtimeId ?? "claude");
@@ -39914,10 +40340,17 @@ async function runCtxHook(runtimeId) {
   const payload = await readStdin();
   const command = runtime.parseCommand(payload);
   if (command === null) {
+    const nativeSearch = matchedNativeSearch(runtime.nativeSearchTools, payload);
+    if (nativeSearch) {
+      emit(refusalAction(runtime.id, nativeSearchMessage(nativeSearch)));
+    }
     return;
   }
   const classification = classifyCommand(command);
   const action = classification.block ? runtime.block(command, classification) : runtime.allow(classification);
+  emit(action);
+}
+function emit(action) {
   if (action.stdout)
     process.stdout.write(action.stdout);
   if (action.stderr)
@@ -39925,6 +40358,13 @@ async function runCtxHook(runtimeId) {
   if (action.exitCode)
     process.exitCode = action.exitCode;
 }
+function matchedNativeSearch(tools, payload) {
+  if (!tools || tools.length === 0) {
+    return null;
+  }
+  const name = parseToolName(payload);
+  return name && tools.includes(name) ? name : null;
+}
 
 // src/ctx/hook-install.ts
 init_fs();
@@ -39961,9 +40401,10 @@ async function installRuntimeHook(projectRoot, runtime) {
     return { path: file, errors: [`${runtime.id}: no installer defined`] };
   }
   const settings = await readSettings3(file);
+  const upgraded = describeExistingGuard(settings, runtime);
   await writeSettings3(file, merge(settings));
   const errors = validate(await readSettings3(file));
-  return { path: file, errors };
+  return { path: file, errors, ...upgraded ? { upgraded } : {} };
 }
 async function uninstallRuntimeHook(projectRoot, runtime) {
   if (runtime.customUninstall) {
@@ -40206,7 +40647,7 @@ async function handleInstallHook(args) {
   console.log("escape: append `# keryx:raw <reason>` to run a raw command anyway");
   console.log("");
   for (const runtime of runtimes) {
-    const { path: file, errors } = await installRuntimeHook(cwd, runtime);
+    const { path: file, errors, upgraded } = await installRuntimeHook(cwd, runtime);
     const tag = runtime.confidence === "experimental" ? " (experimental \u2014 verify on a live install)" : "";
     if (errors.length > 0) {
       for (const error of errors)
@@ -40214,6 +40655,8 @@ async function handleInstallHook(args) {
       process.exitCode = 1;
     } else {
       console.log(`  \u2713 ${runtime.id} -> ${path46.relative(cwd, file)}${tag}`);
+      if (upgraded)
+        console.log(`    ${upgraded}`);
     }
   }
   reportUnsupported(unsupported);
@@ -40350,7 +40793,7 @@ ${renderUntrackedFiles(untracked, config)}
 ` : ""}
 ## Risk Hints
 
-${renderRiskHints(risky, shape)}
+${renderRiskHints(risky, shape, shape.files)}
 
 ## Hunks
 
@@ -40723,13 +41166,19 @@ function renderDiffCounts(file) {
   }
   return file.changed !== undefined ? `: ~${file.changed} changed` : "";
 }
-function renderRiskHints(risky, shape) {
+function renderRiskHints(risky, shape, files) {
   const hints = risky.map((file) => `- ${file.path}`);
   if (shape.pathsAbbreviated) {
     hints.push("- (paths are abbreviated by `--stat`; risk matching is unreliable \u2014 re-run with `--numstat` or `--name-only` to check)");
   }
   if (hints.length === 0) {
-    return shape.mode === "unenumerable" ? "- unknown: no file list in this output shape" : "- none";
+    if (shape.mode === "unenumerable") {
+      return "- unknown: no file list in this output shape";
+    }
+    if (files.length === 0 && (shape.reportedFileCount ?? 0) > 0) {
+      return `- unknown: ${shape.reportedFileCount} file(s) changed but this output shape lists no per-file rows \u2014 nothing was checked. Re-run with \`--numstat\` or \`--name-only\`.`;
+    }
+    return "- none";
   }
   return hints.join(`
 `);
@@ -43662,6 +44111,47 @@ async function routeProjectSkills(args2) {
   }
   console.log(`Next: ${matches2[0]?.next}`);
 }
+var INFLECTIONS = ["s", "es", "ed", "d", "ing", "er", "ers", "ion", "ions", "ation"];
+var MIN_STEM = 4;
+function containsPhrase(text, phrase) {
+  const words = text.split(" ").filter(Boolean);
+  const target = phrase.split(" ").filter(Boolean);
+  if (target.length === 0)
+    return false;
+  for (let i = 0;i + target.length <= words.length; i += 1) {
+    let matched = true;
+    for (let j = 0;j < target.length; j += 1) {
+      const word = words[i + j];
+      const want = target[j];
+      const last = j === target.length - 1;
+      if (word === want)
+        continue;
+      if (last && matchesInflected(word, want))
+        continue;
+      matched = false;
+      break;
+    }
+    if (matched)
+      return true;
+  }
+  return false;
+}
+function matchesInflected(word, stem) {
+  if (stem.length < MIN_STEM || !word.startsWith(stem))
+    return false;
+  return INFLECTIONS.includes(word.slice(stem.length));
+}
+function triggerFires(trigger, normalizedQuery, queryWords, queryTokens) {
+  if (containsPhrase(normalizedQuery, trigger)) {
+    return true;
+  }
+  const rawWords = trigger.split(" ").filter(Boolean);
+  if (rawWords.length === 0) {
+    return false;
+  }
+  const meaningful = routeTokens(trigger);
+  return rawWords.every((word) => meaningful.has(word) ? queryTokens.has(word) : queryWords.has(word));
+}
 function scoreBundledSkillRoute(entry, query) {
   const normalizedQuery = normalizeRouteText(query);
   if (!normalizedQuery) {
@@ -43684,18 +44174,13 @@ function scoreBundledSkillRoute(entry, query) {
     score += 100;
     reasons.push("exact skill");
   }
-  const triggerHit = triggers.some((trigger) => {
-    if (normalizedQuery.includes(trigger)) {
-      return true;
-    }
-    const triggerTokens = [...routeTokens(trigger)];
-    return triggerTokens.length > 0 && triggerTokens.every((token) => queryTokens.has(token));
-  });
+  const queryWords = new Set(normalizedQuery.split(" ").filter(Boolean));
+  const triggerHit = triggers.some((trigger) => triggerFires(trigger, normalizedQuery, queryWords, queryTokens));
   if (triggerHit) {
     score += 55;
     reasons.push("trigger");
   }
-  if (name && normalizedQuery.includes(name)) {
+  if (name && containsPhrase(normalizedQuery, name)) {
     score += 30;
     reasons.push("skill name");
   }
@@ -43801,7 +44286,8 @@ var ROUTE_STOPWORDS = new Set([
 var RU_SYNONYM_PREFIXES = [
   ["\u0440\u0435\u0432\u044C\u044E", ["review"]],
   ["\u0440\u0435\u0432\u044C\u044E\u0435\u0440", ["review", "reviewer"]],
-  ["\u043F\u0440\u043E\u0432\u0435\u0440\u043A", ["review", "verify", "check"]],
+  ["\u043F\u0440\u043E\u0432\u0435\u0440\u043A", ["verify", "check"]],
+  ["\u043F\u0440\u043E\u0432\u0435\u0440", ["verify", "check"]],
   ["\u0440\u0435\u0430\u043B\u0438\u0437", ["implement"]],
   ["\u0438\u043C\u043F\u043B\u0435\u043C\u0435\u043D\u0442", ["implement"]],
   ["\u0432\u043D\u0435\u0434\u0440", ["implement"]],
@@ -43837,6 +44323,7 @@ var RU_SYNONYM_PREFIXES = [
   ["\u0441\u043E\u0437\u0434\u0430", ["create"]],
   ["\u0434\u0435\u043F\u043B\u043E\u0439", ["deploy"]],
   ["\u0440\u0430\u0437\u0432\u0435\u0440\u0442", ["deploy"]],
+  ["\u0440\u0430\u0437\u0432\u0435\u0440\u043D", ["deploy"]],
   ["\u0437\u0430\u0432\u0438\u0441\u0438\u043C", ["dependency", "dependencies"]],
   ["\u0438\u043D\u0442\u0435\u0440\u0432\u044C\u044E", ["interview"]],
   ["\u043E\u043F\u0440\u043E\u0441", ["interview"]],
@@ -43846,6 +44333,7 @@ var RU_SYNONYM_PREFIXES = [
   ["\u0444\u043B\u043E", ["flow"]],
   ["\u043E\u0440\u043A\u0435\u0441\u0442\u0440", ["orchestrator", "orchestrate"]],
   ["\u0430\u043D\u0430\u043B\u0438\u0437", ["analyze", "analysis"]],
+  ["\u043F\u0440\u043E\u0430\u043D\u0430\u043B\u0438\u0437", ["analyze", "analysis"]],
   ["\u0440\u0435\u0432\u044C\u044E\u0438\u0440", ["review"]]
 ];
 function routeTokens(normalized, expand = false) {
@@ -46833,9 +47321,9 @@ var SNAPSHOT_DIRECTORIES = new Set(["__snapshots__"]);
 var SNAPSHOT_SUFFIXES = [".snap"];
 function classifyPath(path133, config = DEFAULT_REVIEW_SCOPE_CONFIG) {
   const normalized = path133.replace(/\\/g, "/").replace(/^\.\//, "");
-  const segments2 = normalized.split("/").filter((segment) => segment.length > 0);
-  const basename = segments2.at(-1) ?? normalized;
-  const directories = segments2.slice(0, -1);
+  const segments = normalized.split("/").filter((segment) => segment.length > 0);
+  const basename = segments.at(-1) ?? normalized;
+  const directories = segments.slice(0, -1);
   for (const segment of directories) {
     if (VENDOR_DIRECTORIES.has(segment)) {
       return { reason: "vendored", detail: `vendored: path segment "${segment}/"` };
@@ -49574,8 +50062,11 @@ init_project_skills();
 import { readFile as readFile72, readdir as readdir24 } from "fs/promises";
 import path135 from "path";
 var PROJECT_REVIEWER_MODULE = "review";
+function escapeRegexLiteral(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 function metadataLine(content, label) {
-  const match = content.match(new RegExp(`^${label.replace(/[.*+?^${}()|[\\]\\\\]/g, "\\\\$&")}:\\s*(.+)$`, "m"));
+  const match = content.match(new RegExp(`^${escapeRegexLiteral(label)}:\\s*(.+)$`, "m"));
   return match?.[1]?.trim();
 }
 async function skillDirs(root) {
@@ -53429,9 +53920,9 @@ async function readContent(file) {
   }
   return readStdin2();
 }
-function surfaceWarnings(warnings, emit2 = console.log) {
+function surfaceWarnings(warnings, emit3 = console.log) {
   for (const warning of warnings) {
-    emit2(`  ${style.yellow(symbols.bullet)} ${warning}`);
+    emit3(`  ${style.yellow(symbols.bullet)} ${warning}`);
   }
 }
 async function handleStatus(cwd) {
@@ -53775,14 +54266,14 @@ async function handleEval(cwd, args2) {
   }
   process.exitCode = gate.status === "fail" ? 1 : 0;
 }
-function renderDecision(decision, emit2 = console.log) {
-  emit2("");
-  emit2(`  gate: ${gateLabel(decision.gate)}`);
-  emit2(`  action: ${decision.action}`);
-  emit2(`  findings: ${decision.findings.length}`);
+function renderDecision(decision, emit3 = console.log) {
+  emit3("");
+  emit3(`  gate: ${gateLabel(decision.gate)}`);
+  emit3(`  action: ${decision.action}`);
+  emit3(`  findings: ${decision.findings.length}`);
   for (const finding of decision.findings.slice(0, 20)) {
     const loc = finding.location?.line ? ` (line ${finding.location.line})` : "";
-    emit2(`    ${severityMarker(finding.severity)} ${finding.category}/${finding.policyId} \u2192 ${finding.action}${loc}`);
+    emit3(`    ${severityMarker(finding.severity)} ${finding.category}/${finding.policyId} \u2192 ${finding.action}${loc}`);
   }
 }
 function severityMarker(severity) {
@@ -53831,7 +54322,7 @@ function applyRuntimeDecision(args2, code, message2, decision, policyIsKnown) {
   if (runtime === undefined) {
     return code;
   }
-  const emit2 = (action) => {
+  const emit3 = (action) => {
     if (action.stdout !== undefined) {
       process.stdout.write(action.stdout);
     }
@@ -53843,9 +54334,9 @@ function applyRuntimeDecision(args2, code, message2, decision, policyIsKnown) {
   const outcome = decideHookOutcome(code !== 0, decision, policyIsKnown);
   switch (outcome.kind) {
     case "refuse":
-      return emit2(refusalAction(runtime, message2));
+      return emit3(refusalAction(runtime, message2));
     case "approve":
-      return emit2(allowAction(runtime));
+      return emit3(allowAction(runtime));
     case "silent":
       return 0;
   }
@@ -63322,7 +63813,7 @@ import { spawnSync as spawnSync2 } from "child_process";
 // package.json
 var package_default = {
   name: "@mrciphersmith/keryx",
-  version: "0.2.74",
+  version: "0.2.76",
   description: "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
   private: false,
   publishConfig: {
@@ -63818,9 +64309,9 @@ function createAssistantMessageStream(otui, renderer, parent) {
     parent.add(container);
     return { container, segmenter: createStreamSegmenter(), views: [], frozen: 0 };
   };
-  const paint = (m, segments2, frozen) => {
-    for (let i = m.frozen;i < segments2.length; i++) {
-      const segment = segments2[i];
+  const paint = (m, segments, frozen) => {
+    for (let i = m.frozen;i < segments.length; i++) {
+      const segment = segments[i];
       if (segment === undefined) {
         continue;
       }
@@ -63832,11 +64323,11 @@ function createAssistantMessageStream(otui, renderer, parent) {
       existing?.destroy();
       m.views[i] = createSegmentView(otui, renderer, m.container, segment);
     }
-    for (const stale of m.views.splice(segments2.length)) {
+    for (const stale of m.views.splice(segments.length)) {
       stale.destroy();
     }
     m.frozen = frozen;
-    for (const segment of segments2) {
+    for (const segment of segments) {
       if (segment.kind === "code") {
         lastCode = { lang: segment.lang, body: segment.body };
       }
@@ -63848,8 +64339,8 @@ function createAssistantMessageStream(otui, renderer, parent) {
         return;
       }
       const m = message2 ??= start();
-      const { segments: segments2, frozen } = m.segmenter.push(chunk);
-      paint(m, segments2, frozen);
+      const { segments, frozen } = m.segmenter.push(chunk);
+      paint(m, segments, frozen);
     },
     finalize: (text) => {
       const m = message2 ?? start();
@@ -63857,9 +64348,9 @@ function createAssistantMessageStream(otui, renderer, parent) {
         view.destroy();
       }
       m.frozen = 0;
-      const segments2 = segmentMarkdown(text);
-      paint(m, segments2, segments2.length);
-      if (segments2.length === 0) {
+      const segments = segmentMarkdown(text);
+      paint(m, segments, segments.length);
+      if (segments.length === 0) {
         try {
           parent.remove(m.container);
         } catch {}
@@ -66642,20 +67133,20 @@ function buildContextUsage(source) {
   const hasEstimate = source.estimateTokens !== undefined;
   const total = hasEstimate ? source.estimateTokens ?? 0 : last ?? 0;
   const estimated = hasEstimate || last === undefined;
-  const segments2 = [];
+  const segments = [];
   if (hasEstimate) {
-    segments2.push({ id: "history", label: "history (est.)", tokens: source.estimateTokens ?? 0 });
+    segments.push({ id: "history", label: "history (est.)", tokens: source.estimateTokens ?? 0 });
   }
   if (lastIn !== undefined) {
-    segments2.push({ id: "last-in", label: "last in", tokens: lastIn });
+    segments.push({ id: "last-in", label: "last in", tokens: lastIn });
   }
   if (lastOut !== undefined) {
-    segments2.push({ id: "last-out", label: "last out", tokens: lastOut });
+    segments.push({ id: "last-out", label: "last out", tokens: lastOut });
   }
   return {
     total,
     estimated,
-    segments: segments2,
+    segments,
     bar: renderUsageBar(total),
     note: total === 0 ? "No context usage yet." : "No model context window is known. The bar is relative to used tokens, not a billed limit."
   };
@@ -68271,6 +68762,161 @@ function setProjectPermissionMode(projectPath, mode, dir) {
 init_permission_mode();
 init_enrich2();
 
+// src/tui/foreground-operation.ts
+class ForegroundOperationOwner {
+  active;
+  disposed = false;
+  get signal() {
+    if (this.active === undefined) {
+      throw new Error("foreground operation has not started");
+    }
+    return this.active.controller.signal;
+  }
+  get isDisposed() {
+    return this.disposed;
+  }
+  get isActive() {
+    return this.active !== undefined;
+  }
+  accepts(token) {
+    return !this.disposed && this.active?.token === token;
+  }
+  begin() {
+    if (this.disposed) {
+      throw new Error("foreground operation owner is disposed");
+    }
+    if (this.active !== undefined) {
+      throw new Error("a foreground operation is already active");
+    }
+    const token = Symbol("foreground-operation");
+    let resolveSettled;
+    const settled = new Promise((resolve3) => {
+      resolveSettled = resolve3;
+    });
+    this.active = { token, controller: new AbortController, settled, resolveSettled };
+    return token;
+  }
+  cancel(reason) {
+    const controller = this.active?.controller;
+    if (controller !== undefined && !controller.signal.aborted) {
+      controller.abort(reason);
+    }
+  }
+  settled() {
+    return this.active?.settled ?? Promise.resolve();
+  }
+  settle(token) {
+    if (this.active?.token !== token) {
+      return;
+    }
+    const active = this.active;
+    this.active = undefined;
+    active.resolveSettled();
+  }
+  dispose() {
+    this.disposed = true;
+    this.cancel("renderer disposed");
+  }
+}
+function createForegroundOperationOwner() {
+  return new ForegroundOperationOwner;
+}
+
+class ForegroundForceHandoff {
+  pending = [];
+  awaitingSettlement = false;
+  enqueue(item) {
+    this.pending.push(item);
+    if (this.awaitingSettlement)
+      return false;
+    this.awaitingSettlement = true;
+    return true;
+  }
+  get isAwaitingSettlement() {
+    return this.awaitingSettlement;
+  }
+  get hasPending() {
+    return this.pending.length > 0;
+  }
+  takeAfterSettlement() {
+    this.awaitingSettlement = false;
+    return this.pending.shift();
+  }
+  takeNext() {
+    return this.pending.shift();
+  }
+}
+function createForegroundForceHandoff() {
+  return new ForegroundForceHandoff;
+}
+function finalizeWikiForegroundOperation(state, callbacks) {
+  if (state.disposed)
+    return "disposed";
+  callbacks.stopBusy();
+  if (state.aborted)
+    return "aborted";
+  callbacks.complete();
+  return "completed";
+}
+async function runAfterForegroundSettlement(owner, action) {
+  await owner.settled();
+  if (!owner.isDisposed) {
+    action();
+  }
+}
+function createForegroundAgentIoFacade(owner, token, io) {
+  const accepts = () => owner.accepts(token);
+  return {
+    write: (text) => {
+      if (accepts())
+        io.write(text);
+    },
+    onHistoryChange: (kind2) => {
+      if (accepts())
+        io.onHistoryChange?.(kind2);
+    },
+    onAssistantText: (text) => {
+      if (accepts())
+        io.onAssistantText?.(text);
+    },
+    onReasoning: (text) => {
+      if (accepts())
+        io.onReasoning?.(text);
+    },
+    onUsage: (usage) => {
+      if (accepts())
+        io.onUsage?.(usage);
+    },
+    onToolCall: (name, input2) => {
+      if (accepts())
+        io.onToolCall?.(name, input2);
+    },
+    onToolResult: (name, result) => {
+      if (accepts())
+        io.onToolResult?.(name, result);
+    },
+    onSystem: (text) => {
+      if (accepts())
+        io.onSystem?.(text);
+    },
+    onTerminalState: (state) => {
+      if (accepts())
+        io.onTerminalState?.(state);
+    },
+    requestApproval: async (tool, input2, meta) => {
+      if (!accepts())
+        return false;
+      const response = await io.requestApproval?.(tool, input2, meta);
+      return accepts() ? response ?? false : false;
+    },
+    onAutoApproved: (tool, input2, meta) => {
+      if (accepts())
+        io.onAutoApproved?.(tool, input2, meta);
+    },
+    permissionMode: () => accepts() ? io.permissionMode?.() ?? "ask" : "ask"
+  };
+}
+
 // src/tui/herdr-report.ts
 import net from "net";
 var SOURCE = "herdr:keryx";
@@ -72001,14 +72647,14 @@ function shortenCwd(cwd, max) {
   if (full.length <= max) {
     return full;
   }
-  const segments2 = full.split("/").filter((s) => s.length > 0);
-  for (let i = 1;i < segments2.length; i++) {
-    const candidate = `\u2026/${segments2.slice(i).join("/")}`;
+  const segments = full.split("/").filter((s) => s.length > 0);
+  for (let i = 1;i < segments.length; i++) {
+    const candidate = `\u2026/${segments.slice(i).join("/")}`;
     if (candidate.length <= max) {
       return candidate;
     }
   }
-  const last = segments2[segments2.length - 1] ?? full;
+  const last = segments[segments.length - 1] ?? full;
   return `\u2026${last.slice(last.length - (max - 1))}`;
 }
 function estimateContextTokens(history) {
@@ -72716,9 +73362,12 @@ async function launchTuiAgentShell(opts) {
   let liveDeps;
   let liveJobs;
   let detachExternal;
+  const foregroundOperation = createForegroundOperationOwner();
   try {
     const r = renderer = await createShellRenderer(otui, {
       onDestroy: () => {
+        foregroundOperation.cancel("renderer destroyed");
+        foregroundOperation.dispose();
         mountedChrome?.destroy();
         setAskUserHost(undefined);
         setSubagentFleetListener(undefined);
@@ -72782,7 +73431,6 @@ async function launchTuiAgentShell(opts) {
     const stopBusy = () => {
       chrome.stopBusy();
     };
-    let mainTurnAbortController;
     const sidebar = chrome.sidebarTop;
     sidebar.add(new otui.TextRenderable(r, { id: "sb-title", content: otui.t`${otui.bold("keryx")}` }));
     sidebar.add(new otui.TextRenderable(r, { id: "sb-model-k", content: otui.t`${otui.dim("Model")}`, marginTop: 1 }));
@@ -73813,7 +74461,7 @@ Staying in the current session.
     let mainQueue = [];
     let mainQueueSeq = 0;
     let pendingQueueEdit;
-    let priorityMainQuestion;
+    const forceHandoff = createForegroundForceHandoff();
     let sideWorkerRunning = false;
     let sideClearTimeout;
     const showSideQueueStatus = () => {
@@ -73963,15 +74611,19 @@ Staying in the current session.
         return;
       mainQueue = removeMainQueueItem(mainQueue, index);
       paintMainQueue();
-      if (mainTurnAbortController !== undefined && !mainTurnAbortController.signal.aborted) {
-        priorityMainQuestion = item;
-        mainTurnAbortController.abort();
-        mainTurnAbortController = undefined;
+      (async () => {
+        const waitsForSettlement = forceHandoff.enqueue(item);
+        foregroundOperation.cancel("queue item forced");
         io.onSystem?.(`\u25C7 main turn interrupted \u2014 q${index + 1} will run next.
 `);
-        return;
-      }
-      runLine(item.question);
+        if (!waitsForSettlement)
+          return;
+        await runAfterForegroundSettlement(foregroundOperation, () => {
+          const next = forceHandoff.takeAfterSettlement();
+          if (next !== undefined)
+            runLine(next.question);
+        });
+      })();
     };
     const handleQueueNavKey = (key) => {
       if (!queueNavActive) {
@@ -74178,6 +74830,8 @@ Staying in the current session.
         });
         switch (decision) {
           case "exit": {
+            foregroundOperation.cancel("shell exit");
+            foregroundOperation.dispose();
             (async () => {
               await closeSlateSession(slateSession, mintTimestampAttemptId);
               await deps.sweepBackgroundJobs?.();
@@ -74198,8 +74852,8 @@ Staying in the current session.
             return;
           }
           case "interrupt": {
-            if (mainTurnAbortController !== undefined && !mainTurnAbortController.signal.aborted) {
-              mainTurnAbortController.abort();
+            if (foregroundOperation.isActive) {
+              foregroundOperation.cancel("interrupted by user");
               io.onSystem?.(`\u25C7 main turn interrupted.
 `);
               return;
@@ -74626,10 +75280,13 @@ ${formatThemeList(getThemeId())}`);
       }));
       if (isWikiEnrichIntent(line)) {
         const startedAt2 = Date.now();
+        const operation2 = foregroundOperation.begin();
         (async () => {
           try {
             startBusy("planning wiki enrich\u2026");
             const plan = await planWikiEnrich(process.cwd());
+            if (foregroundOperation.signal.aborted || foregroundOperation.isDisposed)
+              return;
             stopBusy();
             const maxList = 40;
             const draftLines = plan.drafts.slice(0, maxList).map((p) => `  \xB7 ${p.relativePath}`);
@@ -74656,6 +75313,8 @@ ${formatThemeList(getThemeId())}`);
               acceptedCount: plan.accepted.length,
               total: plan.forceTargets.length
             });
+            if (foregroundOperation.signal.aborted || foregroundOperation.isDisposed)
+              return;
             input2.focus();
             if (choice2 === "cancel") {
               transcript.add(new otui.TextRenderable(r, {
@@ -74692,8 +75351,11 @@ ${formatThemeList(getThemeId())}`);
               force,
               provider: currentSel.provider,
               model: currentSel.model,
+              signal: foregroundOperation.signal,
               concurrency: 2,
               onPage: (info) => {
+                if (foregroundOperation.signal.aborted || foregroundOperation.isDisposed)
+                  return;
                 setBusyPhase(`enrich ${info.index}/${info.total} [${info.phase}] ${info.path}`);
                 setMainAgent("running", `${info.index}/${info.total}`);
                 const status = info.phase === "done" ? "done" : info.phase === "failed" ? "failed" : "running";
@@ -74706,6 +75368,8 @@ ${formatThemeList(getThemeId())}`);
                 });
               }
             });
+            if (foregroundOperation.signal.aborted || foregroundOperation.isDisposed)
+              return;
             stopBusy();
             setMainAgent(result.failed > 0 && result.enriched === 0 ? "failed" : "done", `${result.enriched}ok/${result.failed}fail`);
             const lines = [
@@ -74737,20 +75401,34 @@ ${formatThemeList(getThemeId())}`);
               saveSession();
             } catch {}
           } catch (cause) {
+            if (foregroundOperation.signal.aborted || foregroundOperation.isDisposed)
+              return;
             stopBusy();
             transcript.add(new otui.TextRenderable(r, {
               id: `we-err${uid++}`,
               content: otui.t`${otui.red(`wiki enrich failed: ${cause instanceof Error ? cause.message : String(cause)}`)}`
             }));
           } finally {
-            const secs = ((Date.now() - startedAt2) / 1000).toFixed(1);
-            transcript.add(new otui.TextRenderable(r, {
-              id: `w${uid++}`,
-              content: otui.t`${otui.dim(`worked for ${secs}s`)}`,
-              marginTop: 1
-            }));
-            stopBusy();
-            focusComposer();
+            const operationAborted = foregroundOperation.signal.aborted;
+            foregroundOperation.settle(operation2);
+            finalizeWikiForegroundOperation({ aborted: operationAborted, disposed: foregroundOperation.isDisposed }, {
+              stopBusy,
+              complete: () => {
+                const secs = ((Date.now() - startedAt2) / 1000).toFixed(1);
+                transcript.add(new otui.TextRenderable(r, {
+                  id: `w${uid++}`,
+                  content: otui.t`${otui.dim(`worked for ${secs}s`)}`,
+                  marginTop: 1
+                }));
+                focusComposer();
+                if (!forceHandoff.isAwaitingSettlement) {
+                  const next = forceHandoff.takeNext() ?? mainQueue.shift();
+                  paintMainQueue();
+                  if (next !== undefined)
+                    runLine(next.question);
+                }
+              }
+            });
           }
         })();
         return;
@@ -74758,6 +75436,7 @@ ${formatThemeList(getThemeId())}`);
       fleet.clearMatching((w) => w.id !== MAIN_AGENT_ID && !isSideWorkerId(w.id));
       sessions.clear();
       deps.resetSubagentBudget?.();
+      const operation = foregroundOperation.begin();
       setMainAgent("running", "waiting");
       startBusy("waiting for model");
       const startedAt = Date.now();
@@ -74769,8 +75448,6 @@ ${formatThemeList(getThemeId())}`);
         }
         prevOnSystem?.(text);
       };
-      const controller = new AbortController;
-      mainTurnAbortController = controller;
       const suggestNextStep = async () => {
         try {
           const lastUser = [...history].reverse().find((m) => m.role === "user")?.content ?? "";
@@ -74793,11 +75470,14 @@ ${tail}`,
           chrome.showSuggestion(result.text.trim().split(/\s+/).slice(0, 20).join(" "));
         } catch {}
       };
-      runAgentTurn(io, deps, history, line, {
-        signal: controller.signal,
+      const foregroundIo = createForegroundAgentIoFacade(foregroundOperation, operation, io);
+      runAgentTurn(foregroundIo, deps, history, line, {
+        signal: foregroundOperation.signal,
         ...slateSession !== undefined ? { slateSession } : {}
       }).finally(() => {
-        mainTurnAbortController = undefined;
+        foregroundOperation.settle(operation);
+        if (foregroundOperation.isDisposed)
+          return;
         const secs = ((Date.now() - startedAt) / 1000).toFixed(1);
         stopBusy();
         refreshWorkspaceSidebar();
@@ -74813,15 +75493,11 @@ ${tail}`,
           sbContext.content = otui.t`${otui.dim(`~${est.toLocaleString()} tokens (est)`)}`;
         }
         focusComposer();
-        if (priorityMainQuestion === undefined && mainQueue.length === 0 && !turnFailed) {
+        if (!forceHandoff.hasPending && mainQueue.length === 0 && !turnFailed) {
           suggestNextStep();
         }
-        if (priorityMainQuestion !== undefined) {
-          const next = priorityMainQuestion;
-          priorityMainQuestion = undefined;
-          runLine(next.question);
-        } else if (mainQueue.length > 0) {
-          const next = mainQueue.shift();
+        if (!forceHandoff.isAwaitingSettlement) {
+          const next = forceHandoff.takeNext() ?? mainQueue.shift();
           paintMainQueue();
           if (next !== undefined)
             runLine(next.question);
@@ -77977,7 +78653,7 @@ async function runRemoteTurn(input2) {
   let seq = 0;
   createTurnRecord({ turnId, sessionId, project: input2.project, origin: REMOTE_ORIGIN, startedAt }, input2.dir);
   let bounded2 = false;
-  const emit2 = (kind2, extra = {}) => {
+  const emit3 = (kind2, extra = {}) => {
     const event = { schemaVersion: "1.0.0", turnId, seq, kind: kind2, at: clock(), ...extra };
     if (appendTurnEvent(event, input2.dir)) {
       seq += 1;
@@ -78016,7 +78692,7 @@ async function runRemoteTurn(input2) {
     }
     return { turnId, sessionId, result };
   };
-  emit2("turn.started");
+  emit3("turn.started");
   if (input2.profile.requiredControls.isolation === "required-fail-closed") {
     const available = input2.containmentAvailable ?? (() => false);
     if (!available()) {
@@ -78080,7 +78756,7 @@ async function runRemoteTurn(input2) {
     if (event.kind === "text_delta" && typeof event.text === "string") {
       const redacted = await redactOut(security, event.text);
       assistantText += redacted;
-      emit2("assistant.delta", { text: redacted });
+      emit3("assistant.delta", { text: redacted });
     }
   }
   if (asked) {
@@ -78226,12 +78902,12 @@ function matchRoute(pathname) {
   if (FIXED_ROUTES.has(pathname)) {
     return { route: "fixed", pathname };
   }
-  const segments2 = pathname.split("/");
-  if (segments2.length === 4 && segments2[1] === "v1" && segments2[2] === "turns") {
-    return { route: "turn", turnId: segments2[3] ?? "" };
+  const segments = pathname.split("/");
+  if (segments.length === 4 && segments[1] === "v1" && segments[2] === "turns") {
+    return { route: "turn", turnId: segments[3] ?? "" };
   }
-  if (segments2.length === 5 && segments2[1] === "v1" && segments2[2] === "turns" && segments2[4] === "events") {
-    return { route: "turn-events", turnId: segments2[3] ?? "" };
+  if (segments.length === 5 && segments[1] === "v1" && segments[2] === "turns" && segments[4] === "events") {
+    return { route: "turn-events", turnId: segments[3] ?? "" };
   }
   return { route: "none" };
 }
@@ -82895,13 +83571,26 @@ async function workspaceCommand(args2) {
       return;
     }
     if (subcommand === "confirm-review") {
-      rejectUnknownOptions(args2.slice(3), new Set);
+      rejectUnknownOptions(args2.slice(3), new Set(["--acknowledge-security"]));
       const workspaceId = args2[1];
       const proposalId = args2[2];
       if (!workspaceId || !proposalId)
-        throw new Error("Usage: keryx workspace confirm-review <workspace-id> <proposal-id>");
-      const { token, expiresAt } = await mintConfirmToken(process.cwd(), workspaceId, proposalId, { securityAcknowledged: true });
-      console.log(JSON.stringify({ token, expiresAt }, null, 2));
+        throw new Error("Usage: keryx workspace confirm-review <workspace-id> <proposal-id> [--acknowledge-security]");
+      const security = await readProposalSecurityGate(process.cwd(), workspaceId, proposalId);
+      if (!security)
+        throw new Error(`keryx workspace confirm-review: cannot read proposal ${proposalId} in workspace ${workspaceId} \u2014 refusing to mint a token for a proposal whose security gate is unknown`);
+      const acknowledgeSecurity = booleanFlag(args2, "--acknowledge-security");
+      if (security.gate === "needs-approval" && !acknowledgeSecurity) {
+        throw new Error([
+          `keryx workspace confirm-review: proposal ${proposalId} is gated \`needs-approval\` \u2014 its evidence tripped the security scan.`,
+          ...security.evidenceRefs.length > 0 ? [`Evidence: ${security.evidenceRefs.join(", ")}`] : [],
+          "Read the evidence, then re-run with --acknowledge-security to state that you have.",
+          "Accepting without reading it is the thing this gate exists to prevent."
+        ].join(`
+`));
+      }
+      const { token, expiresAt } = await mintConfirmToken(process.cwd(), workspaceId, proposalId, { securityAcknowledged: security.gate === "needs-approval" && acknowledgeSecurity });
+      console.log(JSON.stringify({ token, expiresAt, securityGate: security.gate, securityAcknowledged: security.gate === "needs-approval" && acknowledgeSecurity }, null, 2));
       return;
     }
     if (subcommand === "review") {