@linghun/tui 0.1.0

package/dist/chunk-NKFKOEYX.js

@@ -0,0 +1,146 @@
+import {
+  charWidth
+} from "./chunk-APJIC2O5.js";
+
+// src/shell/models/transcript-selection-state.ts
+import {
+  isTerminalSelectionMouseInput,
+  isTerminalSelectionStale,
+  parseTerminalSelectionMouseEvent,
+  reduceTerminalSelection,
+  terminalSelectedTextFromRows,
+  terminalSelectionContainsRow,
+  terminalSelectionLineIndexesForBlock,
+  terminalSelectionLineRangesForBlock
+} from "@linghun/ink-runtime";
+function buildTranscriptScreenBuffer(blocks, width = Number.POSITIVE_INFINITY) {
+  const rows = [];
+  for (const block of blocks) {
+    const noSelect = isNoSelectBlock(block);
+    const body = screenTextForBlock(block);
+    const lines = body.replace(/\r/g, "").split("\n");
+    for (let lineInBlock = 0; lineInBlock < lines.length; lineInBlock++) {
+      appendScreenRows(rows, {
+        blockId: block.id,
+        lineInBlock,
+        text: lines[lineInBlock] ?? "",
+        width,
+        noSelect
+      });
+    }
+    if (body.trim().length > 0) appendScreenRows(rows, { text: "", width, noSelect: true });
+  }
+  if (rows.length > 0 && rows.at(-1)?.text === "") rows.pop();
+  return { rows, width };
+}
+function buildTranscriptTextRows(blocks, width = Number.POSITIVE_INFINITY) {
+  return buildTranscriptScreenBuffer(blocks, width).rows;
+}
+function parseSgrMouseEvent(input) {
+  return parseTerminalSelectionMouseEvent(input);
+}
+function isSgrMouseInput(input) {
+  return isTerminalSelectionMouseInput(input);
+}
+function isSelectionStale(state, now) {
+  return isTerminalSelectionStale(state, now);
+}
+function reduceTranscriptSelection(input) {
+  return reduceTerminalSelection(input);
+}
+function selectionContainsRow(selection, rowIndex) {
+  return terminalSelectionContainsRow(selection, rowIndex);
+}
+function selectionLineIndexesForBlock(selection, rows, blockId) {
+  return terminalSelectionLineIndexesForBlock(selection, rows, blockId);
+}
+function selectionLineRangesForBlock(selection, rows, blockId) {
+  return terminalSelectionLineRangesForBlock(selection, rows, blockId).map(toProductBlockSelectionRange);
+}
+function selectedTextFromRows(rows, anchor, focus) {
+  return terminalSelectedTextFromRows(rows, anchor, focus);
+}
+function toProductBlockSelectionRange(range) {
+  return {
+    lineIndex: range.lineIndex,
+    startColumn: range.startColumn,
+    endColumn: range.endColumn
+  };
+}
+function screenTextForBlock(block) {
+  if (block.messageKind === "user_text") return block.fullText ?? block.title ?? "";
+  return block.fullText ?? block.summary ?? block.title ?? "";
+}
+function isNoSelectBlock(block) {
+  if (block.messageKind === "command_transcript" || block.messageKind === "status") return true;
+  if (block.kind === "home" || block.kind === "setup" || block.kind === "permission") return true;
+  return false;
+}
+function appendScreenRows(rows, input) {
+  const wrapWidth = Number.isFinite(input.width) ? Math.max(1, Math.floor(input.width)) : Infinity;
+  const sourceCells = cellsFromText(input.text, input.noSelect === true);
+  if (sourceCells.length === 0) {
+    rows.push({
+      index: rows.length,
+      blockId: input.blockId,
+      lineInBlock: input.lineInBlock,
+      text: "",
+      cells: [],
+      noSelect: input.noSelect
+    });
+    return;
+  }
+  let current = [];
+  let currentWidth = 0;
+  let sourceColumnStart = 0;
+  let softWrapped = false;
+  for (const cell of sourceCells) {
+    const nextWidth = Math.max(1, cell.width);
+    if (current.length > 0 && currentWidth + nextWidth > wrapWidth) {
+      rows.push(createScreenRow(rows.length, input, current, softWrapped, sourceColumnStart));
+      sourceColumnStart += current.length;
+      current = [];
+      currentWidth = 0;
+      softWrapped = true;
+    }
+    current.push(cell);
+    currentWidth += nextWidth;
+  }
+  rows.push(createScreenRow(rows.length, input, current, softWrapped, sourceColumnStart));
+}
+function createScreenRow(index, input, cells, softWrapped, sourceColumnStart) {
+  return {
+    index,
+    blockId: input.blockId,
+    lineInBlock: input.lineInBlock,
+    text: cells.map((cell) => cell.selectableText).join(""),
+    cells,
+    sourceColumnStart,
+    softWrapped,
+    noSelect: input.noSelect
+  };
+}
+function cellsFromText(text, noSelect) {
+  const cells = [];
+  for (const char of Array.from(text)) {
+    const width = Math.max(1, charWidth(char));
+    cells.push({ char, selectableText: noSelect ? "" : char, width, noSelect });
+    for (let index = 1; index < width; index++) {
+      cells.push({ char: "", selectableText: "", width: 0, noSelect: true });
+    }
+  }
+  return cells;
+}
+
+export {
+  buildTranscriptScreenBuffer,
+  buildTranscriptTextRows,
+  parseSgrMouseEvent,
+  isSgrMouseInput,
+  isSelectionStale,
+  reduceTranscriptSelection,
+  selectionContainsRow,
+  selectionLineIndexesForBlock,
+  selectionLineRangesForBlock,
+  selectedTextFromRows
+};

