@linghun/tui 0.1.0

package/dist/chunk-K56D3X7S.js

@@ -0,0 +1,1225 @@
+import {
+  createIndexToolDefinitions
+} from "./chunk-BFVPLGAC.js";
+import {
+  createGitToolDefinitions
+} from "./chunk-6USL33ZO.js";
+
+// src/model-loop-runtime.ts
+import { builtInTools } from "@linghun/tools";
+function createToolInputSchema(name) {
+  const base = { type: "object", additionalProperties: false };
+  if (name === "Read") {
+    return {
+      ...base,
+      properties: {
+        path: { type: "string" },
+        offset: { type: "number" },
+        limit: { type: "number" }
+      },
+      required: ["path"]
+    };
+  }
+  if (name === "Write") {
+    return {
+      ...base,
+      properties: {
+        path: { type: "string" },
+        content: { type: "string" },
+        expectedHash: { type: "string" }
+      },
+      required: ["path", "content"]
+    };
+  }
+  if (name === "Edit") {
+    return {
+      ...base,
+      properties: {
+        path: { type: "string" },
+        oldText: { type: "string" },
+        newText: { type: "string" },
+        expectedHash: { type: "string" }
+      },
+      required: ["path", "oldText", "newText"]
+    };
+  }
+  if (name === "MultiEdit") {
+    return {
+      ...base,
+      properties: {
+        path: { type: "string" },
+        expectedHash: { type: "string" },
+        edits: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              oldText: { type: "string" },
+              newText: { type: "string" }
+            },
+            required: ["oldText", "newText"],
+            additionalProperties: false
+          }
+        }
+      },
+      required: ["path", "edits"]
+    };
+  }
+  if (name === "Grep") {
+    return {
+      ...base,
+      properties: {
+        pattern: { type: "string" },
+        path: { type: "string" },
+        limit: { type: "number" }
+      },
+      required: ["pattern"]
+    };
+  }
+  if (name === "Glob") {
+    return {
+      ...base,
+      properties: {
+        pattern: { type: "string" },
+        path: { type: "string" },
+        limit: { type: "number" }
+      },
+      required: ["pattern"]
+    };
+  }
+  if (name === "Bash") {
+    return {
+      ...base,
+      properties: {
+        command: { type: "string" },
+        timeoutMs: { type: "number" }
+      },
+      required: ["command"]
+    };
+  }
+  if (name === "Todo") {
+    return {
+      ...base,
+      properties: {
+        action: {
+          type: "string",
+          enum: ["list", "add", "start", "done", "block"]
+        },
+        content: { type: "string" },
+        id: { type: "string" },
+        evidence: { type: "string" }
+      },
+      required: ["action"]
+    };
+  }
+  if (name === "Diff") {
+    return {
+      ...base,
+      properties: { files: { type: "array", items: { type: "string" } } }
+    };
+  }
+  if (name === "WebSearch") {
+    return {
+      ...base,
+      properties: {
+        query: { type: "string" },
+        num_results: { type: "number" },
+        allowed_domains: { type: "array", items: { type: "string" } },
+        blocked_domains: { type: "array", items: { type: "string" } }
+      },
+      required: ["query"]
+    };
+  }
+  if (name === "WebFetch") {
+    return {
+      ...base,
+      properties: {
+        url: { type: "string" },
+        prompt: { type: "string" }
+      },
+      required: ["url"]
+    };
+  }
+  return {
+    ...base,
+    properties: {}
+  };
+}
+var SEARCH_EXTRA_TOOLS_NAME = "SearchExtraTools";
+var EXECUTE_EXTRA_TOOL_NAME = "ExecuteExtraTool";
+var COMMAND_PROPOSAL_TOOL_NAME = "CommandProposal";
+var START_AGENT_TOOL_NAME = "StartAgent";
+var AGENT_CONTROL_TOOL_NAME = "AgentControl";
+var SEND_MESSAGE_TOOL_NAME = "SendMessage";
+var RUN_WORKFLOW_TOOL_NAME = "RunWorkflow";
+var INDEX_OPERATION_TOOL_NAME = "IndexOperation";
+var RUN_VERIFICATION_TOOL_NAME = "RunVerification";
+var WRITE_REPORT_TOOL_NAME = "WriteReport";
+var SEARCH_EXTRA_TOOLS_DESCRIPTION = "Discover deferred tools provided by enabled MCP servers, trusted skills, trusted plugins, and codebase-memory. Returns name/kind/description/requiredArgs/executable/reason for each match. Pass a free-text query to filter; pass empty string to list all. Use ExecuteExtraTool to actually invoke a discovered tool.";
+var EXECUTE_EXTRA_TOOL_DESCRIPTION = "Invoke a deferred tool that was previously returned by SearchExtraTools with executable=true. Built-in tools (Read/Edit/Write/Bash/Grep/Glob/Todo) MUST be called directly, not via this wrapper. tool_name must match a discovered tool exactly; params must include all required args.";
+var COMMAND_PROPOSAL_DESCRIPTION = "Fallback only: propose an explicit Linghun slash command when the requested capability cannot be executed by an available structured tool. Do not use this as the default path for agent, workflow, index, verification, or report-writing requests.";
+var START_AGENT_DESCRIPTION = "Start a real Linghun agent runtime for user requests such as multi-agent work, explorer/planner/worker/verifier delegation, or /fork-style role work. Supports addressable name/team, safe cwd/worktree isolation, and true background launch. Runs through validation, start/background guard, permission pipeline, sidechain transcript, evidence, and final agent status.";
+var AGENT_CONTROL_DESCRIPTION = "Inspect or cancel existing Linghun agents through the real agent runtime. Use action=cancel when the user asks to stop, close, interrupt, kill, or cancel one background/sub-agent; use action=cancel_all or stop_all when the user asks to stop all agents. This performs the same durable cancellation as /agents cancel and must be preferred over replying with instructions when a matching agent exists.";
+var SEND_MESSAGE_DESCRIPTION = "Send a text message to a running Linghun agent mailbox by id/name. Team broadcast is fail-closed unless targetType=team or broadcastTeam=true is explicit, and has a small delivery limit. Ambiguous id/name/team matches return candidates instead of broadcasting.";
+var RUN_WORKFLOW_DESCRIPTION = "Run a real Linghun workflow for requests such as splitting work into a workflow or executing workflow steps. Supports explicit multi-agent intent (agents/multiAgent/runningCap/teamName) and records that intent in workflow/tool transcript events. Emits workflow start/step/result/failure events and returns completed/partial/blocked status with evidence refs.";
+var INDEX_OPERATION_DESCRIPTION = "Run a real Linghun index operation for requests such as inspect index status, refresh index, initialize fast index, or repair index ignore rules. Mutating operations use the existing permission pipeline.";
+var RUN_VERIFICATION_DESCRIPTION = "Run Linghun Verification Runner for requests such as plan-only, focused, real-smoke, typecheck, tests, build, lint, or runner self-check smoke checks. Uses the existing verification runtime and records evidence only when commands run.";
+var WRITE_REPORT_DESCRIPTION = "Write a report or controlled file using Linghun's real Write/Edit permission pipeline. Use for requests that explicitly ask to write a report file; do not answer as if a report was written without this tool result.";
+function createSearchExtraToolsInputSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      query: { type: "string" }
+    },
+    required: ["query"]
+  };
+}
+function createExecuteExtraToolInputSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      tool_name: { type: "string" },
+      params: { type: "object", additionalProperties: true }
+    },
+    required: ["tool_name"]
+  };
+}
+function createCommandProposalInputSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      command: { type: "string" },
+      reason: { type: "string" }
+    },
+    required: ["command", "reason"]
+  };
+}
+function createStartAgentInputSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      role: { type: "string", enum: ["explorer", "planner", "worker", "verifier"] },
+      subagent_type: { type: "string" },
+      task: { type: "string" },
+      name: { type: "string" },
+      teamName: { type: "string" },
+      team_name: { type: "string" },
+      runInBackground: { type: "boolean" },
+      run_in_background: { type: "boolean" },
+      cwd: { type: "string" },
+      isolation: { type: "string", enum: ["worktree"] }
+    },
+    required: ["task"]
+  };
+}
+function createAgentControlInputSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      action: { type: "string", enum: ["list", "show", "cancel", "cancel_all", "stop_all"] },
+      agentId: { type: "string" },
+      agent_id: { type: "string" },
+      ref: { type: "string" }
+    },
+    required: ["action"]
+  };
+}
+function createSendMessageInputSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      to: { type: "string" },
+      name: { type: "string" },
+      team: { type: "string" },
+      teamName: { type: "string" },
+      team_name: { type: "string" },
+      targetType: { type: "string", enum: ["id", "name", "team"] },
+      target_type: { type: "string", enum: ["id", "name", "team"] },
+      broadcastTeam: { type: "boolean" },
+      broadcast_team: { type: "boolean" },
+      kind: { type: "string", enum: ["message", "task"] },
+      taskId: { type: "string" },
+      task_id: { type: "string" },
+      message: { type: "string" }
+    },
+    required: ["message"]
+  };
+}
+function createRunWorkflowInputSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      goal: { type: "string" },
+      workflowId: { type: "string" },
+      workflow_id: { type: "string" },
+      inputs: { type: "object", additionalProperties: true },
+      runInBackground: { type: "boolean" },
+      run_in_background: { type: "boolean" },
+      agents: { type: "number" },
+      multiAgent: { type: "boolean" },
+      multi_agent: { type: "boolean" },
+      runningCap: { type: "number" },
+      running_cap: { type: "number" },
+      teamName: { type: "string" },
+      team_name: { type: "string" }
+    }
+  };
+}
+function createIndexOperationInputSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      action: { type: "string", enum: ["inspect", "refresh", "init_fast", "repair"] },
+      force: { type: "boolean" }
+    },
+    required: ["action"]
+  };
+}
+function createRunVerificationInputSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      level: {
+        type: "string",
+        enum: ["plan-only", "smoke", "focused", "real-smoke", "typecheck", "test", "build", "lint"]
+      }
+    },
+    required: ["level"]
+  };
+}
+function createWriteReportInputSchema() {
+  return {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      path: { type: "string" },
+      content: { type: "string" },
+      expectedHash: { type: "string" }
+    },
+    required: ["path", "content"]
+  };
+}
+function createDeferredToolDispatchDefinitions() {
+  return [
+    {
+      name: SEARCH_EXTRA_TOOLS_NAME,
+      description: SEARCH_EXTRA_TOOLS_DESCRIPTION,
+      inputSchema: createSearchExtraToolsInputSchema()
+    },
+    {
+      name: EXECUTE_EXTRA_TOOL_NAME,
+      description: EXECUTE_EXTRA_TOOL_DESCRIPTION,
+      inputSchema: createExecuteExtraToolInputSchema()
+    }
+  ];
+}
+function createModelToolDefinitions() {
+  return [
+    ...createModelToolDefinitionsForTools(
+      Object.values(builtInTools)
+    ),
+    ...createDeferredToolDispatchDefinitions(),
+    {
+      name: START_AGENT_TOOL_NAME,
+      description: START_AGENT_DESCRIPTION,
+      inputSchema: createStartAgentInputSchema()
+    },
+    {
+      name: AGENT_CONTROL_TOOL_NAME,
+      description: AGENT_CONTROL_DESCRIPTION,
+      inputSchema: createAgentControlInputSchema()
+    },
+    {
+      name: SEND_MESSAGE_TOOL_NAME,
+      description: SEND_MESSAGE_DESCRIPTION,
+      inputSchema: createSendMessageInputSchema()
+    },
+    {
+      name: RUN_WORKFLOW_TOOL_NAME,
+      description: RUN_WORKFLOW_DESCRIPTION,
+      inputSchema: createRunWorkflowInputSchema()
+    },
+    {
+      name: INDEX_OPERATION_TOOL_NAME,
+      description: INDEX_OPERATION_DESCRIPTION,
+      inputSchema: createIndexOperationInputSchema()
+    },
+    {
+      name: RUN_VERIFICATION_TOOL_NAME,
+      description: RUN_VERIFICATION_DESCRIPTION,
+      inputSchema: createRunVerificationInputSchema()
+    },
+    {
+      name: WRITE_REPORT_TOOL_NAME,
+      description: WRITE_REPORT_DESCRIPTION,
+      inputSchema: createWriteReportInputSchema()
+    },
+    ...createGitToolDefinitions(),
+    // D.14D-R P0-2 — 结构化索引能力：模型需要"看索引 / 更新索引"时调用真实工具，
+    // 而不是文本冒充执行，也不是本地 NL 正则；mutating 刷新/修复走权限确认。
+    ...createIndexToolDefinitions(),
+    {
+      name: COMMAND_PROPOSAL_TOOL_NAME,
+      description: COMMAND_PROPOSAL_DESCRIPTION,
+      inputSchema: createCommandProposalInputSchema()
+    }
+  ];
+}
+function createModelToolDefinitionsForTools(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: typeof tool.prompt === "function" ? `${tool.description}
+${tool.prompt()}` : tool.description,
+    inputSchema: createToolInputSchema(tool.name)
+  }));
+}
+function createModelToolDefinitionsForReportGuard(guard) {
+  if (!guard || guard.completed) {
+    return createModelToolDefinitions();
+  }
+  if (!guard.evidenceRead) {
+    return createModelToolDefinitionsForTools([
+      builtInTools.Read,
+      builtInTools.Grep,
+      builtInTools.Glob
+    ]);
+  }
+  if (guard.nonWriteToolRounds < 1) {
+    return createModelToolDefinitionsForTools(
+      Object.values(builtInTools).filter(
+        (tool) => tool.name !== "Bash"
+      )
+    );
+  }
+  return createModelToolDefinitionsForTools([builtInTools.Write]);
+}
+function createToolUseDriftSummary(toolName, input) {
+  const path = readToolInputString(input, "path") ?? readToolInputString(input, "file_path");
+  if ((toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit") && path) {
+    return `${toolName}: ${path}`;
+  }
+  return `${toolName}: ${JSON.stringify(input ?? {})}`;
+}
+function readToolInputString(input, key) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return void 0;
+  }
+  const value = input[key];
+  return typeof value === "string" ? value : void 0;
+}
+function isNaturalReadFileRequest(text) {
+  return /(?:\u8bfb|\u8bfb\u53d6|\u6253\u5f00|\u770b\u770b|\u67e5\u770b|show|read|open|view)\s*(?:\u4e00\u4e0b|\u4e0b)?/iu.test(
+    text
+  );
+}
+function hasModelSynthesisIntent(text) {
+  return /\u603b\u7ed3|\u6458\u8981|\u5206\u6790|\u89e3\u91ca|\u5f52\u7eb3|summary|summari[sz]e|analy[sz]e|explain/iu.test(
+    text
+  );
+}
+function looksLikeFilePath(value) {
+  return /[\\/]/u.test(value) || /\.[a-z0-9]{1,12}$/iu.test(value);
+}
+function extractNaturalReadPath(text) {
+  const quoted = /["\u2018\u2019\u201c\u201d'`]([^"\u2018\u2019\u201c\u201d'`]+)["\u2018\u2019\u201c\u201d'`]/u.exec(
+    text
+  )?.[1];
+  if (quoted && looksLikeFilePath(quoted)) {
+    return normalizeRelativePath(quoted);
+  }
+  const token = text.split(/\s+/).map((item) => item.replace(/[\uff0c\u3002,.!?\uff1b;\uff1a:\uff09)]+$/u, "")).find(looksLikeFilePath);
+  return token ? normalizeRelativePath(token) : null;
+}
+function normalizeRelativePath(path) {
+  return path.trim().replaceAll("\\", "/").replace(/^\.\//u, "");
+}
+function extractFileSearchKeywords(text) {
+  return text.replace(/["\u2018\u2019\u201c\u201d'`]/gu, " ").split(/[^\p{L}\p{N}_.-]+/u).map((item) => item.trim().toLowerCase()).filter((item) => item.length >= 2).filter(
+    (item) => ![
+      "read",
+      "open",
+      "view",
+      "show",
+      "file",
+      "the",
+      "this",
+      "that",
+      "previous",
+      "recent",
+      "\u8BFB\u53D6",
+      "\u6253\u5F00",
+      "\u67E5\u770B",
+      "\u770B\u770B",
+      "\u6587\u4EF6",
+      "\u8FD9\u4E2A",
+      "\u521A\u624D",
+      "\u4E0A\u9762",
+      "\u6700\u8FD1"
+    ].includes(item)
+  );
+}
+function matchesFileKeywords(file, keywords) {
+  if (keywords.length === 0) {
+    return false;
+  }
+  const normalized = file.toLowerCase();
+  const name = normalized.split("/").pop() ?? normalized;
+  return keywords.some((keyword) => normalized.includes(keyword) || name.includes(keyword));
+}
+function extractFileMentions(text) {
+  return text.split(/\r?\n/).map((line) => line.split(":")[0]?.trim() ?? "").filter((line) => /[\\/]|\.[a-z0-9]+$/iu.test(line)).map((line) => line.replaceAll("\\", "/"));
+}
+function formatFileCandidates(candidates, language) {
+  const lines = candidates.map((candidate) => `- ${candidate}`);
+  return language === "en-US" ? [
+    "Multiple files match that request. Please choose one with an explicit command:",
+    ...lines,
+    "Example: /read <path>"
+  ].join("\n") : [
+    "\u627E\u5230\u591A\u4E2A\u53EF\u80FD\u6587\u4EF6\uFF0C\u8BF7\u7528\u660E\u786E\u547D\u4EE4\u9009\u62E9\u4E00\u4E2A\uFF1A",
+    ...lines,
+    "\u793A\u4F8B\uFF1A/read <path>"
+  ].join("\n");
+}
+function createSolutionCompletenessStatus() {
+  return {
+    triggered: false,
+    triggerReason: "none",
+    classificationRequired: false,
+    classification: "unknown",
+    impactAreas: [],
+    severity: "unknown",
+    requiredBeforeAction: false,
+    evidenceRefs: [],
+    sourceRefs: [],
+    nextRequiredOutput: "none",
+    checklist: []
+  };
+}
+function inferSolutionCompletenessImpactAreas(text, triggerReason) {
+  const areas = /* @__PURE__ */ new Set();
+  const lower = text.toLowerCase();
+  if (/ccb|opencode|\u6210\u719f\u9879\u76ee|\u5bf9\u7167|\u5168\u5c40|\u7cfb\u7edf\u6027|\u5b8c\u6574\u6027/u.test(
+    lower
+  )) {
+    areas.add("reference_parity");
+    areas.add("runtime_behavior");
+  }
+  if (/\u6743\u9650|permission|denial|\u62d2\u7edd/u.test(lower) || triggerReason === "repeated_denial") {
+    areas.add("permission_pipeline");
+    areas.add("tool_loop");
+  }
+  if (/smoke|tui|\u4ea4\u4e92|\u624b\u611f|\u6c61\u67d3|\u5931\u771f/u.test(lower) || triggerReason === "smoke_contamination") {
+    areas.add("tui_smoke");
+    areas.add("natural_command_bridge");
+  }
+  if (/\u6587\u5b57\u8865\u4e01|regex|\u6b63\u5219|\u53ea\u6539\u6587\u6863|verifier|\u5ba1\u8ba1|audit/u.test(
+    lower
+  )) {
+    areas.add("implementation_scope");
+    areas.add("verification");
+  }
+  return [...areas];
+}
+function formatSolutionCompletenessTrigger(triggerReason) {
+  if (triggerReason === "user_request") {
+    return "\u7528\u6237\u660E\u786E\u8981\u6C42\u6210\u54C1\u7EA7/\u4E0D\u8981\u7F1D\u8865/\u5148\u5BF9\u7167\u6210\u719F\u53C2\u8003/\u5168\u5C40\u68C0\u67E5\u9057\u6F0F\u3002";
+  }
+  if (triggerReason === "smoke_contamination") {
+    return "\u771F\u5B9E smoke \u5DF2\u51FA\u73B0\u6C61\u67D3\u6216\u4EA4\u4E92\u5931\u771F\u3002";
+  }
+  if (triggerReason === "audit_finding") {
+    return "verifier/\u5BA1\u8BA1\u6307\u51FA\u6587\u5B57\u8865\u4E01\u3001regex \u8865\u4E01\u6216\u53EA\u6539\u6587\u6863\u98CE\u9669\u3002";
+  }
+  if (triggerReason === "repeated_denial") {
+    return "\u6700\u8FD1\u540C\u7C7B\u6743\u9650\u62D2\u7EDD\u53CD\u590D\u51FA\u73B0\u3002";
+  }
+  return "\u672A\u89E6\u53D1\u3002";
+}
+var STRUCTURED_FINAL_ANSWER_CLAIM_PREFIX = "LinghunFinalAnswerClaims:";
+var STALE_THRESHOLDS_MS = {
+  completion_claim: 30 * 60 * 1e3,
+  test_claim: 30 * 60 * 1e3,
+  file_change_claim: 30 * 60 * 1e3,
+  verification_claim: 30 * 60 * 1e3,
+  workflow_status_claim: null,
+  agent_status_claim: null,
+  completion_pass: 30 * 60 * 1e3,
+  code_fact: 60 * 60 * 1e3,
+  external_current_fact: 24 * 60 * 60 * 1e3,
+  ccb_parity: null,
+  beta_readiness: null,
+  // D.14G：git 稳定点/worktree 操作绑定到本会话真实 git_operation evidence，不按时间过期。
+  git_operation: null,
+  // Run 2 P1-2：mutating 动作（install/Bash/Write/Edit/index refresh）的"已执行成功"声明，
+  // 绑定到本会话真实成功 evidence；执行成功通常 30 分钟内有效，超时按需重新验证。
+  action_executed: 30 * 60 * 1e3,
+  architecture_boundary: null,
+  completeness: null
+};
+function isEvidenceStaleForClaim(record, kind, now = /* @__PURE__ */ new Date()) {
+  const threshold = STALE_THRESHOLDS_MS[kind];
+  if (threshold === null) return false;
+  const created = Date.parse(record.createdAt);
+  if (Number.isNaN(created)) return false;
+  return now.getTime() - created > threshold;
+}
+var FINAL_ANSWER_CLAIM_KINDS = [
+  "completion_claim",
+  "test_claim",
+  "file_change_claim",
+  "verification_claim",
+  "workflow_status_claim",
+  "agent_status_claim",
+  "completion_pass",
+  "code_fact",
+  "external_current_fact",
+  "ccb_parity",
+  "beta_readiness",
+  "git_operation",
+  "action_executed",
+  "architecture_boundary",
+  "completeness"
+];
+function pushStructuredClaim(out, seen, kind, phrase) {
+  const key = `${kind}\0${phrase}`;
+  if (seen.has(key)) return;
+  seen.add(key);
+  out.push({ kind, phrase });
+}
+function extractStructuredFinalAnswerClaims(text) {
+  return parseStructuredFinalAnswerClaims(text);
+}
+function parseStructuredFinalAnswerClaims(text) {
+  if (!text) return [];
+  const line = text.split(/\r?\n/u).map((item) => item.trim()).find((item) => item.includes(STRUCTURED_FINAL_ANSWER_CLAIM_PREFIX));
+  if (!line) return [];
+  const prefixIndex = line.indexOf(STRUCTURED_FINAL_ANSWER_CLAIM_PREFIX);
+  const payload = line.slice(prefixIndex + STRUCTURED_FINAL_ANSWER_CLAIM_PREFIX.length).trim();
+  if (!payload) return [];
+  try {
+    const parsed = JSON.parse(payload);
+    const claims = Array.isArray(parsed) ? parsed : isPlainRecord(parsed) && Array.isArray(parsed.claims) ? parsed.claims : [];
+    const out = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const item of claims) {
+      if (!isPlainRecord(item)) continue;
+      const kind = item.kind;
+      if (!isFinalAnswerClaimKind(kind)) continue;
+      const phrase = typeof item.phrase === "string" && item.phrase.trim() ? item.phrase.trim() : kind;
+      pushStructuredClaim(out, seen, kind, phrase);
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFinalAnswerClaimKind(value) {
+  return typeof value === "string" && FINAL_ANSWER_CLAIM_KINDS.includes(value);
+}
+function stripStructuredFinalAnswerClaims(text) {
+  if (!text) return text;
+  return text.split(/\r?\n/u).filter((line) => !line.trim().startsWith(STRUCTURED_FINAL_ANSWER_CLAIM_PREFIX)).join("\n").trim();
+}
+function evidenceTokens(record) {
+  return [record.kind, record.source, record.summary, ...record.supportsClaims].join(" ").toLowerCase();
+}
+function claimWindow(text, phrase) {
+  const index = text.indexOf(phrase);
+  if (index < 0) return phrase;
+  return text.slice(Math.max(0, index - 48), index + phrase.length + 48).toLowerCase();
+}
+function isTestCompletionClaim(text, phrase) {
+  const lowered = phrase.toLowerCase();
+  return /(?:测试|tests?\s+passed|vitest|jest|pytest|go\s+test|cargo\s+test)/iu.test(lowered);
+}
+function isTypecheckCompletionClaim(text, phrase) {
+  const lowered = phrase.toLowerCase();
+  return /(?:typecheck|type\s+check|tsc|类型检查)/iu.test(lowered) || lowered === "pass" && /(?:typecheck|type\s+check|tsc|类型检查)/iu.test(claimWindow(text, phrase));
+}
+function isBuildCompletionClaim(text, phrase) {
+  const lowered = phrase.toLowerCase();
+  return /(?:build|构建)/iu.test(lowered) || lowered === "pass" && /(?:build|构建)/iu.test(claimWindow(text, phrase));
+}
+function isDiffCheckCompletionClaim(text, phrase) {
+  const lowered = phrase.toLowerCase();
+  return /(?:diff[-\s]?check|git\s+diff\s+--check)/iu.test(lowered) || lowered === "pass" && /(?:diff[-\s]?check|git\s+diff\s+--check)/iu.test(claimWindow(text, phrase));
+}
+function isSmokeCompletionClaim(text, phrase) {
+  const lowered = phrase.toLowerCase();
+  return /(?:smoke|冒烟)/iu.test(lowered) || lowered === "pass" && /(?:smoke|冒烟)/iu.test(claimWindow(text, phrase));
+}
+function evidenceSupportsTaskCompletion(record) {
+  const tokens = evidenceTokens(record);
+  return /(?:task_completed|completion_evidence|任务完成证据)/iu.test(tokens) && /(?:scope[:=]|scope_|范围[:=]|范围_)/iu.test(tokens) && /(?:validation[:=]|validation_|验证[:=]|验证_)/iu.test(tokens) && /(?:remaining[_\s-]?risk[:=]|remaining[_\s-]?risk_|residual[_\s-]?risk[:=]|risk[:=]|剩余风险[:=]|剩余风险_)/iu.test(
+    tokens
+  );
+}
+function evidenceSupportsCommandClaim(record, claim) {
+  if (claim === "test") {
+    return record.supportsClaims.includes("test_passed");
+  }
+  if (claim === "typecheck") {
+    return record.supportsClaims.includes("typecheck_passed");
+  }
+  if (claim === "build") {
+    return record.supportsClaims.includes("build_passed");
+  }
+  if (claim === "diff_check") {
+    return record.supportsClaims.includes("diff_check_passed");
+  }
+  return record.supportsClaims.includes("smoke_passed");
+}
+function evidenceSupportsCompletionClaim(record, text, match) {
+  if (isTestCompletionClaim(text, match.phrase)) {
+    return evidenceSupportsCommandClaim(record, "test");
+  }
+  if (isTypecheckCompletionClaim(text, match.phrase)) {
+    return evidenceSupportsCommandClaim(record, "typecheck");
+  }
+  if (isBuildCompletionClaim(text, match.phrase)) {
+    return evidenceSupportsCommandClaim(record, "build");
+  }
+  if (isDiffCheckCompletionClaim(text, match.phrase)) {
+    return evidenceSupportsCommandClaim(record, "diff_check");
+  }
+  if (isSmokeCompletionClaim(text, match.phrase)) {
+    return evidenceSupportsCommandClaim(record, "smoke");
+  }
+  return evidenceSupportsTaskCompletion(record);
+}
+function evidenceSupportsVerificationClaim(record) {
+  if (record.kind !== "test_result" && record.kind !== "command_output") return false;
+  if (record.supportsClaims.includes("tool_failure")) return false;
+  return record.supportsClaims.includes("verification_passed") || record.supportsClaims.includes("test_passed") || record.supportsClaims.includes("typecheck_passed") || record.supportsClaims.includes("build_passed") || record.supportsClaims.includes("diff_check_passed") || record.supportsClaims.includes("smoke_passed");
+}
+function evidenceSupportsFileChangeClaim(record) {
+  if (record.kind !== "command_output") return false;
+  if (record.supportsClaims.includes("tool_failure")) return false;
+  if (record.supportsClaims.includes("bash_exit_nonzero")) return false;
+  return record.supportsClaims.includes("file_written") || record.supportsClaims.includes("Write") || record.supportsClaims.includes("Edit") || record.supportsClaims.includes("MultiEdit");
+}
+function evidenceSupportsWorkflowStatusClaim(record) {
+  if (record.kind !== "command_output") return false;
+  if (record.supportsClaims.includes("tool_failure")) return false;
+  return record.supportsClaims.includes("workflow_execution") && record.supportsClaims.includes("workflow_terminal_status");
+}
+function evidenceSupportsAgentStatusClaim(record) {
+  if (record.kind !== "command_output") return false;
+  if (record.supportsClaims.includes("tool_failure")) return false;
+  return record.supportsClaims.includes("agent_execution") && record.supportsClaims.includes("agent_terminal_status");
+}
+function evidenceSupportsIndexCodeFact(record) {
+  if (record.kind !== "index_query") {
+    return false;
+  }
+  if (!record.supportsClaims.includes("index_code_fact")) {
+    return false;
+  }
+  const tokens = evidenceTokens(record);
+  if (/(?:missing|stale|error|not ready|no matches|status[:=\s]+(?:missing|stale|error))/iu.test(
+    tokens
+  )) {
+    return false;
+  }
+  return /(?:\bpath\s*(?:=|:|\s)\s*(?!unknown\b|-)(?:[^\s,;]+)|\bfile_path\s*[:=]\s*(?!unknown\b|-)(?:[^\s,;]+)|\bfile:\s*(?!unknown\b|-)(?:[^\s,;]+)|\bsymbol\s*(?:=|:|\s)\s*(?!unknown\b|-)(?:[^\s,;]+)|\bsnippet\s*=\s*(?!\s*$).+|\bmatch\s*=\s*(?!\s*$).+)/imu.test(
+    tokens
+  );
+}
+function evidenceSupportsLocalCodeFact(record) {
+  if (record.kind === "index_query") {
+    return evidenceSupportsIndexCodeFact(record);
+  }
+  if (record.kind === "file_read" || record.kind === "grep_result") {
+    return true;
+  }
+  const tokens = evidenceTokens(record);
+  return /(?:local_read|grep_match|file:|git_local_fact|git_status)/iu.test(tokens);
+}
+function evidenceSupportsExternalCurrent(record) {
+  if (record.kind === "web_source") return true;
+  return /(?:web_source|external_current_fact)/iu.test(evidenceTokens(record));
+}
+function evidenceSupportsCcbParity(record) {
+  const tokens = evidenceTokens(record);
+  if (/(?:reference_parity_verified|reference_audit)/iu.test(tokens)) return true;
+  if ((record.kind === "file_read" || record.kind === "grep_result") && /reference[-_]parity/iu.test(tokens)) {
+    return true;
+  }
+  return false;
+}
+function evidenceSupportsGitOperation(record) {
+  return record.supportsClaims.some(
+    (claim) => claim === "git_operation" || claim === "stable_point_created" || claim === "worktree_created" || claim === "worktree_resumed" || claim === "worktree_removed"
+  );
+}
+function evidenceSupportsActionExecuted(record) {
+  if (record.kind === "image_result") {
+    return record.supportsClaims.includes("image_result");
+  }
+  if (record.kind !== "command_output" && record.kind !== "test_result") {
+    return false;
+  }
+  if (record.supportsClaims.includes("tool_failure")) {
+    return false;
+  }
+  if (record.supportsClaims.includes("bash_exit_nonzero")) {
+    return false;
+  }
+  const tokens = evidenceTokens(record);
+  if (/(?:denied|cancelled|canceled|permission denied|failure|未执行|拒绝|取消)/iu.test(tokens)) {
+    return false;
+  }
+  return record.supportsClaims.some(
+    (claim) => claim === "Bash" || claim === "Write" || claim === "Edit" || claim === "MultiEdit" || claim === "command_ran" || claim === "file_written" || claim === "index_operation" || claim === "index_refresh" || claim === "index_init_fast" || claim === "index_repair" || claim === "image_result"
+  );
+}
+var REQUIRED_EVIDENCE_LABEL = {
+  completion_claim: "task completion evidence",
+  test_claim: "test result evidence",
+  file_change_claim: "file change evidence",
+  verification_claim: "verification evidence",
+  workflow_status_claim: "terminal successful workflow runtime evidence",
+  agent_status_claim: "terminal successful agent runtime evidence",
+  completion_pass: "test/build/typecheck/diff-check/smoke",
+  code_fact: "Read/Grep/index",
+  external_current_fact: "web_source",
+  ccb_parity: "reference parity evidence (local or web_source)",
+  beta_readiness: "Beta readiness verdict (real-tui report-generation PASS)",
+  git_operation: "git_operation evidence (real stable point / worktree create / worktree remove)",
+  action_executed: "real successful command_output (install / Bash / Write / index refresh)",
+  architecture_boundary: "Architecture Card \u4E0E drift check",
+  completeness: "Solution Completeness classification (single_issue / systemic_gap)"
+};
+function evaluateFinalAnswerClaims(text, evidence, now = /* @__PURE__ */ new Date()) {
+  const structured = extractStructuredFinalAnswerClaims(text).filter(
+    (claim) => claim.kind !== "architecture_boundary" && claim.kind !== "completeness"
+  );
+  return evaluateStructuredFinalAnswerClaims(structured, evidence, now, text);
+}
+function evaluateStructuredFinalAnswerClaims(matches, evidence, now = /* @__PURE__ */ new Date(), sourceText = "") {
+  if (matches.length === 0) {
+    return {
+      status: "passed",
+      matchedClaims: [],
+      unsupportedKinds: [],
+      missingEvidenceKinds: []
+    };
+  }
+  const matchedKinds = new Set(matches.map((item) => item.kind));
+  const unsupported = [];
+  const staleKinds = [];
+  for (const kind of matchedKinds) {
+    let supported = false;
+    let supporter;
+    if (kind === "completion_claim") {
+      const matching2 = evidence.filter(evidenceSupportsTaskCompletion);
+      const fresh2 = matching2.filter((rec) => !isEvidenceStaleForClaim(rec, kind, now));
+      supported = fresh2.length > 0;
+      if (!supported) {
+        unsupported.push(kind);
+        if (matching2.length > 0 && fresh2.length === 0) {
+          staleKinds.push(kind);
+        }
+      }
+      continue;
+    }
+    if (kind === "test_claim") {
+      const matching2 = evidence.filter((record) => evidenceSupportsCommandClaim(record, "test"));
+      const fresh2 = matching2.filter((rec) => !isEvidenceStaleForClaim(rec, kind, now));
+      supported = fresh2.length > 0;
+      if (!supported) {
+        unsupported.push(kind);
+        if (matching2.length > 0 && fresh2.length === 0) {
+          staleKinds.push(kind);
+        }
+      }
+      continue;
+    }
+    if (kind === "verification_claim") {
+      const matching2 = evidence.filter(evidenceSupportsVerificationClaim);
+      const fresh2 = matching2.filter((rec) => !isEvidenceStaleForClaim(rec, kind, now));
+      supported = fresh2.length > 0;
+      if (!supported) {
+        unsupported.push(kind);
+        if (matching2.length > 0 && fresh2.length === 0) {
+          staleKinds.push(kind);
+        }
+      }
+      continue;
+    }
+    if (kind === "completion_pass") {
+      const completionMatches = matches.filter((item) => item.kind === "completion_pass");
+      const matching2 = evidence.filter(
+        (record) => completionMatches.some(
+          (match) => evidenceSupportsCompletionClaim(record, sourceText, match)
+        )
+      );
+      const fresh2 = matching2.filter((rec) => !isEvidenceStaleForClaim(rec, kind, now));
+      supported = completionMatches.every(
+        (match) => fresh2.some((record) => evidenceSupportsCompletionClaim(record, sourceText, match))
+      );
+      if (!supported) {
+        unsupported.push(kind);
+        if (matching2.length > 0 && fresh2.length === 0) {
+          staleKinds.push(kind);
+        }
+      }
+      continue;
+    }
+    if (kind === "code_fact") {
+      supporter = evidenceSupportsLocalCodeFact;
+    } else if (kind === "external_current_fact") {
+      supporter = evidenceSupportsExternalCurrent;
+    } else if (kind === "file_change_claim") {
+      supporter = evidenceSupportsFileChangeClaim;
+    } else if (kind === "workflow_status_claim") {
+      supporter = evidenceSupportsWorkflowStatusClaim;
+    } else if (kind === "agent_status_claim") {
+      supporter = evidenceSupportsAgentStatusClaim;
+    } else if (kind === "ccb_parity") {
+      supporter = evidenceSupportsCcbParity;
+    } else if (kind === "git_operation") {
+      supporter = evidenceSupportsGitOperation;
+    } else if (kind === "action_executed") {
+      supporter = evidenceSupportsActionExecuted;
+    } else {
+      supporter = () => false;
+    }
+    const matching = evidence.filter(supporter);
+    const fresh = matching.filter((rec) => !isEvidenceStaleForClaim(rec, kind, now));
+    supported = fresh.length > 0;
+    if (!supported) {
+      unsupported.push(kind);
+      if (matching.length > 0 && fresh.length === 0) {
+        staleKinds.push(kind);
+      }
+    }
+  }
+  if (unsupported.length === 0) {
+    return {
+      status: "passed",
+      matchedClaims: matches,
+      unsupportedKinds: [],
+      missingEvidenceKinds: []
+    };
+  }
+  const missingEvidenceKinds = unsupported.map((kind) => REQUIRED_EVIDENCE_LABEL[kind]);
+  const verdict = {
+    status: "needs_disclaimer",
+    matchedClaims: matches,
+    unsupportedKinds: unsupported,
+    missingEvidenceKinds
+  };
+  if (staleKinds.length > 0) {
+    verdict.staleKinds = staleKinds;
+  }
+  return verdict;
+}
+function createFinalAnswerClaimReminder(verdict, language) {
+  const phrases = Array.from(new Set(verdict.matchedClaims.map((m) => m.phrase))).slice(0, 6);
+  const kinds = Array.from(new Set(verdict.missingEvidenceKinds)).join(", ");
+  const hasStale = verdict.staleKinds && verdict.staleKinds.length > 0;
+  if (language === "en-US") {
+    const stalePart2 = hasStale ? " Some prior evidence was ignored because it is too old to support these claims." : "";
+    return `Your last reply contains high-risk claims (${phrases.join(", ")}) but the session has no matching evidence (missing: ${kinds}).${stalePart2} Rewrite the reply using only evidence-backed claims, or call a tool first to gather evidence. Keep LinghunFinalAnswerClaims aligned with the rewritten answer. You have only one rewrite chance.`;
+  }
+  const stalePart = hasStale ? "\u90E8\u5206\u65E9\u671F\u8BC1\u636E\u5DF2\u8FC7\u671F\u88AB\u5FFD\u7565\u3002" : "";
+  return `\u4F60\u4E0A\u6B21\u56DE\u7B54\u91CC\u51FA\u73B0\u4E86\u9AD8\u98CE\u9669\u58F0\u660E\uFF08${phrases.join(", ")}\uFF09\uFF0C\u4F46\u5F53\u524D\u4F1A\u8BDD\u6CA1\u6709\u5BF9\u5E94\u7C7B\u578B\u7684\u8BC1\u636E\uFF08\u7F3A\uFF1A${kinds}\uFF09\u3002${stalePart}\u8BF7\u57FA\u4E8E\u5DF2\u6709\u8BC1\u636E\u91CD\u5199\u56DE\u7B54\uFF1B\u82E5\u8BC1\u636E\u4E0D\u8DB3\uFF0C\u5148\u8C03\u7528\u5DE5\u5177\u8865\u8BC1\u636E\u6216\u79FB\u9664\u8BE5\u58F0\u660E\u3002LinghunFinalAnswerClaims \u5FC5\u987B\u4E0E\u91CD\u5199\u540E\u7684\u7B54\u6848\u4FDD\u6301\u4E00\u81F4\u3002\u4EC5\u672C\u8F6E\u4E00\u6B21\u4FEE\u6B63\u673A\u4F1A\u3002`;
+}
+function buildDowngradedFinalAnswer(verdict, language) {
+  const missing = Array.from(new Set(verdict.missingEvidenceKinds)).join(", ") || "matching evidence";
+  const kinds = Array.from(new Set(verdict.unsupportedKinds)).join(", ") || "claim";
+  return language === "en-US" ? [
+    "I cannot provide a verified final claim from the current evidence.",
+    `Missing evidence: ${missing}.`,
+    `Blocked claim types: ${kinds}.`,
+    "I can continue by gathering evidence with tools, or give a limited answer that avoids verified-completion claims."
+  ].join("\n") : [
+    "\u5F53\u524D\u8BC1\u636E\u4E0D\u8DB3\uFF0C\u4E0D\u80FD\u7ED9\u51FA\u5DF2\u9A8C\u8BC1\u7684\u6700\u7EC8\u7ED3\u8BBA\u3002",
+    `\u7F3A\u5C11\u8BC1\u636E\uFF1A${missing}\u3002`,
+    `\u88AB\u62E6\u622A\u7684\u58F0\u660E\u7C7B\u578B\uFF1A${kinds}\u3002`,
+    "\u6211\u53EF\u4EE5\u7EE7\u7EED\u8C03\u7528\u5DE5\u5177\u8865\u9F50\u8BC1\u636E\uFF0C\u6216\u53EA\u7ED9\u51FA\u4E0D\u5305\u542B\u5DF2\u9A8C\u8BC1\u5B8C\u6210\u58F0\u660E\u7684\u6709\u9650\u7ED3\u8BBA\u3002"
+  ].join("\n");
+}
+function evaluateArchitectureAndCompletenessClaims(text, architecture, completeness) {
+  const matched = extractStructuredFinalAnswerClaims(text).flatMap(
+    (claim) => claim.kind === "architecture_boundary" || claim.kind === "completeness" ? [{ kind: claim.kind, phrase: claim.phrase }] : []
+  );
+  if (matched.length === 0) {
+    return {
+      status: "passed",
+      matchedClaims: [],
+      unsupportedKinds: [],
+      missingEvidenceKinds: []
+    };
+  }
+  const unsupported = [];
+  const missing = [];
+  const matchedKinds = new Set(matched.map((m) => m.kind));
+  if (matchedKinds.has("architecture_boundary")) {
+    const supported = architecture.hasActiveCard && (architecture.driftWarnings?.length ?? 0) === 0 && architecture.hasArchitectureEvidence !== false;
+    if (!supported) {
+      unsupported.push("architecture_boundary");
+      missing.push("Architecture Card \u4E0E drift check");
+    }
+  }
+  if (matchedKinds.has("completeness")) {
+    const supported = !completeness.classificationRequired || completeness.classification !== "unknown" && completeness.textHasClassification;
+    if (!supported) {
+      unsupported.push("completeness");
+      missing.push("Solution Completeness classification (single_issue / systemic_gap)");
+    }
+  }
+  if (unsupported.length === 0) {
+    return {
+      status: "passed",
+      matchedClaims: matched,
+      unsupportedKinds: [],
+      missingEvidenceKinds: []
+    };
+  }
+  return {
+    status: "needs_disclaimer",
+    matchedClaims: matched,
+    unsupportedKinds: unsupported,
+    missingEvidenceKinds: missing
+  };
+}
+function createExtendedFinalAnswerReminder(verdict, language) {
+  const phrases = Array.from(new Set(verdict.matchedClaims.map((m) => m.phrase))).slice(0, 6);
+  const kinds = Array.from(new Set(verdict.missingEvidenceKinds)).join(", ");
+  if (language === "en-US") {
+    return `Your last reply contains high-risk claims (${phrases.join(", ")}) but the session has no matching support (missing: ${kinds}). Rewrite the reply using only supported architecture/completeness claims, or run a tool / call /claim-check to gather support first. You have only one rewrite chance.`;
+  }
+  return `\u4F60\u4E0A\u6B21\u56DE\u7B54\u91CC\u51FA\u73B0\u4E86\u9AD8\u98CE\u9669\u58F0\u660E\uFF08${phrases.join(", ")}\uFF09\uFF0C\u4F46\u5F53\u524D\u4F1A\u8BDD\u6CA1\u6709\u5BF9\u5E94\u8BC1\u636E\uFF08\u7F3A\uFF1A${kinds}\uFF09\u3002\u8BF7\u57FA\u4E8E\u5DF2\u6709\u67B6\u6784 / \u5B8C\u6574\u6027\u652F\u6491\u91CD\u5199\u56DE\u7B54\uFF1B\u82E5\u652F\u6491\u4E0D\u8DB3\uFF0C\u5148\u8C03\u7528\u5DE5\u5177 / \u5148\u8D70 /claim-check \u8865\u8BC1\u636E\u6216\u79FB\u9664\u8BE5\u58F0\u660E\u3002\u4EC5\u672C\u8F6E\u4E00\u6B21\u4FEE\u6B63\u673A\u4F1A\u3002`;
+}
+function buildExtendedDowngradedFinalAnswer(verdict, language) {
+  const missing = Array.from(new Set(verdict.missingEvidenceKinds)).join(", ") || "matching support";
+  const kinds = Array.from(new Set(verdict.unsupportedKinds)).join(", ") || "claim";
+  return language === "en-US" ? [
+    "I cannot provide a verified architecture or completeness claim from the current evidence.",
+    `Missing support: ${missing}.`,
+    `Blocked claim types: ${kinds}.`,
+    "I can continue by gathering support, or give a limited answer that avoids closure claims."
+  ].join("\n") : [
+    "\u5F53\u524D\u8BC1\u636E\u4E0D\u8DB3\uFF0C\u4E0D\u80FD\u7ED9\u51FA\u5DF2\u9A8C\u8BC1\u7684\u67B6\u6784\u6216\u5B8C\u6574\u6027\u7ED3\u8BBA\u3002",
+    `\u7F3A\u5C11\u652F\u6491\uFF1A${missing}\u3002`,
+    `\u88AB\u62E6\u622A\u7684\u58F0\u660E\u7C7B\u578B\uFF1A${kinds}\u3002`,
+    "\u6211\u53EF\u4EE5\u7EE7\u7EED\u8865\u9F50\u652F\u6491\uFF0C\u6216\u53EA\u7ED9\u51FA\u4E0D\u5305\u542B\u95ED\u5408\u6027\u58F0\u660E\u7684\u6709\u9650\u7ED3\u8BBA\u3002"
+  ].join("\n");
+}
+function finalAnswerHasCompletenessClassification(text) {
+  return /\b(single_issue|systemic_gap)\b/u.test(text);
+}
+function hasArchitectureEvidenceForClaims(evidence) {
+  return evidence.some((rec) => {
+    const claims = rec.supportsClaims ?? [];
+    if (claims.includes("architecture_boundary_check") || claims.includes("architecture_card") || claims.includes("architecture_runtime")) {
+      return true;
+    }
+    const source = (rec.source ?? "").toLowerCase();
+    if (rec.kind === "file_read" && /architecture-(?:boundary|runtime)/.test(source)) {
+      return true;
+    }
+    return false;
+  });
+}
+function projectRuntimeStatusForPrompt(runtimeStatus) {
+  if (!runtimeStatus || typeof runtimeStatus !== "object") return null;
+  const r = runtimeStatus;
+  const model = r.model && typeof r.model === "object" ? r.model.name ?? "unknown" : "unknown";
+  const memory = r.memory ?? {};
+  const index = r.index ?? {};
+  const cache = r.cache ?? {};
+  const extensions = r.extensions ?? {};
+  const skills = extensions.skills ?? {};
+  const plugins = extensions.plugins ?? {};
+  const hooks = extensions.hooks ?? {};
+  return {
+    memory: {
+      linghunMd: memory.linghunMd ?? "missing",
+      candidates: typeof memory.candidates === "number" ? memory.candidates : 0,
+      accepted: typeof memory.accepted === "number" ? memory.accepted : 0,
+      autoAccept: memory.autoAccept === true
+    },
+    index: {
+      status: typeof index.status === "string" ? index.status : "unknown",
+      projectName: typeof index.projectName === "string" ? index.projectName : null,
+      changedFiles: typeof index.changedFiles === "number" ? index.changedFiles : null
+    },
+    cache: {
+      latestHitRate: typeof cache.latestHitRate === "number" ? cache.latestHitRate : null,
+      changedKeys: Array.isArray(cache.changedKeys) ? cache.changedKeys.filter((k) => typeof k === "string") : []
+    },
+    model: { name: typeof model === "string" ? model : "unknown" },
+    permissionMode: typeof r.permissionMode === "string" ? r.permissionMode : "default",
+    extensions: {
+      skills: {
+        enabled: skills.enabled === true,
+        count: typeof skills.count === "number" ? skills.count : 0
+      },
+      plugins: {
+        enabled: plugins.enabled === true,
+        count: typeof plugins.count === "number" ? plugins.count : 0
+      },
+      hooks: {
+        enabled: hooks.enabled === true,
+        count: typeof hooks.count === "number" ? hooks.count : 0
+      }
+    }
+  };
+}
+function sanitizeDeferredToolPrimaryText(rawText, language, options) {
+  if (options.dispatchKind === "SearchExtraTools" && options.ok) {
+    const count = options.matchedCount ?? extractMatchedCount(rawText);
+    return language === "en-US" ? `Found ${count} extension tool(s).` : `\u5DF2\u53D1\u73B0 ${count} \u4E2A\u6269\u5C55\u5DE5\u5177\u3002`;
+  }
+  if (options.dispatchKind === "ExecuteExtraTool" && options.ok) {
+    return language === "en-US" ? "Extension tool finished." : "\u6269\u5C55\u5DE5\u5177\u8C03\u7528\u5B8C\u6210\u3002";
+  }
+  const reason = stripDeferredInternalTokens(rawText);
+  return language === "en-US" ? `Extension tool call failed: ${reason}` : `\u6269\u5C55\u5DE5\u5177\u8C03\u7528\u5931\u8D25\uFF1A${reason}`;
+}
+function extractMatchedCount(text) {
+  const m = /matched\s+(\d+)/iu.exec(text);
+  return m?.[1] ? Number.parseInt(m[1], 10) : 0;
+}
+function stripDeferredInternalTokens(text) {
+  return text.replace(/^SearchExtraTools[:\s]+/iu, "").replace(/^ExecuteExtraTool[\s(:][^\uff1a:]*[\uff09)]?[:\s]*/iu, "").replace(/SearchExtraTools/giu, "").replace(/ExecuteExtraTool/giu, "").replace(/executeDeferredDispatchToolUse/giu, "").replace(/dispatcher/giu, "").replace(/\s{2,}/gu, " ").trim();
+}
+function deriveToolSupportsClaims(name, input, output) {
+  const claims = /* @__PURE__ */ new Set([name]);
+  const inputObj = input ?? {};
+  if (name === "Read") {
+    claims.add("local_read");
+    const filePath = typeof inputObj.file_path === "string" ? inputObj.file_path : void 0;
+    if (filePath) claims.add(`file:${filePath}`);
+  }
+  if (name === "Grep") {
+    claims.add("local_read");
+    claims.add("grep_match");
+    const pattern = typeof inputObj.pattern === "string" ? inputObj.pattern : void 0;
+    if (pattern) claims.add(`pattern:${pattern.slice(0, 60)}`);
+  }
+  if (name === "Glob") {
+    claims.add("local_read");
+    claims.add("grep_match");
+  }
+  if (name === "Write" || name === "Edit" || name === "MultiEdit") {
+    claims.add("file_written");
+    const filePath = typeof inputObj.file_path === "string" ? inputObj.file_path : void 0;
+    if (filePath) claims.add(`file:${filePath}`);
+  }
+  if (name === "Bash") {
+    const command = typeof inputObj.command === "string" ? inputObj.command : "";
+    claims.add("command_ran");
+    const dataExit = output.data?.exitCode;
+    const exitOk = typeof dataExit === "number" && dataExit === 0 || typeof dataExit !== "number" && /(?:^|\s)exit\s*code\s*0(?:\s|$)/iu.test(output.text ?? "");
+    claims.add(exitOk ? "bash_exit_0" : "bash_exit_nonzero");
+    const cmd = command.toLowerCase();
+    if (exitOk) {
+      if (/(?:^|[\s&|;])(?:vitest|jest|pytest|go\s+test|cargo\s+test|mocha|jasmine|tap\b)/iu.test(cmd)) {
+        claims.add("test_passed");
+      }
+      if (/(?:^|[\s&|;])(?:tsc)(?:\s|$)/iu.test(cmd) || /tsc\s+--noemit/iu.test(cmd)) {
+        claims.add("typecheck_passed");
+      }
+      if (/(?:^|[\s&|;])(?:pnpm|npm|yarn)\s+(?:run\s+)?build(?:\s|$)/iu.test(cmd) || /(?:^|[\s&|;])(?:cargo|go)\s+build(?:\s|$)/iu.test(cmd)) {
+        claims.add("build_passed");
+      }
+      if (/git\s+diff\s+--check/iu.test(cmd)) {
+        claims.add("diff_check_passed");
+      }
+      if (/(?:^|[\s&|;])(?:smoke|run-smoke|.*\bsmoke\b.*)/iu.test(cmd)) {
+        claims.add("smoke_ran");
+      }
+      if (/git\s+(?:status|branch|rev-parse|log|show-ref|symbolic-ref)/iu.test(cmd)) {
+        claims.add("git_status");
+        claims.add("git_local_fact");
+      }
+    }
+  }
+  return Array.from(claims);
+}
+
+export {
+  createToolInputSchema,
+  SEARCH_EXTRA_TOOLS_NAME,
+  EXECUTE_EXTRA_TOOL_NAME,
+  COMMAND_PROPOSAL_TOOL_NAME,
+  START_AGENT_TOOL_NAME,
+  AGENT_CONTROL_TOOL_NAME,
+  SEND_MESSAGE_TOOL_NAME,
+  RUN_WORKFLOW_TOOL_NAME,
+  INDEX_OPERATION_TOOL_NAME,
+  RUN_VERIFICATION_TOOL_NAME,
+  WRITE_REPORT_TOOL_NAME,
+  SEARCH_EXTRA_TOOLS_DESCRIPTION,
+  EXECUTE_EXTRA_TOOL_DESCRIPTION,
+  COMMAND_PROPOSAL_DESCRIPTION,
+  START_AGENT_DESCRIPTION,
+  AGENT_CONTROL_DESCRIPTION,
+  SEND_MESSAGE_DESCRIPTION,
+  RUN_WORKFLOW_DESCRIPTION,
+  INDEX_OPERATION_DESCRIPTION,
+  RUN_VERIFICATION_DESCRIPTION,
+  WRITE_REPORT_DESCRIPTION,
+  createSearchExtraToolsInputSchema,
+  createExecuteExtraToolInputSchema,
+  createCommandProposalInputSchema,
+  createStartAgentInputSchema,
+  createAgentControlInputSchema,
+  createSendMessageInputSchema,
+  createRunWorkflowInputSchema,
+  createIndexOperationInputSchema,
+  createRunVerificationInputSchema,
+  createWriteReportInputSchema,
+  createDeferredToolDispatchDefinitions,
+  createModelToolDefinitions,
+  createModelToolDefinitionsForTools,
+  createModelToolDefinitionsForReportGuard,
+  createToolUseDriftSummary,
+  readToolInputString,
+  isNaturalReadFileRequest,
+  hasModelSynthesisIntent,
+  looksLikeFilePath,
+  extractNaturalReadPath,
+  normalizeRelativePath,
+  extractFileSearchKeywords,
+  matchesFileKeywords,
+  extractFileMentions,
+  formatFileCandidates,
+  createSolutionCompletenessStatus,
+  inferSolutionCompletenessImpactAreas,
+  formatSolutionCompletenessTrigger,
+  STRUCTURED_FINAL_ANSWER_CLAIM_PREFIX,
+  isEvidenceStaleForClaim,
+  extractStructuredFinalAnswerClaims,
+  stripStructuredFinalAnswerClaims,
+  evidenceSupportsLocalCodeFact,
+  evaluateFinalAnswerClaims,
+  evaluateStructuredFinalAnswerClaims,
+  createFinalAnswerClaimReminder,
+  buildDowngradedFinalAnswer,
+  evaluateArchitectureAndCompletenessClaims,
+  createExtendedFinalAnswerReminder,
+  buildExtendedDowngradedFinalAnswer,
+  finalAnswerHasCompletenessClassification,
+  hasArchitectureEvidenceForClaims,
+  projectRuntimeStatusForPrompt,
+  sanitizeDeferredToolPrimaryText,
+  deriveToolSupportsClaims
+};