odai-dsh-agent 0.2.5 → 0.2.7

package/preset/odai/runtime/routing-context.mjs

@@ -1,321 +1,442 @@
 import { createHash } from "node:crypto";
-
+import { classifyResponsibilityInterruptionText } from "./router.mjs";
+import { isUnknownRecord } from "./runtime-types.mjs";
 const DEFAULT_MAX_CHARS = 12_000;
 const DEFAULT_MAX_EVENTS = 80;
+const DEFAULT_MAX_ENTRY_CHARS = 4_000;
 const REQUIREMENT_PATTERNS = [/requirement/iu, /acceptance/iu, /需求/u, /要求/u, /目标/u, /验收/u];
-const ACCEPTANCE_PATTERNS = [/\bA\d+\b/u, /accept(?:ance)?/iu, /验收/u, /通过条件/u, /完成条件/u];
 const DIFF_OUTPUT_PATTERNS = [/diff --git/iu, /^---\s+a\/[^\n]+\n\+\+\+\s+b\//imu];
 const DIFF_COMMAND_PATTERNS = [/^\s*git(?:\.exe)?\s+diff(?:\s|$)/iu];
 const TEST_COMMAND_PATTERNS = [
-  /^\s*(?:&\s*)?(?:"[^"\r\n]*[\\/]node(?:\.exe)?"|[A-Za-z]:\\[^\s"\r\n]*[\\/]node(?:\.exe)?|\/[^\s"\r\n]*\/node|node(?:\.exe)?)\s+--test(?:\s|$)/iu,
-  /^\s*(?:npm|pnpm|yarn)(?:\.cmd)?(?:\s+--(?:prefix|dir)\s+(?:"[^"]+"|\S+))?\s+(?:run\s+)?test(?:\s|$)/iu,
-  /^\s*(?:pytest|vitest|jest|mocha)(?:\.cmd)?(?:\s|$)/iu,
-  /^\s*(?:go|cargo|dotnet)\s+test(?:\s|$)/iu,
+    /^\s*(?:&\s*)?(?:"[^"\r\n]*[\\/]node(?:\.exe)?"|[A-Za-z]:\\[^\s"\r\n]*[\\/]node(?:\.exe)?|\/[^\s"\r\n]*\/node|node(?:\.exe)?)\s+--test(?:\s|$)/iu,
+    /^\s*(?:npm|pnpm|yarn)(?:\.cmd)?(?:\s+--(?:prefix|dir)\s+(?:"[^"]+"|\S+))?\s+(?:run\s+)?test(?:[:.][\w.-]+)?(?:\s|$)/iu,
+    /^\s*(?:(?:npx|pnpm\s+exec|yarn\s+exec)(?:\.cmd)?|npm(?:\.cmd)?\s+exec(?:\s+--)?)\s+(?:--yes\s+)?(?:pytest|vitest|jest|mocha)(?:\.cmd)?(?:\s|$)/iu,
+    /^\s*(?:pytest|vitest|jest|mocha)(?:\.cmd)?(?:\s|$)/iu,
+    /^\s*(?:go|cargo|dotnet)\s+test(?:\s|$)/iu,
+    /^\s*(?:(?:\.\/)?(?:[\w.-]+\/)*mvnw(?:\.cmd)?|mvn(?:\.cmd)?)\s+(?:[^\r\n]*\s)?(?:test|verify)(?:\s|$)/iu,
+    /^\s*(?:\.\/)?gradlew(?:\.bat)?\s+(?:[^\r\n]*\s)?test(?:\s|$)/iu,
 ];
 const TEST_SUCCESS_PATTERNS = [
-  /exit code:\s*0/iu,
-  /(?:^|\n)[^\n]*(?:pass|passed)\s*[:=]?\s*[1-9]\d*/iu,
-  /(?:^|\n)[^\n]*[1-9]\d*\s+passed\b/iu,
-  /(?:^|\n)[^\n]*fail(?:ed)?\s*[:=]?\s*0\b/iu,
-  /\btests?\s+\d+[^\n]*(?:pass|passed)\s+[1-9]\d*[^\n]*fail(?:ed)?\s+0\b/iu,
+    /exit code:\s*0/iu,
+    /(?:^|\n)[^\n]*(?:pass|passed)\s*[:=]?\s*[1-9]\d*/iu,
+    /(?:^|\n)[^\n]*[1-9]\d*\s+passed\b/iu,
+    /(?:^|\n)[^\n]*fail(?:ed)?\s*[:=]?\s*0\b/iu,
+    /\btests?\s+\d+[^\n]*(?:pass|passed)\s+[1-9]\d*[^\n]*fail(?:ed)?\s+0\b/iu,
 ];
 const TEST_FAILURE_PATTERNS = [
-  /exit code:\s*[1-9]\d*/iu,
-  /(?:^|\n)[^\n]*fail(?:ed)?\s*[:=]?\s*[1-9]\d*/iu,
-  /\b(?:tests?|test suite) failed\b/iu,
+    /exit code:\s*[1-9]\d*/iu,
+    /(?:^|\n)[^\n]*fail(?:ed)?\s*[:=]?\s*[1-9]\d*/iu,
+    /\b(?:tests?|test suite) failed\b/iu,
 ];
 const WRITE_TOOL_NAMES = new Set(["edit", "write", "apply_patch"]);
 const SHELL_TOOL_NAMES = new Set(["bash", "pwsh", "shell", "powershell"]);
 const SHELL_CONTROL_PATTERN = /[;&|<>]/u;
 const READ_ONLY_SHELL_COMMAND_PATTERNS = [
-  /^\s*git(?:\.exe)?\s+(?:status|log|show|rev-parse|ls-files|branch)(?:\s|$)/iu,
-  /^\s*(?:Get-[A-Za-z]+|Select-String|Test-Path)(?:\s|$)/iu,
-  /^\s*(?:rg|grep|find|ls|pwd|cat|head|tail|wc|where|which)(?:\.exe)?(?:\s|$)/iu,
-  /^\s*node(?:\.exe)?\s+--check(?:\s|$)/iu,
+    /^\s*git(?:\.exe)?\s+(?:status|log|show|rev-parse|ls-files|branch)(?:\s|$)/iu,
+    /^\s*(?:Get-[A-Za-z]+|Select-String|Test-Path)(?:\s|$)/iu,
+    /^\s*(?:rg|grep|find|ls|pwd|cat|head|tail|wc|where|which|lsof|ps|netstat|ss)(?:\.exe)?(?:\s|$)/iu,
+    /^\s*(?:npx(?:\.cmd)?|pnpm(?:\.cmd)?\s+exec|yarn(?:\.cmd)?\s+exec|npm(?:\.cmd)?\s+exec(?:\s+--)?)?\s*prettier(?:\.cmd)?\s+--check(?:\s|$)/iu,
+    /^\s*node(?:\.exe)?\s+--check(?:\s|$)/iu,
 ];
 const WRITE_COMMAND_PATTERNS = [
-  /(?:^|\s)(?:git\s+apply|apply_patch|sed\s+-i|perl\s+-pi)(?:\s|$)/iu,
-  /(?:^|\s)(?:Set-Content|Add-Content|Out-File|Remove-Item|Move-Item|Copy-Item|New-Item)(?:\s|$)/iu,
-  /(?:^|\s)(?:rm|mv|cp|mkdir|touch)(?:\s|$)/u,
+    /(?:^|\s)(?:git\s+apply|apply_patch|sed\s+-i|perl\s+-pi)(?:\s|$)/iu,
+    /(?:^|\s)(?:Set-Content|Add-Content|Out-File|Remove-Item|Move-Item|Copy-Item|New-Item)(?:\s|$)/iu,
+    /(?:^|\s)(?:rm|mv|cp|mkdir|touch)(?:\s|$)/u,
 ];
-
 function textBlocks(value, depth = 0) {
-  if (depth > 5 || value === null || value === undefined) return [];
-  if (typeof value === "string") return [value];
-  if (Array.isArray(value)) return value.flatMap((item) => textBlocks(item, depth + 1));
-  if (typeof value !== "object") return [];
-  if (value.type === "text" && typeof value.text === "string") return [value.text];
-  const keys = ["content", "message", "output", "result", "data", "text", "value", "command", "args", "input"];
-  return keys.flatMap((key) => key in value ? textBlocks(value[key], depth + 1) : []);
+    if (depth > 5 || value === null || value === undefined)
+        return [];
+    if (typeof value === "string")
+        return [value];
+    if (Array.isArray(value))
+        return value.flatMap((item) => textBlocks(item, depth + 1));
+    if (!isUnknownRecord(value))
+        return [];
+    if (value.type === "text" && typeof value.text === "string")
+        return [value.text];
+    const keys = ["content", "message", "output", "result", "data", "text", "value", "command", "args", "input"];
+    return keys.flatMap((key) => key in value ? textBlocks(value[key], depth + 1) : []);
 }
-
 function matchesAny(text, patterns) {
-  return patterns.some((pattern) => pattern.test(text));
+    return patterns.some((pattern) => pattern.test(text));
+}
+function directUserMessage(event) {
+    const message = isUnknownRecord(event.data?.message) ? event.data.message : event.data;
+    const source = isUnknownRecord(message?.source) ? message.source : undefined;
+    if (typeof message?.role === "string" && message.role !== "user")
+        return undefined;
+    return source?.kind === "user" ? message : undefined;
+}
+function isDirectUserEvent(event) {
+    return directUserMessage(event) !== undefined;
 }
-
 function toolResultBlocks(value, depth = 0) {
-  if (depth > 5 || value === null || value === undefined) return [];
-  if (Array.isArray(value)) return value.flatMap((item) => toolResultBlocks(item, depth + 1));
-  if (typeof value !== "object") return [];
-  const own = value.type === "tool-result" ? [value] : [];
-  return own.concat(Object.values(value).flatMap((item) => toolResultBlocks(item, depth + 1)));
+    if (depth > 5 || value === null || value === undefined)
+        return [];
+    if (Array.isArray(value))
+        return value.flatMap((item) => toolResultBlocks(item, depth + 1));
+    if (!isUnknownRecord(value))
+        return [];
+    const own = value.type === "tool-result" ? [value] : [];
+    return own.concat(Object.values(value).flatMap((item) => toolResultBlocks(item, depth + 1)));
 }
-
 function nativeToolResult(data) {
-  const blocks = toolResultBlocks(data);
-  if (blocks.length !== 1) return undefined;
-  const block = blocks[0];
-  const source = data?.message?.source;
-  if (source?.kind !== "tool"
-    || typeof source.callId !== "string"
-    || !source.callId
-    || block.toolCallId !== source.callId
-    || typeof block.isError !== "boolean"
-    || !Array.isArray(block.content)) {
-    return undefined;
-  }
-  return Object.freeze({
-    callId: source.callId,
-    successful: block.isError === false && !data?.error,
-  });
+    const blocks = toolResultBlocks(data);
+    if (blocks.length !== 1)
+        return undefined;
+    const block = blocks[0];
+    const message = isUnknownRecord(data.message) ? data.message : undefined;
+    const source = isUnknownRecord(message?.source) ? message.source : undefined;
+    if (source?.kind !== "tool"
+        || typeof source.callId !== "string"
+        || !source.callId
+        || block?.toolCallId !== source.callId
+        || typeof block.isError !== "boolean"
+        || !Array.isArray(block.content))
+        return undefined;
+    return Object.freeze({
+        callId: source.callId,
+        successful: block.isError === false && !data.error,
+    });
+}
+function commandFromArguments(value) {
+    let arguments_ = value;
+    if (typeof arguments_ === "string") {
+        const trimmed = arguments_.trim();
+        if (!trimmed.startsWith("{") && !trimmed.startsWith("[")) {
+            return Object.freeze({ command: arguments_, parsed: true });
+        }
+        try {
+            arguments_ = JSON.parse(trimmed);
+        }
+        catch {
+            return Object.freeze({ command: "", parsed: false });
+        }
+    }
+    if (!isUnknownRecord(arguments_))
+        return Object.freeze({ command: "", parsed: false });
+    for (const field of ["command", "cmd", "script"]) {
+        if (typeof arguments_[field] === "string")
+            return Object.freeze({ command: arguments_[field], parsed: true });
+    }
+    return Object.freeze({ command: "", parsed: true });
 }
-
-function commandFromCall(call) {
-  const args = call?.arguments;
-  if (typeof args === "string") return args;
-  if (!args || typeof args !== "object" || Array.isArray(args)) return "";
-  for (const field of ["command", "cmd", "script"]) {
-    if (typeof args[field] === "string") return args[field];
-  }
-  return "";
+function normalizedToolName(name) {
+    const segments = name.split(/[.:/]/u).filter(Boolean);
+    return segments.at(-1) ?? name;
 }
-
 function resultReferencesCall(event, call) {
-  return Number.isSafeInteger(call?.seq)
-    && Array.isArray(event?.sourceEventSeqs)
-    && event.sourceEventSeqs.length === 1
-    && event.sourceEventSeqs[0] === call.seq;
+    return Number.isSafeInteger(call?.seq)
+        && Array.isArray(event?.sourceEventSeqs)
+        && event.sourceEventSeqs.length === 1
+        && event.sourceEventSeqs[0] === call.seq;
 }
-
-function nativeToolCalls(events, startIndex) {
-  const calls = new Map();
-  const duplicates = new Set();
-  for (let index = startIndex; index < events.length; index += 1) {
-    const event = events[index];
-    if (event?.type !== "tool/call") continue;
-    const callId = event.data?.callId;
-    const name = event.data?.name;
-    if (typeof callId !== "string" || !callId || typeof name !== "string" || !name || !Number.isSafeInteger(event.seq)) continue;
-    if (calls.has(callId)) {
-      calls.delete(callId);
-      duplicates.add(callId);
-      continue;
+function nativeToolCalls(events) {
+    const calls = new Map();
+    const duplicates = new Set();
+    for (let index = 0; index < events.length; index += 1) {
+        const event = events[index];
+        if (event?.type !== "tool/call")
+            continue;
+        const callId = event.data?.callId;
+        const name = event.data?.name;
+        if (typeof callId !== "string" || !callId || typeof name !== "string" || !name || !Number.isSafeInteger(event.seq))
+            continue;
+        if (calls.has(callId)) {
+            calls.delete(callId);
+            duplicates.add(callId);
+            continue;
+        }
+        if (duplicates.has(callId))
+            continue;
+        calls.set(callId, Object.freeze({ index, seq: event.seq, name, arguments: event.data?.arguments }));
     }
-    if (duplicates.has(callId)) continue;
-    calls.set(callId, Object.freeze({
-      index,
-      seq: event.seq,
-      name,
-      arguments: event.data?.arguments,
-    }));
-  }
-  return calls;
+    return calls;
 }
-
-function eventEvidence(event, index, calls) {
-  if (event?.type === "user/message") {
-    const text = textBlocks(event.data).join("\n").trim();
-    return text ? { index, source: "user", kinds: ["requirement"], label: "earlier user requirement", text } : undefined;
-  }
-  if (["assistant/message", "agent/message", "message/assistant"].includes(event?.type)) {
-    const text = textBlocks(event.data).join("\n").trim();
-    if (!text) return undefined;
-    const kinds = ["assistant-claim"];
-    if (matchesAny(text, REQUIREMENT_PATTERNS)) kinds.push("requirement");
-    if (matchesAny(text, ACCEPTANCE_PATTERNS)) kinds.push("acceptance");
-    return { index, source: "assistant", kinds, label: "controller claim", text };
-  }
-  if (event?.type === "odai/route-card-frozen" && event.data?.card) {
-    return {
-      index,
-      source: "route-card",
-      kinds: ["acceptance"],
-      label: `frozen route card ${event.data.card.id ?? "(unknown)"}`,
-      text: JSON.stringify(event.data.card),
-    };
-  }
-  if (event?.type === "tool/result") {
-    const result = nativeToolResult(event.data);
-    const call = result ? calls.get(result.callId) : undefined;
-    if (!call || call.index >= index || !resultReferencesCall(event, call)) return undefined;
-    const callId = result.callId;
-    const successful = result.successful;
-    const command = commandFromCall(call);
-    const simpleCommand = !SHELL_CONTROL_PATTERN.test(command);
-    const diffCommand = simpleCommand && matchesAny(command, DIFF_COMMAND_PATTERNS);
-    const testCommand = simpleCommand && matchesAny(command, TEST_COMMAND_PATTERNS);
-    const explicitWrite = WRITE_TOOL_NAMES.has(call.name) || matchesAny(command, WRITE_COMMAND_PATTERNS);
-    const unknownShellMutation = SHELL_TOOL_NAMES.has(call.name)
-      && !diffCommand
-      && !testCommand
-      && (SHELL_CONTROL_PATTERN.test(command) || !matchesAny(command, READ_ONLY_SHELL_COMMAND_PATTERNS));
-    const writeCommand = explicitWrite || unknownShellMutation;
-    if (!successful && !testCommand && !writeCommand) return undefined;
-    const output = textBlocks(event.data).join("\n").trim();
-    const kinds = successful ? ["tool"] : [];
-    if (successful && diffCommand && matchesAny(output, DIFF_OUTPUT_PATTERNS)) kinds.push("diff");
-    if (writeCommand) kinds.push("write");
-    if (testCommand) {
-      const testPassed = successful
-        && matchesAny(output, TEST_SUCCESS_PATTERNS)
-        && !matchesAny(output, TEST_FAILURE_PATTERNS);
-      kinds.push(testPassed ? "test" : "test-failed");
+function eventEvidence(event, index, calls, directUserMessageIds, diagnostics) {
+    if (event?.type === "user/message") {
+        if (!isDirectUserEvent(event))
+            return undefined;
+        const text = textBlocks(event.data).join("\n").trim();
+        if (!text)
+            return undefined;
+        if (classifyResponsibilityInterruptionText(text) === "continue") {
+            return { index, source: "user", kinds: ["continuation"], label: "direct-user continuation", text };
+        }
+        return { index, source: "user", kinds: ["requirement", "acceptance"], label: "user-owned requirement and acceptance", text };
     }
-    const identity = `tool-call:${callId}`;
-    const text = [command ? `command: ${command}` : "", output || "(no textual result)"].filter(Boolean).join("\n\n");
-    return {
-      index,
-      source: "tool",
-      kinds,
-      label: `tool ${call.name} (${identity})`,
-      identity,
-      text,
-    };
-  }
-  if (event?.type === "odai/tool-observed" && event.data?.isError === false) {
-    const identity = typeof event.data.callId === "string" ? `tool-call:${event.data.callId}` : undefined;
-    const tool = event.data.tool ?? "unknown";
-    return {
-      index,
-      source: "tool",
-      kinds: ["tool", ...(WRITE_TOOL_NAMES.has(tool) ? ["write"] : [])],
-      label: `observed tool ${tool}${identity ? ` (${identity})` : ""}`,
-      ...(identity ? { identity } : {}),
-      text: JSON.stringify(event.data),
-    };
-  }
-  return undefined;
+    if (["assistant/message", "agent/message", "message/assistant"].includes(event?.type)) {
+        const text = textBlocks(event.data).join("\n").trim();
+        if (!text)
+            return undefined;
+        const kinds = ["assistant-claim"];
+        if (matchesAny(text, REQUIREMENT_PATTERNS))
+            kinds.push("requirement");
+        return { index, source: "assistant", kinds, label: "controller claim", text };
+    }
+    if (event?.type === "odai/route-card-frozen" && isUnknownRecord(event.data?.card)) {
+        const authorization = isUnknownRecord(event.data.card.authorization) ? event.data.card.authorization : undefined;
+        const userMessageId = typeof authorization?.userMessageId === "string" ? authorization.userMessageId : undefined;
+        if (authorization?.status !== "authorized"
+            || !userMessageId
+            || !directUserMessageIds.has(userMessageId)
+            || !Array.isArray(event.data.card.accept)
+            || event.data.card.accept.length === 0)
+            return undefined;
+        return {
+            index, source: "route-card", kinds: ["acceptance"],
+            label: `authorized frozen route card ${typeof event.data.card.id === "string" ? event.data.card.id : "(unknown)"}`,
+            text: JSON.stringify(event.data.card),
+        };
+    }
+    if (event?.type === "tool/result") {
+        const result = nativeToolResult(event.data);
+        if (!result) {
+            diagnostics.malformedToolResultCount += 1;
+            return undefined;
+        }
+        const call = calls.get(result.callId);
+        if (!call || call.index >= index || !resultReferencesCall(event, call)) {
+            diagnostics.unlinkedToolResultCount += 1;
+            return undefined;
+        }
+        diagnostics.linkedToolResultCount += 1;
+        const decoded = commandFromArguments(call.arguments);
+        if (!decoded.parsed)
+            diagnostics.unparsedToolArgumentsCount += 1;
+        const command = decoded.command;
+        const toolName = normalizedToolName(call.name);
+        const simpleCommand = command !== "" && !SHELL_CONTROL_PATTERN.test(command);
+        const diffCommand = simpleCommand && matchesAny(command, DIFF_COMMAND_PATTERNS);
+        const testCommand = simpleCommand && matchesAny(command, TEST_COMMAND_PATTERNS);
+        const explicitWrite = WRITE_TOOL_NAMES.has(toolName) || matchesAny(command, WRITE_COMMAND_PATTERNS);
+        const unknownShellMutation = SHELL_TOOL_NAMES.has(toolName)
+            && !diffCommand && !testCommand
+            && (SHELL_CONTROL_PATTERN.test(command) || !matchesAny(command, READ_ONLY_SHELL_COMMAND_PATTERNS));
+        if (SHELL_TOOL_NAMES.has(toolName) && !diffCommand && !testCommand && !explicitWrite
+            && !matchesAny(command, READ_ONLY_SHELL_COMMAND_PATTERNS))
+            diagnostics.unclassifiedShellResultCount += 1;
+        const writeCommand = explicitWrite || unknownShellMutation;
+        if (!result.successful && !testCommand && !writeCommand)
+            return undefined;
+        const output = textBlocks(event.data).join("\n").trim();
+        const kinds = result.successful ? ["tool"] : [];
+        if (result.successful && diffCommand) {
+            if (matchesAny(output, DIFF_OUTPUT_PATTERNS))
+                kinds.push("diff");
+            else
+                diagnostics.diffWithoutPatchCount += 1;
+        }
+        if (writeCommand)
+            kinds.push("write");
+        if (testCommand) {
+            const testPassed = result.successful && matchesAny(output, TEST_SUCCESS_PATTERNS) && !matchesAny(output, TEST_FAILURE_PATTERNS);
+            if (result.successful && !matchesAny(output, TEST_SUCCESS_PATTERNS) && !matchesAny(output, TEST_FAILURE_PATTERNS)) {
+                diagnostics.testWithoutVerdictCount += 1;
+            }
+            kinds.push(testPassed ? "test" : "test-failed");
+        }
+        const identity = `tool-call:${result.callId}`;
+        const text = [command ? `command: ${command}` : "", output || "(no textual result)"].filter(Boolean).join("\n\n");
+        return { index, source: "tool", kinds, label: `tool ${call.name} (${identity})`, identity, text };
+    }
+    if (event?.type === "odai/tool-observed" && event.data?.isError === false) {
+        const identity = typeof event.data.callId === "string" ? `tool-call:${event.data.callId}` : undefined;
+        const tool = typeof event.data.tool === "string" ? event.data.tool : "unknown";
+        const normalized = normalizedToolName(tool);
+        return {
+            index, source: "tool", kinds: ["tool", ...(WRITE_TOOL_NAMES.has(normalized) ? ["write"] : [])],
+            label: `observed tool ${tool}${identity ? ` (${identity})` : ""}`,
+            ...(identity ? { identity } : {}), text: JSON.stringify(event.data),
+        };
+    }
+    return undefined;
 }
-
 function truncateText(text, limit) {
-  if (text.length <= limit) return { text, truncated: false };
-  return { text: `${text.slice(0, Math.max(0, limit - 24))}\n...[packet truncated]`, truncated: true };
+    if (text.length <= limit)
+        return { text, truncated: false };
+    return { text: `${text.slice(0, Math.max(0, limit - 24))}\n...[packet truncated]`, truncated: true };
 }
-
 function digestPacket(value) {
-  return createHash("sha256").update(JSON.stringify(value)).digest("hex");
+    return createHash("sha256").update(JSON.stringify(value)).digest("hex");
 }
-
 function coverageFor(currentTask, entries) {
-  const matching = (kind) => entries.filter((entry) => entry.kinds.includes(kind));
-  const latestIndex = (kind) => matching(kind).reduce((latest, entry) => Math.max(latest, entry.index), -1);
-  const acceptanceCount = matching("acceptance").length;
-  const diffEntries = matching("diff");
-  const testEntries = matching("test");
-  const failedTestEntries = matching("test-failed");
-  const latestWriteIndex = latestIndex("write");
-  const latestDiffIndex = latestIndex("diff");
-  const latestTestIndex = latestIndex("test");
-  const latestFailedTestIndex = latestIndex("test-failed");
-  const currentEvidence = acceptanceCount > 0
-    && latestDiffIndex >= 0
-    && latestTestIndex >= 0
-    && latestDiffIndex > latestWriteIndex
-    && latestTestIndex > latestWriteIndex
-    && latestTestIndex > latestFailedTestIndex
-    && diffEntries.some((diff) => testEntries.some((testResult) => diff.identity !== testResult.identity));
-  return Object.freeze({
-    requirements: Boolean(currentTask) || matching("requirement").length > 0,
-    acceptanceCount,
-    diffCount: diffEntries.length,
-    testCount: testEntries.length,
-    failedTestCount: failedTestEntries.length,
-    writeCount: matching("write").length,
-    toolEvidenceCount: matching("tool").length,
-    latestWriteIndex,
-    latestDiffIndex,
-    latestTestIndex,
-    latestFailedTestIndex,
-    currentEvidence,
-  });
+    const matching = (kind) => entries.filter((entry) => entry.kinds.includes(kind));
+    const latestIndex = (kind) => matching(kind).reduce((latest, entry) => Math.max(latest, entry.index), -1);
+    const acceptanceCount = matching("acceptance").length;
+    const diffEntries = matching("diff");
+    const testEntries = matching("test");
+    const failedTestEntries = matching("test-failed");
+    const latestWriteIndex = latestIndex("write");
+    const latestDiffIndex = latestIndex("diff");
+    const latestTestIndex = latestIndex("test");
+    const latestFailedTestIndex = latestIndex("test-failed");
+    const currentEvidence = acceptanceCount > 0
+        && latestDiffIndex >= 0 && latestTestIndex >= 0
+        && latestDiffIndex > latestWriteIndex && latestTestIndex > latestDiffIndex
+        && latestTestIndex > latestFailedTestIndex
+        && diffEntries.some((diff) => testEntries.some((testResult) => diff.identity !== testResult.identity));
+    return Object.freeze({
+        requirements: Boolean(currentTask) || matching("requirement").length > 0,
+        acceptanceCount, diffCount: diffEntries.length, testCount: testEntries.length,
+        failedTestCount: failedTestEntries.length, writeCount: matching("write").length,
+        toolEvidenceCount: matching("tool").length, latestWriteIndex, latestDiffIndex,
+        latestTestIndex, latestFailedTestIndex, currentEvidence,
+    });
 }
-
 export function buildRoleContextPacket(agent, role, taskText, options = {}) {
-  const maxChars = Number.isSafeInteger(options.maxChars) && options.maxChars > 0
-    ? options.maxChars
-    : DEFAULT_MAX_CHARS;
-  const maxEvents = Number.isSafeInteger(options.maxEvents) && options.maxEvents > 0
-    ? options.maxEvents
-    : DEFAULT_MAX_EVENTS;
-  const taskBudget = Math.max(128, Math.floor(maxChars / 2));
-  const task = truncateText(String(taskText ?? "").trim(), taskBudget);
-  const events = Array.isArray(agent?.session?.events) ? agent.session.events : [];
-  const startIndex = Math.max(0, events.length - maxEvents);
-  const calls = nativeToolCalls(events, startIndex);
-  const selected = [];
-  let evidenceChars = 0;
-  let truncated = task.truncated || events.length > maxEvents;
-
-  for (let index = events.length - 1; index >= startIndex; index -= 1) {
-    const entry = eventEvidence(events[index], index, calls);
-    if (!entry) continue;
-    const remaining = maxChars - task.text.length - evidenceChars;
-    if (remaining <= 0) { truncated = true; break; }
-    const bounded = truncateText(entry.text, remaining);
-    selected.push(Object.freeze({ ...entry, kinds: Object.freeze([...new Set(entry.kinds)]), text: bounded.text }));
-    evidenceChars += bounded.text.length;
-    if (bounded.truncated) { truncated = true; break; }
-  }
-  selected.reverse();
-
-  const entries = Object.freeze(selected);
-  const coverage = coverageFor(task.text, entries);
-  const packetBody = Object.freeze({
-    schemaVersion: 1,
-    role,
-    currentTask: task.text,
-    entries,
-    coverage,
-    truncated,
-  });
-  const digest = digestPacket(packetBody);
-  const reviewerSufficient = !truncated
-    && coverage.requirements
-    && coverage.acceptanceCount > 0
-    && coverage.diffCount > 0
-    && coverage.testCount > 0
-    && coverage.toolEvidenceCount > 0
-    && coverage.currentEvidence;
-  return Object.freeze({
-    ...packetBody,
-    digest,
-    evidenceCount: entries.length,
-    toolEvidenceCount: coverage.toolEvidenceCount,
-    sufficient: role === "reviewer" ? reviewerSufficient : Boolean(task.text),
-  });
+    const maxChars = Number.isSafeInteger(options.maxChars) && (options.maxChars ?? 0) > 0 ? options.maxChars : DEFAULT_MAX_CHARS;
+    const maxEvents = Number.isSafeInteger(options.maxEvents) && (options.maxEvents ?? 0) > 0 ? options.maxEvents : DEFAULT_MAX_EVENTS;
+    const taskBudget = Math.max(32, Math.floor(maxChars / 3));
+    const task = truncateText(String(taskText ?? "").trim(), taskBudget);
+    const events = Array.isArray(agent?.session?.events) ? agent.session.events : [];
+    const calls = nativeToolCalls(events);
+    const directUserMessageIds = new Set(events.flatMap((event) => {
+        if (event?.type !== "user/message")
+            return [];
+        const message = directUserMessage(event);
+        return message && typeof message.id === "string" ? [message.id] : [];
+    }));
+    const mutableDiagnostics = {
+        rawEventCount: events.length,
+        evidenceEventCount: 0,
+        selectedEvidenceCount: 0,
+        omittedEvidenceCount: 0,
+        nativeToolCallCount: calls.size,
+        linkedToolResultCount: 0,
+        malformedToolResultCount: 0,
+        unlinkedToolResultCount: 0,
+        unparsedToolArgumentsCount: 0,
+        unclassifiedShellResultCount: 0,
+        diffWithoutPatchCount: 0,
+        testWithoutVerdictCount: 0,
+    };
+    const allEvidence = [];
+    const preTruncatedIndices = new Set();
+    for (let index = 0; index < events.length; index += 1) {
+        const event = events[index];
+        if (!event)
+            continue;
+        const entry = eventEvidence(event, index, calls, directUserMessageIds, mutableDiagnostics);
+        if (!entry)
+            continue;
+        const bounded = truncateText(entry.text, DEFAULT_MAX_ENTRY_CHARS);
+        if (bounded.truncated)
+            preTruncatedIndices.add(entry.index);
+        allEvidence.push(Object.freeze({ ...entry, kinds: Object.freeze([...new Set(entry.kinds)]), text: bounded.text }));
+    }
+    mutableDiagnostics.evidenceEventCount = allEvidence.length;
+    const recent = allEvidence.slice(-maxEvents);
+    const anchors = ["requirement", "acceptance"].flatMap((kind) => {
+        const entry = allEvidence.findLast((candidate) => candidate.kinds.includes(kind));
+        return entry ? [entry] : [];
+    });
+    const candidateByIndex = new Map();
+    for (const entry of [...recent, ...anchors])
+        candidateByIndex.set(entry.index, entry);
+    const candidates = [...candidateByIndex.values()].sort((left, right) => left.index - right.index);
+    mutableDiagnostics.selectedEvidenceCount = candidates.length;
+    mutableDiagnostics.omittedEvidenceCount = Math.max(0, allEvidence.length - candidates.length);
+    const priorityKinds = ["requirement", "acceptance", "write", "diff", "test-failed", "test"];
+    const prioritized = [];
+    const prioritizedIndices = new Set();
+    for (const kind of priorityKinds) {
+        const entry = candidates.findLast((candidate) => candidate.kinds.includes(kind));
+        if (entry && !prioritizedIndices.has(entry.index)) {
+            prioritized.push(entry);
+            prioritizedIndices.add(entry.index);
+        }
+    }
+    for (let index = candidates.length - 1; index >= 0; index -= 1) {
+        const entry = candidates[index];
+        if (entry && !prioritizedIndices.has(entry.index)) {
+            prioritized.push(entry);
+            prioritizedIndices.add(entry.index);
+        }
+    }
+    const rendered = [];
+    let evidenceChars = 0;
+    let textTruncated = task.truncated || prioritized.some((entry) => preTruncatedIndices.has(entry.index));
+    const availableChars = Math.max(0, maxChars - task.text.length);
+    const maxEntryChars = Math.max(96, Math.min(DEFAULT_MAX_ENTRY_CHARS, Math.floor(availableChars / 6)));
+    for (const entry of prioritized) {
+        const remaining = maxChars - task.text.length - evidenceChars;
+        if (remaining < 96) {
+            textTruncated = true;
+            break;
+        }
+        const bounded = truncateText(entry.text, Math.min(remaining, maxEntryChars));
+        rendered.push(Object.freeze({ ...entry, text: bounded.text }));
+        evidenceChars += bounded.text.length;
+        textTruncated ||= bounded.truncated;
+    }
+    rendered.sort((left, right) => left.index - right.index);
+    const entries = Object.freeze(rendered);
+    const coverage = coverageFor(task.text, entries);
+    const diagnostics = Object.freeze({
+        ...mutableDiagnostics,
+        hostEvidenceAvailable: mutableDiagnostics.linkedToolResultCount > 0,
+    });
+    const truncated = textTruncated || mutableDiagnostics.omittedEvidenceCount > 0 || rendered.length < candidates.length;
+    const evidenceCoverage = coverageFor(task.text, candidates);
+    const evidenceMarkers = priorityKinds.map((kind) => {
+        const entry = candidates.findLast((candidate) => candidate.kinds.includes(kind));
+        return entry ? { kind, index: entry.index, identity: entry.identity } : { kind, index: -1 };
+    });
+    const evidenceDigest = digestPacket({
+        coverage: {
+            requirements: evidenceCoverage.requirements,
+            acceptanceCount: evidenceCoverage.acceptanceCount,
+            diffCount: evidenceCoverage.diffCount,
+            testCount: evidenceCoverage.testCount,
+            failedTestCount: evidenceCoverage.failedTestCount,
+            writeCount: evidenceCoverage.writeCount,
+            latestWriteIndex: evidenceCoverage.latestWriteIndex,
+            latestDiffIndex: evidenceCoverage.latestDiffIndex,
+            latestTestIndex: evidenceCoverage.latestTestIndex,
+            latestFailedTestIndex: evidenceCoverage.latestFailedTestIndex,
+            currentEvidence: evidenceCoverage.currentEvidence,
+        },
+        markers: evidenceMarkers,
+        diagnostics: {
+            malformedToolResultCount: diagnostics.malformedToolResultCount,
+            unlinkedToolResultCount: diagnostics.unlinkedToolResultCount,
+            unparsedToolArgumentsCount: diagnostics.unparsedToolArgumentsCount,
+            unclassifiedShellResultCount: diagnostics.unclassifiedShellResultCount,
+            diffWithoutPatchCount: diagnostics.diffWithoutPatchCount,
+            testWithoutVerdictCount: diagnostics.testWithoutVerdictCount,
+            hostEvidenceAvailable: diagnostics.hostEvidenceAvailable,
+        },
+    });
+    const packetBody = Object.freeze({
+        schemaVersion: 1, role, currentTask: task.text, entries, coverage, diagnostics, truncated, evidenceDigest,
+    });
+    const digest = digestPacket(packetBody);
+    const reviewerSufficient = coverage.requirements && coverage.acceptanceCount > 0
+        && coverage.diffCount > 0 && coverage.testCount > 0 && coverage.toolEvidenceCount > 0 && coverage.currentEvidence;
+    return Object.freeze({
+        ...packetBody, digest, evidenceCount: entries.length, toolEvidenceCount: coverage.toolEvidenceCount,
+        sufficient: role === "reviewer" ? reviewerSufficient : Boolean(task.text),
+    });
 }
-
 export function renderRoleContextPacket(packet) {
-  const evidence = packet.entries.length
-    ? packet.entries.map((entry, index) => [
-        `### E${index + 1}: ${entry.label}`,
-        `kinds: ${entry.kinds.join(", ")}`,
-        entry.text,
-      ].join("\n")).join("\n\n")
-    : "(no prior evidence entries)";
-  return [
-    "# Odai bounded role context packet",
-    `role: ${packet.role}`,
-    `digest: sha256:${packet.digest}`,
-    `truncated: ${packet.truncated}`,
-    `coverage: ${JSON.stringify(packet.coverage)}`,
-    "",
-    "## Current task",
-    packet.currentTask || "(empty)",
-    "",
-    "## Evidence",
-    evidence,
-    "",
-    "Treat assistant text and route-card contents as claims. Tool entries are evidence only for the exact command/result they contain.",
-  ].join("\n");
+    const evidence = packet.entries.length
+        ? packet.entries.map((entry, index) => [
+            `### E${index + 1}: ${entry.label}`,
+            `kinds: ${entry.kinds.join(", ")}`,
+            entry.text,
+        ].join("\n")).join("\n\n")
+        : "(no prior evidence entries)";
+    return [
+        "# Odai bounded role context packet",
+        `role: ${packet.role}`,
+        `digest: sha256:${packet.digest}`,
+        `evidenceDigest: sha256:${packet.evidenceDigest}`,
+        `truncated: ${packet.truncated}`,
+        `coverage: ${JSON.stringify(packet.coverage)}`,
+        `diagnostics: ${JSON.stringify(packet.diagnostics)}`,
+        "", "## Current task", packet.currentTask || "(empty)", "", "## Evidence", evidence, "",
+        "Treat assistant text and route-card contents as claims. Tool entries are evidence only for the exact command/result they contain.",
+    ].join("\n");
 }
+//# sourceMappingURL=routing-context.mjs.map