package/dist/chunk-NMNOAFFT.js

@@ -0,0 +1,167 @@
+// src/model-setup-runtime.ts
+import { validateProviderEnvSetup } from "@linghun/config";
+function getNextModelSetupStep(values) {
+  if (!values.baseUrl) return "baseUrl";
+  if (!values.apiKey) return "apiKey";
+  if (!values.model) return "model";
+  if (!values.reasoningLevel) return "reasoning";
+  return "confirm";
+}
+function parseModelSetupPrefill(text) {
+  const prefill = {};
+  const url = text.match(/https?:\/\/[^\s，,]+/iu)?.[0];
+  if (url) prefill.baseUrl = url;
+  const model = text.match(/(?:^|[\s，,;；])model(?:\s*[=:：]\s*|\s+)([^\s，,;；]+)/iu)?.[1] ?? text.match(/(?:^|[\s，,;；])模型(?:\s*[=:：]\s*|\s+)([^\s，,;；]+)/iu)?.[1];
+  if (model) prefill.model = model;
+  const reasoning = text.match(
+    /(?:reasoning|推理等级|推理)\s*[=:：]?\s*(Low|Medium|High|低|中|高)/iu
+  )?.[1];
+  if (reasoning) prefill.reasoningLevel = normalizeModelSetupReasoningLevel(reasoning);
+  const key = text.match(/(?:api\s*key|apikey|key|密钥)\s*[=:：]?\s*([^\s，,;；]+)/iu)?.[1] ?? text.match(/\b(sk-[A-Za-z0-9._-]{8,})\b/u)?.[1];
+  if (key) prefill.apiKey = key;
+  return prefill;
+}
+function normalizeModelSetupReasoningLevel(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "low" || normalized === "\u4F4E") return "Low";
+  if (normalized === "high" || normalized === "\u9AD8") return "High";
+  return "Medium";
+}
+function looksLikeModelSetupInput(text) {
+  const prefill = parseModelSetupPrefill(text);
+  if (/正常|状态|doctor|检查|诊断|怎么样|是否|吗|\?|？/iu.test(text)) {
+    return Object.keys(prefill).length > 0;
+  }
+  return /配置.*(?:模型|api\s*key|key|provider|供应商)|设置.*(?:模型|api\s*key|key|provider|供应商)|我要配置模型|configure\s+(?:model|provider|api\s*key)|setup\s+(?:model|provider)|model\s+setup|api\s*key|apikey/iu.test(
+    text
+  ) || Object.keys(prefill).length > 0;
+}
+function applyModelSetupValues(setup, values) {
+  const next = { ...setup.values, ...values };
+  validateModelSetupPartial(next);
+  setup.values = next;
+}
+function validateModelSetupPartial(values) {
+  if (values.baseUrl !== void 0) {
+    validateProviderEnvSetup({
+      baseUrl: values.baseUrl,
+      apiKey: "temporary-validation-key",
+      model: "temporary-model",
+      reasoningLevel: "Medium"
+    });
+  }
+  if (values.apiKey !== void 0) {
+    validateProviderEnvSetup({
+      baseUrl: "https://example.com/v1",
+      apiKey: values.apiKey,
+      model: "temporary-model",
+      reasoningLevel: "Medium"
+    });
+  }
+  if (values.model !== void 0 || values.reasoningLevel !== void 0) {
+    validateProviderEnvSetup({
+      baseUrl: "https://example.com/v1",
+      apiKey: "temporary-validation-key",
+      model: values.model ?? "temporary-model",
+      reasoningLevel: values.reasoningLevel ?? "Medium",
+      endpointProfile: values.endpointProfile,
+      includeUsage: values.includeUsage,
+      auxModel: values.auxModel
+    });
+  }
+}
+function getModelSetupPromptMessage(setup, language) {
+  const keyByStep = {
+    baseUrl: "baseUrlPrompt",
+    apiKey: "apiKeyPrompt",
+    model: "modelPrompt",
+    reasoning: "reasoningPrompt",
+    auxModel: "auxModelPrompt",
+    confirm: "confirmPrompt"
+  };
+  return formatModelSetupMessage(keyByStep[setup.step], language, setup);
+}
+function formatModelSetupMessage(key, language, setup) {
+  const english = language === "en-US";
+  const messagesByKey = {
+    intro: english ? [
+      "Model setup wizard",
+      "- One-time setup for this computer; other repositories will reuse the same user provider.env.",
+      "- API key is saved in the private user provider.env, never in project .linghun/settings.json.",
+      `- Save location: ${setup.providerEnvPath}`,
+      setup.createdTemplate ? "- A commented template was created for manual edits later." : ""
+    ].filter(Boolean).join("\n") : [
+      "\u6A21\u578B\u914D\u7F6E\u5411\u5BFC",
+      "- \u8FD9\u662F\u672C\u673A\u4E00\u6B21\u914D\u7F6E\uFF1B\u914D\u7F6E\u540E\u5176\u4ED6\u4ED3\u5E93\u4F1A\u9ED8\u8BA4\u590D\u7528\u540C\u4E00\u4E2A\u7528\u6237 provider.env\u3002",
+      "- API key \u4F1A\u5199\u5165\u672C\u673A\u7528\u6237\u79C1\u5BC6 provider.env\uFF0C\u4E0D\u4F1A\u5199\u5165\u9879\u76EE .linghun/settings.json\u3002",
+      `- \u5199\u5165\u4F4D\u7F6E\uFF1A${setup.providerEnvPath}`,
+      setup.createdTemplate ? "- \u5DF2\u521B\u5EFA\u5E26\u6CE8\u91CA\u6A21\u677F\uFF0C\u540E\u7EED\u53EF\u76F4\u63A5\u7F16\u8F91\u8FD9\u4E2A\u6587\u4EF6\u3002" : ""
+    ].filter(Boolean).join("\n"),
+    baseUrlPrompt: english ? "API base URL is missing. Enter the root API URL, for example https://example.com/v1." : "\u7F3A\u5C11 API \u5730\u5740\u3002\u8BF7\u8F93\u5165 root API \u5730\u5740\uFF0C\u4F8B\u5982 https://example.com/v1\u3002",
+    apiKeyPrompt: english ? "API key is missing. Enter it now; input is masked when possible and the raw value will not be printed." : "\u7F3A\u5C11 API key\u3002\u8BF7\u8F93\u5165 API key\uFF08\u8F93\u5165\u65F6\u4F1A\u5C3D\u91CF mask\uFF0C\u4E0D\u663E\u793A\u539F\u503C\uFF09\u3002",
+    modelPrompt: english ? "Model name is missing. Enter the model name." : "\u7F3A\u5C11\u6A21\u578B\u540D\u79F0\u3002\u8BF7\u8F93\u5165\u6A21\u578B\u540D\u79F0\u3002",
+    reasoningPrompt: english ? "Reasoning level: Low / Medium / High. Press Enter to use Medium." : "\u63A8\u7406\u7B49\u7EA7\u53EF\u9009 Low / Medium / High\uFF0C\u9ED8\u8BA4 Medium\u3002\u76F4\u63A5\u56DE\u8F66\u4F7F\u7528 Medium\u3002",
+    auxModelPrompt: english ? "Auxiliary model is optional. Press Enter to let helper roles follow the main model." : "\u8F85\u52A9\u6A21\u578B\u53EF\u9009\uFF0C\u76F4\u63A5\u56DE\u8F66\u5219\u8DDF\u968F\u4E3B\u6A21\u578B\u3002",
+    confirmPrompt: english ? "Type yes/save to save, no to cancel, or details for safety notes." : "\u8BF7\u8F93\u5165 yes \u4FDD\u5B58\uFF0Cno \u53D6\u6D88\uFF0Cdetails \u67E5\u770B\u5B89\u5168\u8BF4\u660E\u3002",
+    cancelled: english ? "Model setup cancelled. No key was saved." : "\u5DF2\u53D6\u6D88\u6A21\u578B\u914D\u7F6E\uFF0C\u672A\u4FDD\u5B58\u4EFB\u4F55 key\u3002",
+    details: english ? [
+      "Safety notes",
+      `- provider.env path: ${setup.providerEnvPath}`,
+      "- Shell env has highest priority, then user provider.env, then existing settings/default.",
+      "- The raw key is not displayed and is not written to project settings, docs, reports, or logs.",
+      "- Role routes can stay unset; they follow the main model by default."
+    ].join("\n") : [
+      "\u5B89\u5168\u8BF4\u660E",
+      `- provider.env \u8DEF\u5F84\uFF1A${setup.providerEnvPath}`,
+      "- shell env \u53D8\u91CF\u4F18\u5148\u7EA7\u6700\u9AD8\uFF0C\u5176\u6B21\u7528\u6237 provider.env\uFF0C\u518D\u8D70\u73B0\u6709 settings/default\u3002",
+      "- \u771F\u5B9E key \u4E0D\u4F1A\u663E\u793A\u3001\u4E0D\u5199\u5165\u9879\u76EE settings\u3001\u4E0D\u5199\u5165\u6587\u6863\u6216\u62A5\u544A\u3002",
+      "- \u4E0D\u8BBE\u7F6E\u89D2\u8272\u8DEF\u7531\u4E5F\u53EF\u4EE5\u6B63\u5E38\u4F7F\u7528\uFF0C\u89D2\u8272\u9ED8\u8BA4\u8DDF\u968F\u4E3B\u6A21\u578B\u3002"
+    ].join("\n")
+  };
+  return messagesByKey[key];
+}
+function formatModelSetupFallbackError(language) {
+  return language === "en-US" ? "Validation failed. Complete the missing fields and try again." : "\u68C0\u67E5\u672A\u901A\u8FC7\uFF0C\u8BF7\u8865\u5168\u7F3A\u5931\u9879\u3002";
+}
+function formatModelSetupSummary(setup, language) {
+  const english = language === "en-US";
+  return [
+    english ? "Model setup summary" : "\u6A21\u578B\u914D\u7F6E\u6458\u8981",
+    "- provider openai-compatible",
+    `- base URL ${setup.values.baseUrl ? "present" : "missing"}`,
+    `- api key ${setup.values.apiKey ? "present" : "missing"}`,
+    `- model ${setup.values.model ?? "missing"}`,
+    `- reasoning level ${setup.values.reasoningLevel ?? "Medium"}`,
+    `${english ? "- save location" : "- \u5199\u5165\u4F4D\u7F6E"}\uFF1A${setup.providerEnvPath}`,
+    english ? "Type yes/save to save. The raw API key is not shown." : "\u8BF7\u8F93\u5165 yes/\u4FDD\u5B58 \u786E\u8BA4\u540E\u624D\u4F1A\u5199\u5165\uFF1B\u6458\u8981\u4E0D\u4F1A\u663E\u793A key \u539F\u503C\u3002"
+  ].join("\n");
+}
+function formatModelSetupSaved(path, language) {
+  return language === "en-US" ? [
+    "Saved. Restart Linghun to use the new user provider config.",
+    `- User provider.env: ${path}`,
+    "- This is user-scoped and will be reused by other repositories by default.",
+    "- To change API URL, key, or model later, run /model setup or edit provider.env.",
+    "- Check configuration with /model doctor."
+  ].join("\n") : [
+    "\u5DF2\u4FDD\u5B58\uFF0C\u8BF7\u91CD\u542F Linghun \u540E\u4F7F\u7528\u65B0\u7684\u7528\u6237\u7EA7 provider \u914D\u7F6E\u3002",
+    `- \u7528\u6237 provider.env\uFF1A${path}`,
+    "- \u8FD9\u662F\u7528\u6237\u7EA7\u914D\u7F6E\uFF0C\u4E4B\u540E\u8FDB\u5165\u5176\u4ED6\u4ED3\u5E93\u4F1A\u9ED8\u8BA4\u590D\u7528\u3002",
+    "- \u540E\u7EED\u60F3\u66F4\u6362 API \u5730\u5740\u3001key \u6216\u6A21\u578B\u540D\u79F0\uFF0C\u53EF\u8FD0\u884C /model setup\uFF0C\u6216\u7F16\u8F91\u4E0A\u8FF0 provider.env\u3002",
+    "- \u68C0\u67E5\u914D\u7F6E\u53EF\u8FD0\u884C /model doctor\u3002"
+  ].join("\n");
+}
+
+export {
+  getNextModelSetupStep,
+  parseModelSetupPrefill,
+  normalizeModelSetupReasoningLevel,
+  looksLikeModelSetupInput,
+  applyModelSetupValues,
+  validateModelSetupPartial,
+  getModelSetupPromptMessage,
+  formatModelSetupMessage,
+  formatModelSetupFallbackError,
+  formatModelSetupSummary,
+  formatModelSetupSaved
+};

