dsh-decision-layer 0.7.2 → 0.7.4

package/lib/host/decision-context.js

@@ -0,0 +1,206 @@
+import { redactCredentials, stripInjected } from "./excerpt.js";
+import { summarizeExecution } from "./danger-gate.js";
+import { isObject } from "./types.js";
+function clip(text, maxBytes) {
+  let size = 0;
+  let result = "";
+  for (const char of text) {
+    size += Buffer.byteLength(char);
+    if (size > maxBytes) break;
+    result += char;
+  }
+  return result;
+}
+function decisionText(value, maxBytes = 1536) {
+  if (typeof value !== "string" || maxBytes <= 0) return "";
+  const clean = redactCredentials(stripInjected(value.slice(0, 32 * 1024))).trim();
+  return clip(clean, maxBytes);
+}
+function clipTail(text, maxBytes) {
+  let size = 0;
+  let result = "";
+  const chars = Array.from(text);
+  for (let index = chars.length - 1; index >= 0; index--) {
+    const char = chars[index];
+    size += Buffer.byteLength(char);
+    if (size > maxBytes) break;
+    result = char + result;
+  }
+  return result;
+}
+function decisionTail(value, maxBytes = 512) {
+  if (typeof value !== "string" || maxBytes <= 0) return "";
+  const clean = redactCredentials(stripInjected(value.slice(0, 32 * 1024))).trim();
+  return clipTail(clean, maxBytes);
+}
+const OPAQUE = /[A-Za-z0-9_+-]{24,}/g;
+const resultExcerpt = (value, maxBytes) => clip(decisionText(value, 32 * 1024).replace(OPAQUE, "[redacted]"), maxBytes);
+const messagesOf = (value) => Array.isArray(value) ? value.filter(isObject) : [];
+const textOf = (message) => Array.isArray(message.content) ? message.content.filter(isObject).filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n") : "";
+const human = (message) => message.role === "user" && (!message.source || isObject(message.source) && message.source.kind === "user");
+function historyOf(agent) {
+  try {
+    const derived = agent?.session?.deriveMessages?.();
+    return Array.isArray(derived) ? messagesOf(derived) : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function backgroundOf(messages, isHuman) {
+  const lastUser = messages.findLastIndex(isHuman);
+  const lastAssistant = messages.findLastIndex((message) => message.role === "assistant");
+  return [lastUser, lastAssistant].filter((index) => index >= 0).sort((a, b) => a - b).map((index) => {
+    const message = messages[index];
+    if (!message) return void 0;
+    const role = isHuman(message) ? "user" : "assistant";
+    const raw = textOf(message);
+    const excerpt = role === "user" ? decisionText(raw, 512) : decisionTail(raw, 512);
+    return { role, text: excerpt };
+  }).filter((item) => Boolean(item?.text));
+}
+function evidenceOf(messages) {
+  const calls = /* @__PURE__ */ new Map();
+  const evidence = [];
+  for (const message of messages) {
+    if (message.role === "assistant" && Array.isArray(message.content)) {
+      for (const block of message.content.filter(isObject)) {
+        if (block.type !== "tool-call" || typeof block.id !== "string" || typeof block.name !== "string") continue;
+        let args = block.arguments;
+        if (typeof args === "string") {
+          try {
+            args = JSON.parse(args);
+          } catch {
+            args = void 0;
+          }
+        }
+        calls.set(block.id, { name: block.name, arguments: args });
+      }
+    }
+    if (message.role !== "tool") continue;
+    const source = isObject(message.source) ? message.source : {};
+    const id = typeof message.toolCallId === "string" ? message.toolCallId : source.callId;
+    const call = typeof id === "string" ? calls.get(id) : void 0;
+    const name = call?.name ?? (typeof message.name === "string" ? message.name : typeof message.toolName === "string" ? message.toolName : "");
+    if (!name) continue;
+    const item = { tool: decisionText(name, 96), outcome: message.isError === true ? "error" : "ok" };
+    if (call) {
+      const summary = summarizeExecution(call);
+      if (summary.command) item.command = decisionText(summary.command, 160);
+      if (summary.path) item.path = decisionText(summary.path, 160);
+    }
+    if (["bash", "pwsh", "shell", "exec", "terminal", "run_command"].includes(name)) {
+      const result = resultExcerpt(textOf(message), 256);
+      if (result) item.result = result;
+    }
+    evidence.push(item);
+  }
+  const bounded = evidence.length > 12 ? [...evidence.slice(0, 4), ...evidence.slice(-8)] : [...evidence];
+  while (Buffer.byteLength(JSON.stringify(bounded)) > 4096) bounded.shift();
+  return bounded;
+}
+const REPLACEMENTS = /* @__PURE__ */ new Set(["compact-checkpoint", "dsh-rewind"]);
+function afterLastReplacement(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const message = messages[i];
+    if (!message) continue;
+    const source = isObject(message.source) ? message.source : void 0;
+    if (source && typeof source.kind === "string" && REPLACEMENTS.has(source.kind)) return messages.slice(i + 1);
+  }
+  return messages;
+}
+function boundaryHolds(history, boundary) {
+  if (boundary.start <= 0) return true;
+  const previous = history[boundary.start - 1];
+  if (!previous) return false;
+  return previous === boundary.anchor || boundary.anchorId !== void 0 && previous.id === boundary.anchorId;
+}
+function snapshotOf(history, boundary, isHuman) {
+  const messages = history ?? [];
+  const lastHuman = messages.findLastIndex(isHuman);
+  const window = boundary === void 0 ? messages.slice(lastHuman >= 0 ? lastHuman : messages.length) : boundary.broken ? [] : boundaryHolds(messages, boundary) ? messages.slice(boundary.start) : [];
+  const current = afterLastReplacement(window);
+  const requests = boundary?.requests ?? current.filter(isHuman).map((message) => decisionText(textOf(message), 8192));
+  const request = decisionText(requests.at(-1) ?? "", 1536);
+  const evidence = evidenceOf(current);
+  const context = {
+    request,
+    // Earlier real requests in this turn stay visible as background: with only the
+    // last one, a short follow-up ("继续") would hide the main task. Pre-turn
+    // context is kept too, but the size cap below drops it first.
+    background: [
+      ...boundary?.background ?? backgroundOf(messages.slice(0, Math.max(lastHuman, 0)), isHuman),
+      ...requests.slice(0, -1).slice(-2).map((text) => ({ role: "user", text: decisionText(text, 1024) }))
+    ].slice(-4),
+    progress: evidence.slice(-3)
+  };
+  while (Buffer.byteLength(JSON.stringify(context.progress)) > 1024 && context.progress.length > 1) context.progress.shift();
+  while (Buffer.byteLength(JSON.stringify(context)) > 4096 && (context.background.length || context.progress.length > 1)) {
+    if (context.background.length) context.background.shift();
+    else context.progress.shift();
+  }
+  return {
+    context,
+    evidence,
+    // Completion conditions come from the latest real request only. Joining a
+    // turn's requests would resurrect work the user just cancelled ("drop the
+    // earlier list, only review"); when the latest request has no explicit
+    // conditions the check skips rather than infer from an older revision.
+    conditionsText: requests.at(-1) ?? ""
+  };
+}
+function createDecisionContext({ ignored } = {}) {
+  const boundaries = /* @__PURE__ */ new WeakMap();
+  const isHuman = (message) => human(message) && !(typeof message.id === "string" && ignored?.(message.id) === true);
+  const enter = (agent, position) => {
+    const known = agent ? boundaries.get(agent) : void 0;
+    const first = !known || known.turn !== position.turn;
+    const inputs = messagesOf(position.messages).filter(isHuman).map((message) => decisionText(textOf(message), 8192)).filter(Boolean);
+    if (!first && inputs.length === 0) return { changed: false };
+    const history = historyOf(agent);
+    let boundary = known;
+    const anchor = history?.at(-1);
+    if (first) {
+      boundary = {
+        turn: position.turn,
+        start: history?.length ?? 0,
+        anchor,
+        broken: history === void 0,
+        ...isObject(anchor) && typeof anchor.id === "string" ? { anchorId: anchor.id } : {},
+        requests: [],
+        background: history ? backgroundOf(history, isHuman) : []
+      };
+      if (agent) boundaries.set(agent, boundary);
+    } else if (boundary?.broken) {
+      boundary.broken = history === void 0;
+      boundary.start = history?.length ?? 0;
+      boundary.anchor = anchor;
+      if (isObject(anchor) && typeof anchor.id === "string") boundary.anchorId = anchor.id;
+      else delete boundary.anchorId;
+      boundary.background = history ? backgroundOf(history, isHuman) : [];
+    }
+    const active = boundary;
+    active.requests.push(...inputs);
+    active.requests = active.requests.slice(-8);
+    return { changed: true, snapshot: snapshotOf(history, active, isHuman) };
+  };
+  return {
+    enter(agent, position) {
+      try {
+        return enter(agent, position);
+      } catch {
+        return { changed: false };
+      }
+    },
+    snapshot(agent) {
+      try {
+        return snapshotOf(historyOf(agent), agent ? boundaries.get(agent) : void 0, isHuman);
+      } catch {
+        return { context: { request: "", background: [], progress: [] }, conditionsText: "", evidence: [] };
+      }
+    }
+  };
+}
+export {
+  createDecisionContext,
+  decisionText
+};

package/lib/host/excerpt.d.ts

@@ -22,4 +22,5 @@ export declare const TASK_EXCERPT_LIMIT = 512;
  * a secret to the log.
  */
 export declare function redactCredentials(input: string): string;
+export declare function stripInjected(input: string): string;
 export declare function taskExcerpt(state: unknown, limit?: number): string | undefined;

package/lib/host/excerpt.js

@@ -1,9 +1,11 @@
 const MAX_INPUT = 8 * 1024;
 const TASK_EXCERPT_LIMIT = 512;
 const TOKEN_KEYS = String.raw`token|api[ _-]*key`;
-const PHRASE_KEYS = String.raw`password|passwd|passphrase|secret`;
+const PHRASE_KEYS = String.raw`password|passw(?:or)?d|passphrase|secret[ _-]?key|access[ _-]?key|private[ _-]?key|secret`;
 const CN_KEYS = String.raw`密码|口令|密码短语|密钥|令牌|凭证|私钥`;
 const COMBINED_KEYS = String.raw`${PHRASE_KEYS}|${TOKEN_KEYS}`;
+const ENV_PHRASE_KEYS = String.raw`PASSW(?:OR)?D|SECRET|ACCESS[_-]?KEY|PRIVATE[_-]?KEY`;
+const ENV_TOKEN_KEYS = String.raw`TOKEN|API[_-]?KEY`;
 const SEPARATOR = String.raw`[:=：＝]`;
 const VALUE = String.raw`(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\s,;}，；、]+)`;
 const CLAUSE = String.raw`(?:"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|[^\r\n,;，；、]*)`;
@@ -30,6 +32,13 @@ const RULE = {
   asciiCopula: new RegExp(String.raw`(\b(?:${COMBINED_KEYS})\b\s*(?:${COPULA})\s*)${VALUE_LIKE}${VALUE}`, "gi"),
   cnCopula: new RegExp(String.raw`((?:${CN_KEYS})\s*(?:是|为)\s*)${VALUE_LIKE}${VALUE}`, "g"),
   flag: new RegExp(String.raw`(^|\s)(--(?:${COMBINED_KEYS})(?:\s+|=))${VALUE}`, "gi"),
+  // Env-style keys are often a suffix of a longer identifier (`DB_PASSWORD`,
+  // `AWS_SECRET_ACCESS_KEY`), where `\b` cannot match across `_`. JSON and quoted
+  // .env output place a closing quote between key and separator, and a quoted
+  // passphrase may contain spaces, so the key allows a quote and the value is the
+  // whole clause (over-redaction is the accepted direction).
+  envPhrase: new RegExp(String.raw`([A-Za-z0-9_]*(?:${ENV_PHRASE_KEYS})[A-Za-z0-9_]*["']?\s*${SEPARATOR}\s*)${CLAUSE}`, "gi"),
+  envToken: new RegExp(String.raw`([A-Za-z0-9_]*(?:${ENV_TOKEN_KEYS})[A-Za-z0-9_]*["']?\s*${SEPARATOR}\s*)${VALUE}`, "gi"),
   // Legacy space form (`token abc`), but never swallow a copula: the rule above
   // masks the value that follows it.
   loose: new RegExp(String.raw`(\b(?:${COMBINED_KEYS})\b\s+)(?!(?:${COPULA})(?:\s|$)|${SEPARATOR})${VALUE}`, "gi")
@@ -45,18 +54,23 @@ function redactCredentials(input) {
   text = text.replace(RULE.asciiCopula, "$1[redacted]");
   text = text.replace(RULE.cnCopula, "$1[redacted]");
   text = text.replace(RULE.flag, "$1$2[redacted]");
+  text = text.replace(RULE.envPhrase, "$1[redacted]");
+  text = text.replace(RULE.envToken, "$1[redacted]");
   text = text.replace(RULE.loose, "$1[redacted]");
   for (const [pattern, replacement] of TOKEN_SHAPES) text = text.replace(pattern, replacement);
   return text;
 }
+function stripInjected(input) {
+  return input.replace(/<(openviking-context|system-reminder)\b[^>]*>[\s\S]*?<\/\1>/gi, " ").replace(/<(openviking-context|system-reminder)\b[\s\S]*$/i, " ");
+}
 function taskExcerpt(state, limit = TASK_EXCERPT_LIMIT) {
   if (typeof state !== "string") return void 0;
-  const stripped = state.slice(0, MAX_INPUT).replace(/<(openviking-context|system-reminder)\b[^>]*>[\s\S]*?<\/\1>/gi, " ").replace(/<(openviking-context|system-reminder)\b[\s\S]*$/i, " ");
-  const text = redactCredentials(stripped).replace(/\s+/g, " ").trim();
+  const text = redactCredentials(stripInjected(state.slice(0, MAX_INPUT))).replace(/\s+/g, " ").trim();
   return text ? text.slice(0, limit) : void 0;
 }
 export {
   TASK_EXCERPT_LIMIT,
   redactCredentials,
+  stripInjected,
   taskExcerpt
 };

package/lib/host/index.js

@@ -11,6 +11,7 @@ import { createTaskCompletion } from "./task-completion.js";
 import { createLoopGuard } from "./loop-guard.js";
 import { createLogStore } from "./log-store.js";
 import { createStateStore } from "./state-store.js";
+import { createDecisionContext } from "./decision-context.js";
 import { analyzeSessionLogs, reconstructSessionSeed, listSessionDecisions } from "./log-analyze.js";
 import { isObject } from "./types.js";
 const name = "dsh-decision-layer";
@@ -35,50 +36,6 @@ function lastAssistantText(agent) {
     return "";
   }
 }
-function stepTaskText(messages) {
-  try {
-    if (!Array.isArray(messages)) return "";
-    return messages.map(asMessage).filter((message) => message?.role === "user" && Array.isArray(message.content)).flatMap((message) => message.content.filter((block) => isObject(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text)).join("\n").slice(0, 8 * 1024);
-  } catch {
-    return "";
-  }
-}
-function turnUserText(agent) {
-  try {
-    const messages = derivedMessages(agent);
-    if (!messages) return "";
-    const texts = [];
-    let collecting = false;
-    for (let i = messages.length - 1; i >= 0; i--) {
-      const message = asMessage(messages[i]);
-      if (message?.role === "user" && Array.isArray(message.content)) {
-        collecting = true;
-        texts.unshift(message.content.filter((block) => isObject(block) && block.type === "text" && typeof block.text === "string").map((block) => block.text).join("\n"));
-      } else if (collecting) break;
-    }
-    return texts.join("\n").slice(0, 8 * 1024);
-  } catch {
-    return "";
-  }
-}
-function turnToolEvidence(agent) {
-  try {
-    const messages = derivedMessages(agent);
-    if (!messages) return [];
-    const evidence = [];
-    for (const item of messages) {
-      const message = asMessage(item);
-      if (message?.role !== "tool" || !Array.isArray(message.content)) continue;
-      const tool = typeof message.name === "string" ? message.name : typeof message.toolName === "string" ? message.toolName : "";
-      if (!tool) continue;
-      evidence.push({ tool: tool.slice(0, 128), outcome: message.isError === true ? "error" : "ok" });
-      if (evidence.length >= 40) break;
-    }
-    return evidence;
-  } catch {
-    return [];
-  }
-}
 function agentTools(ctx, agent) {
   try {
     const schemas = typeof ctx.tools?.schemas === "function" ? ctx.tools.schemas(agent) : void 0;
@@ -108,6 +65,20 @@ async function apply(ctx, options = {}) {
   if (typeof ctx.effect === "function") ctx.effect(() => () => {
     void stateStore.dispose();
   });
+  const steeredIds = /* @__PURE__ */ new Map();
+  const rememberSteer = (message) => {
+    const id = isObject(message) && typeof message.id === "string" ? message.id : void 0;
+    if (!id) return;
+    steeredIds.set(id, true);
+    if (steeredIds.size > 256) steeredIds.delete(steeredIds.keys().next().value);
+  };
+  const steerAgent = (agent, text) => {
+    if (typeof agent.steer !== "function") throw new Error("Agent cannot be steered");
+    const message = createUserMessage({ content: [{ type: "text", text }], source: { kind: "user" } });
+    rememberSteer(message);
+    return agent.steer(message);
+  };
+  const decisionContext = createDecisionContext({ ignored: (id) => steeredIds.has(id) });
   const gate = createDangerGate({
     evaluate: (input, request) => backend.evaluate(input, request),
     sessions,
@@ -116,8 +87,10 @@ async function apply(ctx, options = {}) {
     // is at least this confident. Read per call so an edit takes effect at once.
     minConfidence: async () => (await resolveConfig({ path })).gateSettings?.minConfidence,
     // Read lazily (only when a dangerous call is recorded) so ordinary tool calls
-    // never pay for deriveMessages().
-    taskText: (agent) => turnUserText(agent)
+    // never pay for deriveMessages(). The gate itself still sends only the call
+    // summary; this excerpt is local-log context, from the same snapshot the other
+    // decision points use.
+    taskText: (agent) => decisionContext.snapshot(agent).context.request
   });
   const loopGuard = createLoopGuard({ sessions });
   const featureOn = async (key) => {
@@ -152,19 +125,17 @@ async function apply(ctx, options = {}) {
       evaluate: (input, request) => backend.evaluate(input, request),
       sessions,
       settings: async () => (await resolveConfig({ path })).checkSettings,
-      steer: (agent, text) => {
-        if (typeof agent.steer !== "function") throw new Error("Agent cannot be steered");
-        return agent.steer(createUserMessage({ content: [{ type: "text", text }], source: { kind: "user" } }));
-      }
+      steer: steerAgent
     });
     const installCheck = () => ctx.on("agent/turn-stopping", async (payload) => {
       if (!await featureOn("check")) return;
+      const snapshot = decisionContext.snapshot(payload.agent);
       return selfCheck.review({
         agent: payload.agent,
         turn: payload.turn,
         signal: payload.signal,
         output: lastAssistantText(payload.agent),
-        userText: turnUserText(payload.agent)
+        context: snapshot.context
       });
     });
     if (typeof ctx.effect === "function") ctx.effect(installCheck);
@@ -173,20 +144,21 @@ async function apply(ctx, options = {}) {
       evaluate: (input, request) => backend.evaluate(input, request),
       sessions,
       settings: async () => (await resolveConfig({ path })).completeSettings,
-      steer: (agent, text) => {
-        if (typeof agent.steer !== "function") throw new Error("Agent cannot be steered");
-        return agent.steer(createUserMessage({ content: [{ type: "text", text }], source: { kind: "user" } }));
-      }
+      steer: steerAgent
     });
     const installCompletion = () => ctx.on("agent/turn-stopping", async (payload) => {
       if (!await featureOn("complete")) return;
+      const snapshot = decisionContext.snapshot(payload.agent);
       return taskCompletion.review({
         agent: payload.agent,
         turn: payload.turn,
         signal: payload.signal,
         output: lastAssistantText(payload.agent),
-        userText: turnUserText(payload.agent),
-        evidence: turnToolEvidence(payload.agent)
+        // Conditions come only from this turn's real user text; evidence only from
+        // this turn's window, so an earlier task's successes cannot vouch for it.
+        userText: snapshot.conditionsText,
+        evidence: snapshot.evidence,
+        context: snapshot.context
       });
     });
     if (typeof ctx.effect === "function") ctx.effect(installCompletion);
@@ -197,46 +169,71 @@ async function apply(ctx, options = {}) {
       settings: async () => (await resolveConfig({ path })).narrowSettings
     });
     const narrowedTurns = /* @__PURE__ */ new Map();
-    const installNarrowingHook = () => ctx.on("agent/pre-step", async (payload, next) => {
-      const agent = payload?.agent;
-      const id = agent?.session?.id;
-      const turn = payload?.turn;
-      if (typeof id === "string") await sessions.ensureLoaded(id);
-      if (typeof id === "string" && Number.isInteger(turn)) {
-        const state = narrowedTurns.get(id);
-        if (!state || state.turn !== turn) {
-          state?.dispose?.();
-          narrowedTurns.delete(id);
-          if (await featureOn("narrow")) {
-            const entry = { turn, dispose: void 0 };
-            narrowedTurns.set(id, entry);
-            if (narrowedTurns.size > 1024) {
-              const oldest = narrowedTurns.keys().next().value;
-              if (oldest !== id) {
-                narrowedTurns.get(oldest)?.dispose?.();
-                narrowedTurns.delete(oldest);
+    const releaseNarrowing = (id) => {
+      const entry = narrowedTurns.get(id);
+      if (!entry) return;
+      try {
+        entry.dispose?.();
+      } catch {
+      }
+      narrowedTurns.delete(id);
+    };
+    const installNarrowingHook = () => {
+      const disposeHook = ctx.on("agent/pre-step", async (payload, next) => {
+        const agent = payload?.agent;
+        const id = agent?.session?.id;
+        const turn = payload?.turn;
+        if (typeof id === "string") await sessions.ensureLoaded(id);
+        if (typeof id === "string" && Number.isInteger(turn)) {
+          const entered = decisionContext.enter(agent, { turn, messages: payload.messages });
+          const previous = narrowedTurns.get(id);
+          const turnChanged = !previous || previous.turn !== turn;
+          if (turnChanged || entered.changed) {
+            releaseNarrowing(id);
+            if (await featureOn("narrow")) {
+              const entry = { turn, dispose: void 0 };
+              narrowedTurns.set(id, entry);
+              if (narrowedTurns.size > 1024) {
+                const oldest = narrowedTurns.keys().next().value;
+                if (oldest !== id) releaseNarrowing(oldest);
               }
-            }
-            try {
-              const result = await narrowing.review({
-                agent,
-                turn,
-                signal: payload.signal,
-                state: stepTaskText(payload.messages),
-                tools: agentTools(ctx, agent)
-              });
-              if (result.mode === "enforce" && result.applied && typeof agent?.ctx?.tools?.restrict === "function") {
-                entry.dispose = agent.ctx.tools.restrict({ allow: result.keep });
+              try {
+                const { context } = entered.snapshot ?? decisionContext.snapshot(agent);
+                const result = await narrowing.review({
+                  agent,
+                  turn,
+                  step: payload.step,
+                  signal: payload.signal,
+                  state: { request: context.request, background: context.background, progress: context.progress },
+                  taskText: context.request,
+                  tools: agentTools(ctx, agent)
+                });
+                if (result.mode === "enforce" && result.applied && typeof agent?.ctx?.tools?.restrict === "function") {
+                  const restriction = agent.ctx.tools.restrict({ allow: result.keep });
+                  if (narrowedTurns.get(id) === entry) entry.dispose = restriction;
+                  else restriction?.();
+                }
+              } catch {
               }
-            } catch {
             }
           }
         }
-      }
-      return next();
-    });
+        return next();
+      });
+      return () => {
+        disposeHook?.();
+        for (const key of [...narrowedTurns.keys()]) releaseNarrowing(key);
+      };
+    };
     if (typeof ctx.effect === "function") ctx.effect(installNarrowingHook);
     else installNarrowingHook();
+    const installNarrowingRelease = () => ctx.on("session/event", (subject, event) => {
+      if (!isObject(event) || event.type !== "turn/end") return;
+      const id = isObject(subject) && typeof subject.id === "string" ? subject.id : void 0;
+      if (id !== void 0) releaseNarrowing(id);
+    });
+    if (typeof ctx.effect === "function") ctx.effect(installNarrowingRelease);
+    else installNarrowingRelease();
   }
   const rawSkill = await readFile(new URL("../../skills/decision-layer/SKILL.md", import.meta.url), "utf8");
   const content = rawSkill.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, "").trim();
@@ -273,7 +270,7 @@ async function apply(ctx, options = {}) {
       port,
       trendConfig: (await resolveConfig({ path })).checkSettings
     });
-    const listRows = (sessionId, { page, pageSize } = {}) => listSessionDecisions(sessionId, { port, page, pageSize });
+    const listRows = (sessionId, { page, pageSize, lowOnly } = {}) => listSessionDecisions(sessionId, { port, page, pageSize, lowOnly });
     const unregister = createManagerRoutes({ path, sessions, backend, logStore, analyze, listRows, bindHost: web.webServer.host }).map((route) => web.webServer.register(route));
     return () => {
       unregister.forEach((dispose) => dispose());

package/lib/host/log-analyze.d.ts

@@ -106,11 +106,12 @@ export declare function reconstructSessionSeed(sessionId: unknown, { dir, port,
     maxLog?: number;
     readStream?: ReadStream;
 }): Promise<SessionSeed | undefined>;
-export declare function listSessionDecisions(sessionId: unknown, { dir, port, page, pageSize, readStream }?: {
+export declare function listSessionDecisions(sessionId: unknown, { dir, port, page, pageSize, lowOnly, readStream }?: {
     dir?: string;
     port?: number;
     page?: number;
     pageSize?: number;
+    lowOnly?: boolean;
     readStream?: ReadStream;
 }): Promise<{
     entries: LogRow[];

package/lib/host/log-analyze.js

@@ -220,7 +220,7 @@ async function reconstructSessionSeed(sessionId, { dir, port, trendConfig, maxLo
   if (decisions.size === 0) return void 0;
   return buildSeed(decisions, { maxLog, trendConfig });
 }
-async function listSessionDecisions(sessionId, { dir, port, page = 1, pageSize = 100, readStream = createReadableStream } = {}) {
+async function listSessionDecisions(sessionId, { dir, port, page = 1, pageSize = 100, lowOnly = false, readStream = createReadableStream } = {}) {
   if (typeof sessionId !== "string" || !sessionId.trim()) throw new Error("Invalid session id");
   const size = Number.isSafeInteger(pageSize) && pageSize > 0 && pageSize <= 500 ? pageSize : 100;
   const records = [];
@@ -229,7 +229,8 @@ async function listSessionDecisions(sessionId, { dir, port, page = 1, pageSize =
     if (record.sessionId === sessionId) records.push(record);
   }
   const { decisions } = foldSession(records);
-  const rows = [...decisions.values()].sort((a, b) => atOf(b) - atOf(a));
+  const all = [...decisions.values()].sort((a, b) => atOf(b) - atOf(a));
+  const rows = lowOnly ? all.filter((record) => record.kind === "check" && record.outcome === "low") : all;
   const total = rows.length;
   const pages = Math.max(1, Math.ceil(total / size));
   const current = Math.min(Math.max(1, Number.isSafeInteger(page) ? page : 1), pages);

package/lib/host/manager-api.d.ts

@@ -13,6 +13,7 @@ export type ManagerRouteDeps = {
     listRows?: (id: string, options: {
         page: number;
         pageSize: number;
+        lowOnly?: boolean;
     }) => Promise<unknown>;
     env?: Record<string, string | undefined>;
     bindHost?: string;

package/lib/host/manager-api.js

@@ -111,7 +111,9 @@ function createManagerRoutes({ path, sessions, backend, logStore, analyze, listR
       }
     }),
     // One newest-first page of this session's full persisted decision rows, for
-    // the analysis tab's paginated log. Rows carry the same panel fields as /log,
+    // the analysis tab's paginated log. `lowOnly=1` filters to low self-check
+    // scores before paging, so a single low score in a long session is one click
+    // away instead of a manual scan. Rows carry the same panel fields as /log,
     // including the gate's already-redacted and length-bounded command/path, so
     // this exposes nothing the recent-rows route does not already.
     route("logrows", {
@@ -121,8 +123,9 @@ function createManagerRoutes({ path, sessions, backend, logStore, analyze, listR
         const params = new URL(req.url ?? "/", "http://localhost").searchParams;
         const page = Number.parseInt(params.get("page") ?? "1", 10);
         const pageSize = Number.parseInt(params.get("pageSize") ?? "100", 10);
+        const lowOnly = params.get("lowOnly") === "1";
         try {
-          return await listRows(id, { page: Number.isNaN(page) ? 1 : page, pageSize: Number.isNaN(pageSize) ? 100 : pageSize });
+          return await listRows(id, { page: Number.isNaN(page) ? 1 : page, pageSize: Number.isNaN(pageSize) ? 100 : pageSize, ...lowOnly ? { lowOnly } : {} });
         } catch (error) {
           if (error?.code === "BAD_REQUEST") throw error;
           throw codedError("log rows failed", "INTERNAL");

package/lib/host/narrowing.d.ts

@@ -19,8 +19,11 @@ export declare function relevanceQuestions(state: unknown, tools: readonly ToolC
 export type NarrowTurn = {
     agent?: AgentLike;
     turn?: number;
+    step?: number;
     signal?: AbortSignal;
     state?: unknown;
+    /** Raw request text for the log row; `state` may now be a structured object. */
+    taskText?: unknown;
     tools?: unknown;
 };
 export type NarrowResult = {

package/lib/host/narrowing.js

@@ -106,9 +106,10 @@ function createNarrowing({
     }
     if (typeof sessions.log !== "function") return;
     try {
-      const task = taskExcerpt(turn?.state);
+      const task = taskExcerpt(turn?.taskText ?? turn?.state);
       const context = task ? { task } : {};
       if (Number.isSafeInteger(turn?.turn) && turn?.turn >= 0) context.turn = turn?.turn;
+      if (Number.isSafeInteger(turn?.step) && turn?.step >= 0) context.step = turn?.step;
       sessions.log(id, { kind: "narrow", outcome, ...context, ...detail });
     } catch {
     }
@@ -146,7 +147,7 @@ function createNarrowing({
       const keptNames = names.filter(alwaysKeep);
       const optional = tools.filter((tool) => !alwaysKeep(tool.name));
       if (optional.length < minCandidates) return { ...skip, keep: names };
-      const hasState = typeof turn?.state === "string" ? turn.state.trim().length > 0 : isObject(turn?.state) ? Object.keys(turn.state).length > 0 : false;
+      const hasState = typeof turn?.taskText === "string" ? turn.taskText.trim().length > 0 : typeof turn?.state === "string" ? turn.state.trim().length > 0 : isObject(turn?.state) ? Object.keys(turn.state).length > 0 : false;
       if (!hasState) return { ...skip, keep: names };
       const id = turn?.agent?.session?.id;
       if (sessions && typeof id === "string") {

package/lib/host/self-check.d.ts

@@ -1,6 +1,6 @@
-import type { AgentLike, CheckSettings, EvaluateInput, Evaluator, SessionsFace } from './types.js';
+import type { AgentLike, CheckSettings, DecisionContext, EvaluateInput, Evaluator, SessionsFace } from './types.js';
 export declare const DEFAULT_RUBRIC: readonly string[];
-export declare function scoreQuestion(output: unknown, rubric?: readonly string[]): EvaluateInput;
+export declare function scoreQuestion(output: unknown, rubric?: readonly string[], context?: DecisionContext): EvaluateInput;
 export declare const DEFAULT_MIN_CONFIDENCE = 0.4;
 export type CheckTurn = {
     agent?: AgentLike;
@@ -8,6 +8,7 @@ export type CheckTurn = {
     signal?: AbortSignal;
     output?: unknown;
     userText?: unknown;
+    context?: DecisionContext;
 };
 export type CheckResult = {
     evaluated: boolean;