@linghun/tui 0.1.0

package/dist/chunk-5H7RRF7C.js

@@ -0,0 +1,6 @@
+// src/runtime-utils.ts
+var MEMORY_LEARNING_STATE_FILE = "learning-state.json";
+
+export {
+  MEMORY_LEARNING_STATE_FILE
+};

package/dist/chunk-64MJP6FK.js

@@ -0,0 +1,558 @@
+import {
+  applyToolResultBudgetToMessages,
+  formatToolResultBudgetEvidenceSummary,
+  formatToolResultBudgetSystemEvent
+} from "./chunk-O7S3HYE6.js";
+import {
+  MAX_EVIDENCE_RECORDS
+} from "./chunk-RDGM4RUE.js";
+import {
+  LINGHUN_DEFAULT_TOOL_RESULT_CHARS,
+  LINGHUN_MAX_TOOL_RESULT_BYTES
+} from "./chunk-IWUIOLMF.js";
+import {
+  writeHandoffPacket
+} from "./chunk-MLUIOBKL.js";
+import {
+  deriveToolSupportsClaims
+} from "./chunk-K56D3X7S.js";
+import {
+  mergeFailureRecord,
+  writeFailureRecord
+} from "./chunk-GDQQNPBP.js";
+import {
+  classifyProviderFailure
+} from "./chunk-OZMX3E35.js";
+import {
+  truncateDisplay
+} from "./chunk-OMZYPQVA.js";
+import {
+  summarizeArchitectureCard
+} from "./chunk-MVONSJEN.js";
+
+// src/evidence-runtime.ts
+import { randomUUID } from "crypto";
+var TRANSCRIPT_TOOL_OUTPUT_PREVIEW_CHARS = 2e3;
+var TRANSCRIPT_TOOL_OUTPUT_MAX_CHARS = 8e3;
+var MAX_ROUND_ASSISTANT_CHARS_FOR_PROVIDER = 16e3;
+var ROUND_ASSISTANT_HEAD_CHARS = 4e3;
+var ROUND_ASSISTANT_TAIL_CHARS = 4e3;
+function createEvidenceRecord(kind, summary, source, supportsClaims) {
+  return {
+    id: randomUUID(),
+    kind,
+    summary: truncateDisplay(summary.replace(/\s+/g, " "), 180),
+    source,
+    supportsClaims,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function rememberEvidence(context, evidence) {
+  context.evidence.unshift(evidence);
+  context.evidence = context.evidence.slice(0, MAX_EVIDENCE_RECORDS);
+}
+function pickEvidence(evidence) {
+  return {
+    id: evidence.id,
+    kind: evidence.kind,
+    source: evidence.source,
+    summary: evidence.summary
+  };
+}
+function truncateRoundAssistantForProvider(text, context) {
+  if (text.length <= MAX_ROUND_ASSISTANT_CHARS_FOR_PROVIDER) return text;
+  const head = text.slice(0, ROUND_ASSISTANT_HEAD_CHARS);
+  const tail = text.slice(-ROUND_ASSISTANT_TAIL_CHARS);
+  const omitted = text.length - ROUND_ASSISTANT_HEAD_CHARS - ROUND_ASSISTANT_TAIL_CHARS;
+  const separator = context.language === "en-US" ? `
+
+[... ${omitted} characters omitted \u2014 full output preserved in artifact; use /details or Ctrl+O to inspect ...]
+
+` : `
+
+[... \u4E2D\u95F4\u7701\u7565 ${omitted} \u4E2A\u5B57\u7B26 \u2014 \u5B8C\u6574\u8F93\u51FA\u5DF2\u4FDD\u5B58\u5728 artifact \u4E2D\uFF1B\u7528 /details \u6216 Ctrl+O \u67E5\u770B ...]
+
+`;
+  return head + separator + tail;
+}
+async function recordProviderFailureEvidence(context, sessionId, error, runtime) {
+  const code = error instanceof Error && "code" in error && typeof error.code === "string" ? error.code : "PROVIDER_ERROR";
+  const message = error instanceof Error ? error.message : String(error);
+  const failureKind = classifyProviderFailure(error);
+  const transitFailure = failureKind === "transit";
+  const summary = `provider failure: kind ${failureKind}; code ${code}; provider ${runtime.provider}; model ${runtime.model}; endpoint profile ${runtime.endpointProfile}; message ${sanitizeProviderFailureText(message)}`;
+  const evidence = createEvidenceRecord(
+    "command_output",
+    summary,
+    `provider:${runtime.provider}:failure`,
+    ["provider_failure", code, runtime.provider, runtime.model, runtime.endpointProfile]
+  );
+  rememberEvidence(context, evidence);
+  await context.store.appendEvent(sessionId, {
+    type: "evidence_record",
+    ...evidence
+  });
+  await appendSystemEvent(context, sessionId, summary, "warning");
+  context.lastProviderFailure = {
+    code,
+    kind: failureKind,
+    provider: runtime.provider,
+    model: runtime.model,
+    endpointProfile: runtime.endpointProfile,
+    summary: evidence.summary,
+    evidenceId: evidence.id,
+    createdAt: evidence.createdAt
+  };
+  await captureFailureLearning(context, sessionId, {
+    category: "provider_failure",
+    failureSummary: `provider request failed kind=${failureKind} code=${code} message=${sanitizeProviderFailureText(message)}`,
+    rootCauseGuess: transitFailure ? `provider/network transit failure with ${code}` : `model/provider request failed with ${code}`,
+    avoidNextTime: transitFailure ? "Retry later; if it repeats, check provider transit/gateway stability with /model doctor. Do not change provider route/env/key/model unless diagnostics point there." : code === "PROVIDER_RATE_LIMITED" ? "Back off / reduce request rate before retrying provider calls" : `Check provider config and request shape for ${code} before retrying; do not assume the request succeeded`,
+    sourceRef: `evidence:${evidence.id}`,
+    relatedTarget: code,
+    severity: "high"
+  });
+  return evidence;
+}
+async function recordModelToolFailureForMetaScheduler(context, sessionId, result) {
+  if (result.ok || result.pendingApproval) return;
+  if (isUserDecisionToolStop(result.text)) return;
+  await appendSystemEvent(
+    context,
+    sessionId,
+    `meta scheduler tool failure: tool ${result.tool}; evidence ${result.evidenceId ?? "none"}`,
+    "warning"
+  );
+  await captureFailureLearning(context, sessionId, {
+    category: "tool_failure",
+    failureSummary: `tool failed: ${result.tool}: ${truncateDisplay(result.text, 180)}`,
+    rootCauseGuess: `${result.tool} returned a failed result in the model tool loop`,
+    avoidNextTime: "Do not claim the tool action completed; inspect the failure, retry with corrected inputs, or explicitly degrade.",
+    sourceRef: result.evidenceId ? `evidence:${result.evidenceId}` : `tool:${result.tool}`,
+    relatedTarget: result.tool,
+    severity: "medium"
+  });
+}
+function isUserDecisionToolStop(text) {
+  return /^(?:ask|denied|deny|rejected|cancelled|canceled|block):/iu.test(text.trim());
+}
+function sanitizeProviderFailureError(error) {
+  if (!(error instanceof Error)) {
+    return sanitizeProviderFailureText(String(error));
+  }
+  const sanitized = new Error(sanitizeProviderFailureText(error.message));
+  if ("suggestion" in error && typeof error.suggestion === "string") {
+    Object.assign(sanitized, { suggestion: error.suggestion });
+  }
+  return sanitized;
+}
+function sanitizeProviderFailureText(text) {
+  return text.replace(/sk-[A-Za-z0-9_-]+/gu, "sk-***").replace(/Bearer\s+[A-Za-z0-9._~-]+/giu, "Bearer ***").replace(/api[_-]?key=[^\s&]+/giu, "api_key=***").replace(/[A-Z]:[\\/][^\s]+/gu, "[local-path]").replace(/\/[^\s]*?(?:Linghun|linghun)[^\s]*/gu, "[local-path]");
+}
+async function recordToolFailureEvidence(context, sessionId, name, summary) {
+  const evidence = createEvidenceRecord(
+    "command_output",
+    `${name} failure: ${truncateDisplay(summary.replace(/\s+/g, " "), 140)}`,
+    `tool:${name}:failure`,
+    [name, "tool_failure"]
+  );
+  rememberEvidence(context, evidence);
+  await context.store.appendEvent(sessionId, {
+    type: "evidence_record",
+    ...evidence
+  });
+  return evidence;
+}
+async function captureFailureLearning(context, sessionId, input) {
+  context.lastMetaSchedulerFailureLearningFulfilled = true;
+  if (input.category === "tool_failure") {
+    context.lastToolFailure = {
+      toolName: input.relatedTarget ?? "unknown",
+      summary: input.failureSummary
+    };
+  }
+  let record;
+  try {
+    ({ record } = mergeFailureRecord(context.failureLearning, input));
+    await writeFailureRecord(context.failureLearning, record);
+    await appendSystemEvent(
+      context,
+      sessionId,
+      `failure_learning recorded category=${record.category} count=${record.count} severity=${record.severity}`,
+      "info"
+    );
+  } catch {
+    await appendSystemEvent(
+      context,
+      sessionId,
+      `failure_learning degraded warning=write_failed category=${record?.category ?? input.category}`,
+      "warning"
+    ).catch(() => void 0);
+  }
+}
+async function recordArchitectureRuntimeCard(context, sessionId, card) {
+  const evidence = createEvidenceRecord(
+    "command_output",
+    context.language === "en-US" ? `Architecture audit recorded: ${card.projectFacts.length} fact(s), ${card.verification.length} verification suggestion(s).` : `\u67B6\u6784\u5BA1\u8BA1\u5DF2\u8BB0\u5F55\uFF1A${card.projectFacts.length} \u6761\u4E8B\u5B9E\uFF0C${card.verification.length} \u6761\u9A8C\u8BC1\u5EFA\u8BAE\u3002`,
+    "architecture-runtime:v1",
+    ["architecture_runtime", "architecture_card", card.target]
+  );
+  rememberEvidence(context, evidence);
+  await context.store.appendEvent(sessionId, {
+    type: "evidence_record",
+    ...evidence
+  });
+  await appendSystemEvent(
+    context,
+    sessionId,
+    `architecture runtime triggered: evidence ${evidence.id}; target ${card.target}`,
+    "info"
+  );
+  if (context.memory.lastHandoff) {
+    context.memory.lastHandoff.currentArchitectureCard = summarizeArchitectureCard(card);
+    await writeHandoffPacket(context, context.memory.lastHandoff);
+  }
+  return evidence;
+}
+async function recordToolEvidence(context, sessionId, name, output, input) {
+  const kind = name === "Read" ? "file_read" : name === "Grep" || name === "Glob" ? "grep_result" : name === "Bash" || name === "Write" || name === "Edit" || name === "MultiEdit" ? "command_output" : null;
+  if (!kind) {
+    return null;
+  }
+  const readOnlyEvidence = name === "Read" || name === "Grep" || name === "Glob";
+  const evidence = createEvidenceRecord(
+    kind,
+    readOnlyEvidence ? formatReadOnlyToolEvidenceSummary(name, output, input) : `${name}: ${truncateDisplay(output.text.replace(/\s+/g, " "), 120)}`,
+    output.fullOutputPath ?? name,
+    [
+      ...deriveToolSupportsClaims(name, input, output),
+      ...readOnlyEvidence ? ["readonly_low_noise_evidence"] : []
+    ]
+  );
+  rememberEvidence(context, evidence);
+  await context.store.appendEvent(sessionId, {
+    type: "evidence_record",
+    ...evidence
+  });
+  return evidence;
+}
+function formatReadOnlyToolEvidenceSummary(name, output, input) {
+  const target = readToolEvidenceTarget(input);
+  const artifact = output.fullOutputPath ? "artifact=yes" : "artifact=no";
+  const bytes = output.text.length;
+  return `${name}: ${target}; output_chars=${bytes}; ${artifact}`;
+}
+function readToolEvidenceTarget(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return "target=unspecified";
+  const record = input;
+  for (const key of ["path", "file_path", "pattern", "query"]) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim()) {
+      return `${key}=${truncateDisplay(value.replace(/\s+/g, " "), 90)}`;
+    }
+  }
+  const paths = record.paths;
+  if (Array.isArray(paths)) {
+    const values = paths.filter((item) => typeof item === "string");
+    if (values.length > 0) {
+      return `paths=${truncateDisplay(values.slice(0, 3).join(","), 90)}`;
+    }
+  }
+  return "target=unspecified";
+}
+async function recordVerificationEvidence(context, sessionId, report) {
+  const supportsClaims = deriveVerificationSupportsClaims(report);
+  const evidence = {
+    id: randomUUID(),
+    kind: "test_result",
+    summary: `${formatVerificationEvidenceStatusSummary(report)} \u65E5\u5FD7\uFF1A${report.logPath ?? "\u65E0\u65E5\u5FD7"}`,
+    source: report.logPath ?? "Verification Runner",
+    supportsClaims,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  rememberEvidence(context, evidence);
+  await context.store.appendEvent(sessionId, {
+    type: "evidence_record",
+    ...evidence
+  });
+  if (report.status === "fail" || report.status === "partial" || report.status === "timeout") {
+    const failedCommand = report.commands.find(
+      (c) => c.status === "fail" || c.status === "timeout"
+    );
+    await captureFailureLearning(context, sessionId, {
+      category: "verification_failure",
+      failureSummary: `verification ${report.status}: ${report.summary}`,
+      rootCauseGuess: failedCommand ? `verification command failed (exit ${failedCommand.exitCode ?? "n/a"})` : `verification did not reach pass (${report.status})`,
+      avoidNextTime: "Fix the failing verification command and re-run it; do not claim verified/passed until status=pass",
+      sourceRef: `evidence:${evidence.id}`,
+      relatedTarget: failedCommand?.kind ?? "verification",
+      severity: report.status === "fail" ? "high" : "medium"
+    });
+  }
+}
+function deriveVerificationSupportsClaims(report) {
+  if (report.status !== "pass") {
+    return ["verification attempted", `verification:${report.status}`, "\u672A\u901A\u8FC7\u9A8C\u8BC1", "\u9700\u8981\u590D\u6838"];
+  }
+  const hasRealPassedCommand = report.commands.some(
+    (command) => command.status === "pass" && command.synthetic !== true
+  );
+  const claims = new Set(
+    hasRealPassedCommand ? ["verification_passed"] : ["verification_self_check_passed", "verification_not_run"]
+  );
+  for (const command of report.commands) {
+    if (command.status !== "pass") continue;
+    if (command.kind === "test") {
+      claims.add("test_passed");
+    } else if (command.kind === "typecheck") {
+      claims.add("typecheck_passed");
+    } else if (command.kind === "build") {
+      claims.add("build_passed");
+    } else if (command.kind === "lint") {
+      claims.add("lint_passed");
+    } else if (command.kind === "smoke") {
+      claims.add(command.synthetic ? "smoke_ran" : "smoke_passed");
+    }
+  }
+  return [...claims];
+}
+function formatVerificationEvidenceStatusSummary(report) {
+  const syntheticOnlyPass = report.status === "pass" && report.commands.length > 0 && report.commands.every((command) => command.synthetic === true || command.status !== "pass");
+  if (syntheticOnlyPass) {
+    return "SELF-CHECK\uFF1Asynthetic self-check \u5DF2\u901A\u8FC7\uFF1B\u771F\u5B9E\u9A8C\u8BC1\u672A\u8FD0\u884C\uFF0C\u4E0D\u80FD\u4F5C\u4E3A\u771F\u5B9E PASS \u8BC1\u636E\u3002";
+  }
+  const statusLabel = report.status.toUpperCase();
+  return new RegExp(`^${statusLabel}(?:\\s|:|\uFF1A)`, "u").test(report.summary) ? report.summary : `${statusLabel} ${report.summary}`;
+}
+async function recordToolResultBudgetEvidence(context, sessionId, record) {
+  const existing = context.evidence.find(
+    (item) => item.fullOutputPath === record.artifact.path || item.outputPath === record.artifact.path || item.summary.includes(record.artifact.relativePath)
+  );
+  if (existing) return existing.id;
+  const evidence = createEvidenceRecord(
+    "command_output",
+    formatToolResultBudgetEvidenceSummary(record),
+    record.artifact.relativePath,
+    ["tool_result_budget", "artifact", `toolUseId:${record.toolUseId}`]
+  );
+  evidence.fullOutputPath = record.artifact.path;
+  evidence.outputPath = record.artifact.path;
+  rememberEvidence(context, evidence);
+  await context.store.appendEvent(sessionId, {
+    type: "evidence_record",
+    ...evidence
+  });
+  await appendSystemEvent(context, sessionId, formatToolResultBudgetSystemEvent(record), "info");
+  return evidence.id;
+}
+async function appendBackgroundTaskEvent(context, sessionId, task) {
+  await context.store.appendEvent(sessionId, {
+    type: "background_task_update",
+    task,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function appendSystemEvent(context, sessionId, message, level) {
+  await context.store.appendEvent(sessionId, {
+    type: "system_event",
+    id: randomUUID(),
+    level,
+    message,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function appendRouteDecisionEvent(context, sessionId, decision) {
+  await appendSystemEvent(
+    context,
+    sessionId,
+    `Role route decision ${decision.id}: trigger ${decision.triggerReason}; role ${decision.role}; selected ${decision.selectedProvider || "paused"}/${decision.selectedModel || "paused"}; fallback candidates ${decision.fallbackCandidates.join(",") || "none"}; capabilities ${decision.requiredCapabilities.join("+")}; budget ${decision.maxCostCny === void 0 ? "unconfigured" : decision.maxCostCny}; fallback used ${decision.fallbackUsed ? "yes" : "no"}; budget stop ${decision.budgetStop ? "yes" : "no"}; stop ${decision.stopConditions.join("|") || "none"}`,
+    decision.stopConditions.length > 0 ? "warning" : "info"
+  );
+}
+function createToolEndEvent(id, output) {
+  return {
+    type: "tool_call_end",
+    id,
+    output: summarizeToolEndOutputForTranscript(output),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function summarizeToolEndOutputForTranscript(output) {
+  const text = compactToolEndTextForTranscript(
+    output.summary || output.preview || output.text || "tool call completed",
+    output.fullOutputPath
+  );
+  return {
+    text,
+    summary: output.summary === void 0 ? void 0 : compactToolEndTextForTranscript(output.summary, output.fullOutputPath),
+    preview: output.preview === void 0 ? void 0 : compactToolEndTextForTranscript(output.preview, output.fullOutputPath),
+    truncated: output.truncated,
+    fullOutputPath: output.fullOutputPath,
+    evidenceId: output.evidenceId,
+    changedFiles: output.changedFiles
+  };
+}
+function compactToolEndTextForTranscript(text, fullOutputPath) {
+  const bytes = Buffer.byteLength(text, "utf8");
+  if (text.length <= TRANSCRIPT_TOOL_OUTPUT_MAX_CHARS && bytes <= TRANSCRIPT_TOOL_OUTPUT_MAX_CHARS) {
+    return text;
+  }
+  return [
+    text.slice(0, TRANSCRIPT_TOOL_OUTPUT_PREVIEW_CHARS),
+    "",
+    `<transcript-tool-end-output-truncated originalChars=${text.length} originalBytes=${bytes}${fullOutputPath ? ` fullOutputPath=${fullOutputPath}` : ""}>`
+  ].join("\n");
+}
+function compactToolOutputForTranscript(output) {
+  const text = typeof output.text === "string" ? output.text : "";
+  const textBytes = Buffer.byteLength(text, "utf8");
+  if (text.length <= TRANSCRIPT_TOOL_OUTPUT_MAX_CHARS && textBytes <= TRANSCRIPT_TOOL_OUTPUT_MAX_CHARS) {
+    const compactedDetails = typeof output.details === "string" && output.details.length > TRANSCRIPT_TOOL_OUTPUT_MAX_CHARS ? `<transcript-tool-output-details-truncated originalChars=${output.details.length}${output.fullOutputPath ? ` fullOutputPath=${output.fullOutputPath}` : ""}>` : output.details;
+    return compactedDetails === output.details ? output : { ...output, details: compactedDetails };
+  }
+  const preview = text.slice(0, TRANSCRIPT_TOOL_OUTPUT_PREVIEW_CHARS);
+  return {
+    ...output,
+    text: [
+      preview,
+      "",
+      `<transcript-tool-output-truncated originalChars=${text.length} originalBytes=${textBytes}${output.fullOutputPath ? ` fullOutputPath=${output.fullOutputPath}` : ""}>`
+    ].join("\n"),
+    details: typeof output.details === "string" && output.details.length > TRANSCRIPT_TOOL_OUTPUT_PREVIEW_CHARS ? `<transcript-tool-output-details-truncated originalChars=${output.details.length}${output.fullOutputPath ? ` fullOutputPath=${output.fullOutputPath}` : ""}>` : output.details,
+    data: compactToolOutputDataForTranscript(output.data),
+    truncated: true
+  };
+}
+function compactToolOutputDataForTranscript(data) {
+  if (!data || typeof data !== "object") return data;
+  const serialized = JSON.stringify(data);
+  if (serialized.length <= LINGHUN_DEFAULT_TOOL_RESULT_CHARS && Buffer.byteLength(serialized, "utf8") <= LINGHUN_MAX_TOOL_RESULT_BYTES) {
+    return data;
+  }
+  return {
+    truncated: true,
+    originalChars: serialized.length,
+    preview: serialized.slice(0, TRANSCRIPT_TOOL_OUTPUT_PREVIEW_CHARS)
+  };
+}
+function isToolOutputFailure(name, output) {
+  if (name === "Bash") {
+    const exitCode = output.data?.exitCode;
+    return typeof exitCode === "number" && exitCode !== 0;
+  }
+  return false;
+}
+async function appendDerivedToolEvents(context, sessionId, name, output) {
+  if (name === "Todo") {
+    await context.store.appendEvent(sessionId, {
+      type: "todo_update",
+      items: context.tools.todos,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  if (name === "Diff" && isDiffSummary(output.data)) {
+    await context.store.appendEvent(sessionId, {
+      type: "diff_update",
+      summary: output.data,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+}
+function isDiffSummary(value) {
+  return typeof value === "object" && value !== null && "changedFiles" in value;
+}
+function getToolResultBudgetState(context) {
+  context.toolResultBudgetState ??= { seenIds: /* @__PURE__ */ new Set(), replacements: /* @__PURE__ */ new Map() };
+  return context.toolResultBudgetState;
+}
+async function appendDeferredToolResultEvent(context, sessionId, toolUseId, dispatchName, content, isError, evidenceId) {
+  const budgetedContent = await budgetToolResultTranscriptContent(
+    context,
+    sessionId,
+    toolUseId,
+    content
+  );
+  await context.store.appendEvent(sessionId, {
+    type: "tool_result",
+    toolUseId,
+    toolName: dispatchName,
+    content: budgetedContent,
+    isError,
+    evidenceId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function appendToolResultEvent(context, sessionId, toolUseId, toolName, content, isError, evidenceId) {
+  const budgetedContent = await budgetToolResultTranscriptContent(
+    context,
+    sessionId,
+    toolUseId,
+    content
+  );
+  await context.store.appendEvent(sessionId, {
+    type: "tool_result",
+    toolUseId,
+    toolName,
+    content: budgetedContent,
+    isError,
+    evidenceId,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+}
+async function budgetToolResultTranscriptContent(context, sessionId, toolUseId, content) {
+  const contentText = stringifyToolResultContentForBudget(content);
+  if (!contentText || contentText.startsWith("<persisted-tool-result>")) return content;
+  if (contentText.length <= LINGHUN_DEFAULT_TOOL_RESULT_CHARS && Buffer.byteLength(contentText, "utf8") <= LINGHUN_MAX_TOOL_RESULT_BYTES) {
+    return content;
+  }
+  const budgeted = await applyToolResultBudgetToMessages(
+    [{ role: "tool", tool_call_id: toolUseId, content: contentText }],
+    { projectPath: context.projectPath, sessionId }
+  );
+  for (const record of budgeted.records) {
+    await recordToolResultBudgetEvidence(context, sessionId, record);
+  }
+  const replacement = budgeted.messages[0];
+  return replacement?.role === "tool" ? replacement.content : content;
+}
+function stringifyToolResultContentForBudget(content) {
+  if (typeof content === "string") return content;
+  try {
+    return JSON.stringify(content);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  TRANSCRIPT_TOOL_OUTPUT_PREVIEW_CHARS,
+  TRANSCRIPT_TOOL_OUTPUT_MAX_CHARS,
+  MAX_ROUND_ASSISTANT_CHARS_FOR_PROVIDER,
+  ROUND_ASSISTANT_HEAD_CHARS,
+  ROUND_ASSISTANT_TAIL_CHARS,
+  createEvidenceRecord,
+  rememberEvidence,
+  pickEvidence,
+  truncateRoundAssistantForProvider,
+  recordProviderFailureEvidence,
+  recordModelToolFailureForMetaScheduler,
+  sanitizeProviderFailureError,
+  sanitizeProviderFailureText,
+  recordToolFailureEvidence,
+  captureFailureLearning,
+  recordArchitectureRuntimeCard,
+  recordToolEvidence,
+  recordVerificationEvidence,
+  recordToolResultBudgetEvidence,
+  appendBackgroundTaskEvent,
+  appendSystemEvent,
+  appendRouteDecisionEvent,
+  createToolEndEvent,
+  compactToolOutputForTranscript,
+  isToolOutputFailure,
+  appendDerivedToolEvents,
+  getToolResultBudgetState,
+  appendDeferredToolResultEvent,
+  appendToolResultEvent,
+  budgetToolResultTranscriptContent
+};