package/dist/chunk-NSIKYD3X.js

@@ -0,0 +1,74 @@
+// src/shell/models/permission-explanation.ts
+function sanitizePermissionReason(reason) {
+  if (!reason) return "";
+  return reason.replace(
+    /命中\s*(deny|ask|allow)\s*规则[：:].*/gu,
+    (_match, effect) => effect === "deny" ? "\u547D\u4E2D\u62D2\u7EDD\u89C4\u5219\u3002" : effect === "ask" ? "\u547D\u4E2D\u9700\u786E\u8BA4\u89C4\u5219\u3002" : "\u547D\u4E2D\u5141\u8BB8\u89C4\u5219\u3002"
+  ).replace(
+    /Hit\s+(deny|ask|allow)\s+rule:.*/giu,
+    (_match, effect) => effect.toLowerCase() === "deny" ? "Hit deny rule." : effect.toLowerCase() === "ask" ? "Hit ask rule." : "Hit allow rule."
+  );
+}
+function explainSemantic(semantic, language) {
+  const isEn = language === "en-US";
+  switch (semantic) {
+    case "readonly":
+      return isEn ? "Read-only operation." : "\u53EA\u8BFB\u64CD\u4F5C\u3002";
+    case "mutating":
+      return isEn ? "May change workspace files." : "\u53EF\u80FD\u4FEE\u6539\u5DE5\u4F5C\u533A\u6587\u4EF6\u3002";
+    case "destructive":
+      return isEn ? "Destructive command (delete / overwrite / shutdown)." : "\u7834\u574F\u6027\u547D\u4EE4\uFF08\u5220\u9664 / \u8986\u76D6 / \u5173\u505C\uFF09\u3002";
+    case "network":
+      return isEn ? "Performs network calls." : "\u4F1A\u53D1\u8D77\u7F51\u7EDC\u8BF7\u6C42\u3002";
+    case "install":
+      return isEn ? "Installs or updates dependencies." : "\u5B89\u88C5\u6216\u66F4\u65B0\u4F9D\u8D56\u3002";
+    case "secret_read":
+      return isEn ? "Reads sensitive files." : "\u8BFB\u53D6\u654F\u611F\u6587\u4EF6\u3002";
+    case "outside_workspace":
+      return isEn ? "Touches paths outside the workspace." : "\u6D89\u53CA\u5DE5\u4F5C\u533A\u5916\u7684\u8DEF\u5F84\u3002";
+    default:
+      return isEn ? "Action requires confirmation." : "\u9700\u8981\u786E\u8BA4\u540E\u518D\u6267\u884C\u3002";
+  }
+}
+function explainPathSafety(pathSafety, language) {
+  const isEn = language === "en-US";
+  switch (pathSafety) {
+    case "workspace_safe":
+      return isEn ? "Path is workspace-safe." : "\u8DEF\u5F84\u5728\u5DE5\u4F5C\u533A\u4E14\u5B89\u5168\u3002";
+    case "workspace_write":
+      return isEn ? "Writes inside the workspace." : "\u5728\u5DE5\u4F5C\u533A\u5185\u5199\u5165\u3002";
+    case "outside_workspace":
+      return isEn ? "Touches paths outside the workspace." : "\u6D89\u53CA\u5DE5\u4F5C\u533A\u5916\u8DEF\u5F84\u3002";
+    case "sensitive_path":
+      return isEn ? "Touches a sensitive path." : "\u6D89\u53CA\u654F\u611F\u8DEF\u5F84\u3002";
+    default:
+      return isEn ? "Path classification unknown." : "\u8DEF\u5F84\u5206\u7C7B\u672A\u77E5\u3002";
+  }
+}
+function explainHowToUpdate(language) {
+  return language === "en-US" ? "Use /permissions to update rules." : "\u53EF\u7528 /permissions \u67E5\u770B\u4E0E\u8C03\u6574\u89C4\u5219\u3002";
+}
+function explainPolicyVerdict(verdict, language) {
+  const lines = [];
+  if (verdict.semantic) lines.push(explainSemantic(verdict.semantic, language));
+  if (verdict.pathSafety) lines.push(explainPathSafety(verdict.pathSafety, language));
+  if (verdict.redactedSummary && verdict.redactedSummary.trim().length > 0) {
+    lines.push(verdict.redactedSummary.trim());
+  }
+  if (verdict.reason) {
+    const safe = sanitizePermissionReason(verdict.reason).trim();
+    if (safe.length > 0 && !lines.some((existing) => existing === safe)) {
+      lines.push(safe);
+    }
+  }
+  lines.push(explainHowToUpdate(language));
+  return lines;
+}
+
+export {
+  sanitizePermissionReason,
+  explainSemantic,
+  explainPathSafety,
+  explainHowToUpdate,
+  explainPolicyVerdict
+};

package/dist/chunk-O7EFPSMC.js

@@ -0,0 +1,60 @@
+// src/memory-eviction-runtime.ts
+var AGENT_KEEP_RECENT = 5;
+var AGENT_FULL_REPORT_MAX_CHARS = 400;
+var BLOCK_KEEP_RECENT = 60;
+var BLOCK_FULLTEXT_EVICT_CHARS = 200;
+var TOOL_BUDGET_STATE_MAX_ENTRIES = 200;
+function evictCompletedAgents(context) {
+  const agents = context.agents;
+  if (agents.length <= AGENT_KEEP_RECENT) return;
+  const terminal = (a) => a.status === "completed" || a.status === "failed" || a.status === "cancelled";
+  let evictCount = 0;
+  for (let i = agents.length - 1; i >= 0; i--) {
+    const agent = agents[i];
+    if (!agent || !terminal(agent)) continue;
+    evictCount++;
+    if (evictCount <= AGENT_KEEP_RECENT) continue;
+    if (agent.lastResultFullReport && agent.lastResultFullReport.length > AGENT_FULL_REPORT_MAX_CHARS) {
+      agent.lastResultFullReport = agent.lastResultFullReport.slice(0, AGENT_FULL_REPORT_MAX_CHARS) + "\u2026[evicted]";
+    }
+    agent.mailbox = [];
+    agent.contextSummary = "";
+  }
+}
+function evictCommittedBlocks(blocks) {
+  if (blocks.length <= BLOCK_KEEP_RECENT) return;
+  const evictBefore = blocks.length - BLOCK_KEEP_RECENT;
+  for (let i = 0; i < evictBefore; i++) {
+    const block = blocks[i];
+    if (!block) continue;
+    if (block.fullText && block.fullText.length > BLOCK_FULLTEXT_EVICT_CHARS) {
+      block.fullText = block.fullText.slice(0, BLOCK_FULLTEXT_EVICT_CHARS) + "\u2026[evicted]";
+    }
+  }
+}
+function pruneToolResultBudgetState(context) {
+  const state = context.toolResultBudgetState;
+  if (!state) return;
+  if (state.seenIds.size <= TOOL_BUDGET_STATE_MAX_ENTRIES) return;
+  const idsArray = [...state.seenIds];
+  const removeCount = idsArray.length - TOOL_BUDGET_STATE_MAX_ENTRIES;
+  for (let i = 0; i < removeCount; i++) {
+    const id = idsArray[i];
+    if (id) {
+      state.seenIds.delete(id);
+      state.replacements.delete(id);
+    }
+  }
+}
+function runMemoryEviction(context, blocks) {
+  evictCompletedAgents(context);
+  evictCommittedBlocks(blocks);
+  pruneToolResultBudgetState(context);
+}
+
+export {
+  evictCompletedAgents,
+  evictCommittedBlocks,
+  pruneToolResultBudgetState,
+  runMemoryEviction
+};

package/dist/chunk-O7S3HYE6.js

@@ -0,0 +1,210 @@
+import {
+  LINGHUN_DEFAULT_TOOL_RESULT_CHARS,
+  LINGHUN_MAX_TOOL_RESULTS_PER_MESSAGE_CHARS,
+  LINGHUN_MAX_TOOL_RESULT_BYTES
+} from "./chunk-IWUIOLMF.js";
+
+// src/tool-result-budget.ts
+import { createHash, randomUUID } from "crypto";
+import { mkdir, writeFile } from "fs/promises";
+import { basename, join, relative } from "path";
+var TOOL_RESULTS_DIR = "tool-results";
+var TOOL_RESULT_PREVIEW_CHARS = 2e3;
+async function applyToolResultBudgetToMessages(messages, options) {
+  const candidates = collectToolResultCandidates(messages, options.state);
+  if (candidates.length === 0) return { messages, records: [] };
+  const cachedReplacements = /* @__PURE__ */ new Map();
+  const freshCandidates = [];
+  for (const candidate of candidates) {
+    const stateKey = options.state ? getCandidateStateKey(candidate, options.sessionId) : void 0;
+    const existing = stateKey ? options.state?.replacements.get(stateKey) : void 0;
+    if (existing) {
+      cachedReplacements.set(candidate.toolUseId, existing.summary);
+      continue;
+    }
+    if (stateKey && options.state?.seenIds.has(stateKey)) {
+      continue;
+    }
+    freshCandidates.push(candidate);
+  }
+  const selected = /* @__PURE__ */ new Map();
+  for (const candidate of freshCandidates) {
+    if (candidate.chars > LINGHUN_DEFAULT_TOOL_RESULT_CHARS || candidate.bytes > LINGHUN_MAX_TOOL_RESULT_BYTES) {
+      selected.set(candidate.toolUseId, { ...candidate, reason: "single_result" });
+    }
+  }
+  const freshIds = new Set(freshCandidates.map((candidate) => candidate.toolUseId));
+  for (const group of groupCandidatesByAssistantToolUse(messages, candidates)) {
+    const visibleSize = group.reduce((sum, candidate) => {
+      const stateKey = options.state ? getCandidateStateKey(candidate, options.sessionId) : void 0;
+      const replacement = stateKey ? options.state?.replacements.get(stateKey) : void 0;
+      return sum + (replacement?.summary.length ?? candidate.chars);
+    }, 0);
+    if (visibleSize <= LINGHUN_MAX_TOOL_RESULTS_PER_MESSAGE_CHARS) continue;
+    let remaining = visibleSize;
+    for (const candidate of [...group].filter((item) => freshIds.has(item.toolUseId)).sort((a, b) => b.chars - a.chars)) {
+      if (remaining <= LINGHUN_MAX_TOOL_RESULTS_PER_MESSAGE_CHARS) break;
+      if (!selected.has(candidate.toolUseId)) {
+        selected.set(candidate.toolUseId, { ...candidate, reason: "aggregate_message" });
+      }
+      remaining -= candidate.chars;
+    }
+  }
+  if (selected.size === 0) {
+    for (const candidate of freshCandidates) {
+      options.state?.seenIds.add(getCandidateStateKey(candidate, options.sessionId));
+    }
+    return cachedReplacements.size === 0 ? { messages, records: [] } : { messages: replaceToolResults(messages, cachedReplacements), records: [] };
+  }
+  const replacements = new Map(cachedReplacements);
+  const records = [];
+  for (const candidate of selected.values()) {
+    const artifact = await writeToolResultArtifact(candidate, options);
+    const replacement = buildToolResultBudgetSummary(artifact, candidate.reason);
+    replacements.set(candidate.toolUseId, replacement);
+    const record = {
+      toolUseId: candidate.toolUseId,
+      originalChars: candidate.content.length,
+      replacementChars: replacement.length,
+      artifact,
+      reason: candidate.reason
+    };
+    records.push(record);
+    const stateKey = getCandidateStateKey(candidate, options.sessionId);
+    options.state?.replacements.set(stateKey, {
+      summary: replacement,
+      record,
+      fingerprint: stateKey
+    });
+  }
+  for (const candidate of freshCandidates) {
+    options.state?.seenIds.add(getCandidateStateKey(candidate, options.sessionId));
+  }
+  return {
+    messages: replaceToolResults(messages, replacements),
+    records
+  };
+}
+function collectToolResultCandidates(messages, _state) {
+  const candidates = [];
+  messages.forEach((message, messageIndex) => {
+    if (message.role !== "tool") return;
+    if (isBudgetSummary(message.content)) return;
+    const bytes = Buffer.byteLength(message.content, "utf8");
+    candidates.push({
+      messageIndex,
+      toolUseId: message.tool_call_id,
+      content: message.content,
+      chars: message.content.length,
+      bytes
+    });
+  });
+  return candidates;
+}
+function getCandidateStateKey(candidate, sessionId) {
+  candidate.stateKey ??= [
+    sessionId,
+    candidate.toolUseId,
+    candidate.chars,
+    candidate.bytes,
+    createHash("sha256").update(candidate.content).digest("hex")
+  ].join("\0");
+  return candidate.stateKey;
+}
+function groupCandidatesByAssistantToolUse(messages, candidates) {
+  const byMessageIndex = new Map(
+    candidates.map((candidate) => [candidate.messageIndex, candidate])
+  );
+  const groups = [];
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+    if (message.role !== "assistant" || !message.toolCalls?.length) continue;
+    const ids = new Set(message.toolCalls.map((toolCall) => toolCall.id));
+    const group = [];
+    for (let cursor = index + 1; cursor < messages.length; cursor += 1) {
+      const next = messages[cursor];
+      if (next.role === "assistant") break;
+      if (next.role !== "tool") continue;
+      if (!ids.has(next.tool_call_id)) continue;
+      const candidate = byMessageIndex.get(cursor);
+      if (candidate) group.push(candidate);
+    }
+    if (group.length > 0) groups.push(group);
+  }
+  return groups;
+}
+async function writeToolResultArtifact(candidate, options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const dir = join(options.projectPath, ".linghun", "session", TOOL_RESULTS_DIR, options.sessionId);
+  await mkdir(dir, { recursive: true });
+  const sha256 = createHash("sha256").update(candidate.content).digest("hex");
+  const safeId = sanitizeId(candidate.toolUseId) || randomUUID();
+  const artifactId = `${safeId}-${sha256.slice(0, 12)}`;
+  const path = join(dir, `${artifactId}.txt`);
+  await writeFile(path, candidate.content, { encoding: "utf8", flag: "wx" }).catch(
+    async (error) => {
+      if (error.code !== "EEXIST") throw error;
+    }
+  );
+  const relativePath = relative(options.projectPath, path).replace(/\\/g, "/");
+  const preview = candidate.content.slice(0, TOOL_RESULT_PREVIEW_CHARS);
+  return {
+    id: artifactId,
+    toolUseId: candidate.toolUseId,
+    path,
+    relativePath,
+    bytes: candidate.bytes,
+    chars: candidate.content.length,
+    sha256,
+    previewChars: preview.length,
+    preview,
+    hasMore: preview.length < candidate.content.length
+  };
+}
+function buildToolResultBudgetSummary(artifact, reason) {
+  return [
+    "<persisted-tool-result>",
+    `reason: ${reason}`,
+    `toolUseId: ${artifact.toolUseId}`,
+    `artifactId: ${artifact.id}`,
+    `artifactPath: ${artifact.relativePath}`,
+    `originalChars: ${artifact.chars}`,
+    `originalBytes: ${artifact.bytes}`,
+    `sha256: ${artifact.sha256}`,
+    `previewChars: ${artifact.previewChars}`,
+    "read: use /details output with the evidence id or read the artifact path if you need the full tool output.",
+    "preview:",
+    artifact.preview,
+    artifact.hasMore ? "..." : "",
+    "</persisted-tool-result>"
+  ].filter((line) => line !== "").join("\n");
+}
+function replaceToolResults(messages, replacements) {
+  let changed = false;
+  const next = messages.map((message) => {
+    if (message.role !== "tool") return message;
+    const replacement = replacements.get(message.tool_call_id);
+    if (!replacement || replacement === message.content) return message;
+    changed = true;
+    return { ...message, content: replacement };
+  });
+  return changed ? next : messages;
+}
+function sanitizeId(value) {
+  return value.replace(/[^A-Za-z0-9_-]+/gu, "-").slice(0, 64);
+}
+function isBudgetSummary(content) {
+  return content.startsWith("<persisted-tool-result>");
+}
+function formatToolResultBudgetEvidenceSummary(record) {
+  return `tool_result persisted artifact=${record.artifact.relativePath} toolUseId=${record.toolUseId} chars=${record.originalChars} bytes=${record.artifact.bytes} sha256=${record.artifact.sha256}`;
+}
+function formatToolResultBudgetSystemEvent(record) {
+  return `tool_result_budget_persisted evidence artifact=${basename(record.artifact.path)} toolUseId=${record.toolUseId} reason=${record.reason} chars=${record.originalChars} sha256=${record.artifact.sha256}`;
+}
+
+export {
+  applyToolResultBudgetToMessages,
+  formatToolResultBudgetEvidenceSummary,
+  formatToolResultBudgetSystemEvent
+};