@linghun/tui 0.1.1 → 0.1.3

package/dist/{chunk-LIPZJNXS.js → chunk-CQCJGMXG.js}

@@ -1,21 +1,21 @@
 import {
   ensureSession,
   showCommandPanel
-} from "./chunk-AZU7HXIT.js";
+} from "./chunk-6JPUBF7B.js";
 import {
   decidePermission
-} from "./chunk-DDXS2RDZ.js";
+} from "./chunk-PHPEPZAA.js";
 import {
   appendSystemEvent,
   budgetToolResultTranscriptContent,
   createEvidenceRecord,
   rememberEvidence
-} from "./chunk-L2GU3PWU.js";
+} from "./chunk-DEIYY6NI.js";
 import {
   sanitizeDiagnosticText,
   truncateDisplay,
   writeLine
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 
 // src/capability-runtime.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-L2GU3PWU.js → chunk-DEIYY6NI.js}

@@ -6,26 +6,29 @@ import {
   formatToolResultBudgetEvidenceSummary,
   formatToolResultBudgetSystemEvent
 } from "./chunk-O7S3HYE6.js";
+import {
+  formatToolDiagnosticsSummary
+} from "./chunk-OI5TZ37D.js";
 import {
   LINGHUN_DEFAULT_TOOL_RESULT_CHARS,
   LINGHUN_MAX_TOOL_RESULT_BYTES
 } from "./chunk-IWUIOLMF.js";
 import {
   writeHandoffPacket
-} from "./chunk-MLUIOBKL.js";
+} from "./chunk-7ZMDQZ22.js";
 import {
   deriveToolSupportsClaims
-} from "./chunk-K56D3X7S.js";
+} from "./chunk-NWZ44SFI.js";
 import {
   mergeFailureRecord,
   writeFailureRecord
-} from "./chunk-GDQQNPBP.js";
+} from "./chunk-6GXIGN5W.js";
 import {
   classifyProviderFailure
 } from "./chunk-OZMX3E35.js";
 import {
   truncateDisplay
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 import {
   summarizeArchitectureCard
 } from "./chunk-MVONSJEN.js";
@@ -37,6 +40,7 @@ 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;
+var RECENT_DIAGNOSTICS_LIMIT = 20;
 function createEvidenceRecord(kind, summary, source, supportsClaims) {
   return {
     id: randomUUID(),
@@ -215,20 +219,25 @@ async function recordArchitectureRuntimeCard(context, sessionId, card) {
   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;
+  const kind = name === "Read" || name === "ReadSnippets" || name === "SourcePack" ? "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 readOnlyEvidence = name === "Read" || name === "ReadSnippets" || name === "SourcePack" || name === "Grep" || name === "Glob";
+  const supportsClaims = [
+    ...deriveToolSupportsClaims(name, input, output),
+    ...readOnlyEvidence ? ["readonly_low_noise_evidence"] : []
+  ];
   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"] : []
-    ]
+    supportsClaims
   );
+  const semanticProbe = supportsClaims.includes("bash_exit_0") ? compactSemanticProbeEvidence(context, output, input) : void 0;
+  if (semanticProbe) {
+    evidence.data = { ...typeof evidence.data === "object" && evidence.data ? evidence.data : {}, semanticProbe };
+  }
   rememberEvidence(context, evidence);
   await context.store.appendEvent(sessionId, {
     type: "evidence_record",
@@ -237,11 +246,44 @@ async function recordToolEvidence(context, sessionId, name, output, input) {
   return evidence;
 }
 function formatReadOnlyToolEvidenceSummary(name, output, input) {
-  const target = readToolEvidenceTarget(input);
+  const target = name === "SourcePack" ? sourcePackEvidenceTarget(input, output) : name === "ReadSnippets" ? readSnippetsEvidenceTarget(input) : readToolEvidenceTarget(input);
   const artifact = output.fullOutputPath ? "artifact=yes" : "artifact=no";
   const bytes = output.text.length;
   return `${name}: ${target}; output_chars=${bytes}; ${artifact}`;
 }
+function sourcePackEvidenceTarget(input, output) {
+  const query = readStringField(input, "query");
+  const paths = extractOutputCandidatePaths(output.data);
+  const pathText = paths.length > 0 ? `; paths=${truncateDisplay(paths.slice(0, 4).join(","), 120)}` : "";
+  return `query=${truncateDisplay((query ?? "unspecified").replace(/\s+/g, " "), 90)}${pathText}`;
+}
+function readSnippetsEvidenceTarget(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return "ranges=unspecified";
+  const ranges = input.ranges;
+  if (!Array.isArray(ranges)) return "ranges=unspecified";
+  const paths = ranges.map(
+    (item) => item && typeof item === "object" && typeof item.path === "string" ? item.path : void 0
+  ).filter((item) => Boolean(item));
+  return paths.length > 0 ? `ranges=${truncateDisplay(paths.slice(0, 4).join(","), 120)}` : "ranges=unspecified";
+}
+function readStringField(input, key) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return void 0;
+  const value = input[key];
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function extractOutputCandidatePaths(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return [];
+  const record = data;
+  const candidatePaths = record.candidatePaths;
+  if (Array.isArray(candidatePaths)) {
+    return candidatePaths.filter((item) => typeof item === "string");
+  }
+  const snippets = record.snippets;
+  if (!Array.isArray(snippets)) return [];
+  return snippets.map(
+    (item) => item && typeof item === "object" && typeof item.path === "string" ? item.path : void 0
+  ).filter((item) => Boolean(item));
+}
 function readToolEvidenceTarget(input) {
   if (!input || typeof input !== "object" || Array.isArray(input)) return "target=unspecified";
   const record = input;
@@ -258,6 +300,15 @@ function readToolEvidenceTarget(input) {
       return `paths=${truncateDisplay(values.slice(0, 3).join(","), 90)}`;
     }
   }
+  const ranges = record.ranges;
+  if (Array.isArray(ranges)) {
+    const values = ranges.map(
+      (item) => item && typeof item === "object" && typeof item.path === "string" ? item.path : void 0
+    ).filter((item) => Boolean(item));
+    if (values.length > 0) {
+      return `ranges=${truncateDisplay(values.slice(0, 3).join(","), 90)}`;
+    }
+  }
   return "target=unspecified";
 }
 async function recordVerificationEvidence(context, sessionId, report) {
@@ -378,8 +429,12 @@ function createToolEndEvent(id, output) {
   };
 }
 function summarizeToolEndOutputForTranscript(output) {
+  const diagnostics = formatToolDiagnosticsSummary(output);
   const text = compactToolEndTextForTranscript(
-    output.summary || output.preview || output.text || "tool call completed",
+    appendCompactDiagnostics(
+      output.summary || output.preview || output.text || "tool call completed",
+      diagnostics
+    ),
     output.fullOutputPath
   );
   return {
@@ -389,9 +444,15 @@ function summarizeToolEndOutputForTranscript(output) {
     truncated: output.truncated,
     fullOutputPath: output.fullOutputPath,
     evidenceId: output.evidenceId,
-    changedFiles: output.changedFiles
+    changedFiles: output.changedFiles,
+    data: compactToolStructuredDataForTranscript(output.data)
   };
 }
+function appendCompactDiagnostics(text, diagnostics) {
+  if (!diagnostics || text.includes("Linghun diagnostics:")) return text;
+  return `${diagnostics}
+${text}`;
+}
 function compactToolEndTextForTranscript(text, fullOutputPath) {
   const bytes = Buffer.byteLength(text, "utf8");
   if (text.length <= TRANSCRIPT_TOOL_OUTPUT_MAX_CHARS && bytes <= TRANSCRIPT_TOOL_OUTPUT_MAX_CHARS) {
@@ -432,12 +493,69 @@ function compactToolOutputDataForTranscript(data) {
   return {
     truncated: true,
     originalChars: serialized.length,
-    preview: serialized.slice(0, TRANSCRIPT_TOOL_OUTPUT_PREVIEW_CHARS)
+    preview: serialized.slice(0, TRANSCRIPT_TOOL_OUTPUT_PREVIEW_CHARS),
+    ...compactToolStructuredDataForTranscript(data)
+  };
+}
+function compactToolStructuredDataForTranscript(data) {
+  const compact = {};
+  const diagnostics = compactDiagnosticsDataForTranscript(data);
+  const validationEvidence = compactValidationEvidenceDataForTranscript(data);
+  if (diagnostics) Object.assign(compact, diagnostics);
+  if (validationEvidence) Object.assign(compact, validationEvidence);
+  return Object.keys(compact).length > 0 ? compact : void 0;
+}
+function compactDiagnosticsDataForTranscript(data) {
+  const diagnostics = readDiagnosticsForTranscript(data);
+  if (!diagnostics) return void 0;
+  return { diagnostics };
+}
+function compactValidationEvidenceDataForTranscript(data) {
+  const validationEvidence = readValidationEvidenceForTranscript(data);
+  if (!validationEvidence) return void 0;
+  return { validationEvidence };
+}
+function readDiagnosticsForTranscript(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const diagnostics = data.diagnostics;
+  if (!Array.isArray(diagnostics) || diagnostics.length === 0) return void 0;
+  return diagnostics.slice(0, 5).map(compactDiagnosticForTranscript).filter((diagnostic) => Boolean(diagnostic));
+}
+function compactDiagnosticForTranscript(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const type = typeof record.type === "string" ? record.type : void 0;
+  const severity = typeof record.severity === "string" ? record.severity : void 0;
+  const evidence = typeof record.evidence === "string" ? truncateDisplay(record.evidence.replace(/\s+/g, " "), 160) : void 0;
+  if (!type || !evidence) return void 0;
+  return {
+    type,
+    severity,
+    evidence,
+    ...readCompactDiagnosticTargetFields(record)
+  };
+}
+function readCompactDiagnosticTargetFields(record) {
+  const target = typeof record.target === "string" ? record.target : void 0;
+  const path = typeof record.path === "string" ? record.path : void 0;
+  const command = typeof record.command === "string" ? record.command : void 0;
+  const fallback = typeof record.fallback === "string" ? record.fallback : void 0;
+  const targetHost = typeof record.targetHost === "string" ? record.targetHost : void 0;
+  const targetPort = typeof record.targetPort === "number" ? record.targetPort : void 0;
+  return {
+    ...command ? { command } : {},
+    ...fallback ? { fallback } : {},
+    ...target ? { target } : {},
+    ...path ? { path } : {},
+    ...targetHost ? { targetHost } : {},
+    ...targetPort !== void 0 ? { targetPort } : {}
   };
 }
 function isToolOutputFailure(name, output) {
   if (name === "Bash") {
-    const exitCode = output.data?.exitCode;
+    const data = output.data;
+    if (data?.isError === false) return false;
+    const exitCode = data?.exitCode;
     return typeof exitCode === "number" && exitCode !== 0;
   }
   return false;
@@ -483,11 +601,14 @@ async function appendDeferredToolResultEvent(context, sessionId, toolUseId, disp
   });
 }
 async function appendToolResultEvent(context, sessionId, toolUseId, toolName, content, isError, evidenceId) {
+  rememberRecentDiagnostics(context, toolName, content, toolUseId, evidenceId);
+  rememberToolEvidenceData(context, evidenceId, content);
+  const contentWithDiagnostics = appendToolResultContentDiagnostics(content);
   const budgetedContent = await budgetToolResultTranscriptContent(
     context,
     sessionId,
     toolUseId,
-    content
+    contentWithDiagnostics
   );
   await context.store.appendEvent(sessionId, {
     type: "tool_result",
@@ -499,6 +620,193 @@ async function appendToolResultEvent(context, sessionId, toolUseId, toolName, co
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   });
 }
+function rememberToolEvidenceData(context, evidenceId, content) {
+  if (!evidenceId || !content || typeof content !== "object") return;
+  if (!Array.isArray(context.evidence)) return;
+  const output = content;
+  const compact = compactToolEvidenceData(output.data);
+  if (!compact) return;
+  const evidence = context.evidence.find((item) => item.id === evidenceId);
+  if (evidence) {
+    evidence.data = { ...typeof evidence.data === "object" && evidence.data ? evidence.data : {}, ...compact };
+  }
+}
+function compactToolEvidenceData(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const record = data;
+  const compact = {};
+  for (const key of ["service", "serviceHint", "artifactHint", "binaryHint", "binaryPreflight"]) {
+    if (record[key] !== void 0) compact[key] = record[key];
+  }
+  const validationEvidence = readValidationEvidenceForTranscript(data);
+  if (validationEvidence) compact.validationEvidence = validationEvidence;
+  return Object.keys(compact).length > 0 ? compact : void 0;
+}
+function compactSemanticProbeEvidence(context, output, input) {
+  const tokens = collectSemanticContractTokens(context);
+  if (tokens.length === 0) return void 0;
+  if (!looksLikeServiceProbeCommand(input)) return void 0;
+  const haystack = [output.text, output.summary, output.preview].filter((item) => typeof item === "string" && item.length > 0).join("\n").toLowerCase();
+  if (!haystack) return void 0;
+  const matched = tokens.filter((token) => haystack.includes(token.toLowerCase()));
+  const required = Math.min(2, tokens.length);
+  if (matched.length < required) return void 0;
+  return { tokens: matched.slice(0, 12) };
+}
+function looksLikeServiceProbeCommand(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return false;
+  const command = input.command;
+  if (typeof command !== "string") return false;
+  return /\b(?:curl|wget|http|httpie|python|python3|node|deno|ruby|perl|php)\b|(?:requests|fetch|urllib|http\.client|axios|localhost|127\.0\.0\.1)/iu.test(
+    command
+  );
+}
+function collectSemanticContractTokens(context) {
+  const tools = context.tools;
+  if (tools.headlessBench?.enabled !== true) return [];
+  const tokens = /* @__PURE__ */ new Set();
+  for (const item of tools.validationContract?.items ?? []) {
+    if (item.kind !== "service" || item.validation !== "semantic" || !Array.isArray(item.semanticTokens)) {
+      continue;
+    }
+    for (const token of item.semanticTokens) {
+      if (typeof token === "string" && token.trim()) {
+        tokens.add(token.trim());
+      }
+    }
+  }
+  return [...tokens];
+}
+function rememberRecentDiagnostics(context, source, content, toolUseId, evidenceId) {
+  const diagnostics = readDiagnosticsForTranscript(content?.data);
+  if (!diagnostics || diagnostics.length === 0) return;
+  const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+  const entries = diagnostics.map((diagnostic) => ({
+    source,
+    ...diagnostic,
+    createdAt,
+    toolUseId,
+    evidenceId
+  }));
+  context.tools.recentDiagnostics = [
+    ...entries,
+    ...context.tools.recentDiagnostics ?? []
+  ].slice(0, RECENT_DIAGNOSTICS_LIMIT);
+}
+function appendToolResultContentDiagnostics(content) {
+  if (!content || typeof content !== "object") return content;
+  const output = content;
+  if (typeof output.text !== "string") return content;
+  const diagnostics = formatToolDiagnosticsSummary(output);
+  const compactData = compactToolStructuredDataForTranscript(output.data);
+  if (!diagnostics && !compactData) return content;
+  return {
+    ...output,
+    data: compactData,
+    text: diagnostics ? appendCompactDiagnostics(output.text, diagnostics) : output.text
+  };
+}
+function readValidationEvidenceForTranscript(data) {
+  if (!data || typeof data !== "object") return void 0;
+  const record = data;
+  const entries = [
+    readArtifactValidationEvidence(record),
+    readPreservationValidationEvidence(record),
+    readServiceValidationEvidence(record),
+    readBinaryValidationEvidence(record)
+  ].filter((item) => Boolean(item));
+  return entries.length > 0 ? entries : void 0;
+}
+function readArtifactValidationEvidence(record) {
+  const artifact = readRecord(record.artifact);
+  if (!artifact) return void 0;
+  const path = readString(artifact.path);
+  if (!path) return void 0;
+  return {
+    kind: "artifact",
+    path,
+    tool: "Bash.artifact",
+    ok: record.exitCode === 0 && artifact.exists === true && checksOk(readRecord(artifact.checks)),
+    ...artifact.checks && typeof artifact.checks === "object" ? { checks: compactArtifactChecks(artifact.checks) } : {}
+  };
+}
+function readPreservationValidationEvidence(record) {
+  const artifact = readRecord(record.artifact);
+  const checks = readRecord(artifact?.checks);
+  const preserve = readRecord(checks?.preserve);
+  const path = readString(artifact?.path);
+  if (!artifact || !checks || !preserve || !path) return void 0;
+  return {
+    kind: "preservation",
+    path,
+    tool: "Bash.artifact",
+    ok: record.exitCode === 0 && preserve.ok === true,
+    checks: { preserve: compactCheckRecord(preserve) }
+  };
+}
+function readServiceValidationEvidence(record) {
+  const service = readRecord(record.service);
+  if (!service) return void 0;
+  const target = readString(service.target) ?? readServiceTargetFromHostPort(service);
+  if (!target) return void 0;
+  const readiness = readRecord(service.readiness);
+  const fetch = readRecord(service.fetch);
+  return {
+    kind: "service",
+    target,
+    tool: "Bash.service",
+    ok: record.exitCode === 0 && (service.ready === true || readiness?.ok === true),
+    ...readiness || fetch ? { checks: { ...readiness ? { readiness: compactCheckRecord(readiness) } : {}, ...fetch ? { fetch: compactCheckRecord(fetch) } : {} } } : {}
+  };
+}
+function readBinaryValidationEvidence(record) {
+  const binary = readRecord(record.binary);
+  if (!binary) return void 0;
+  const path = readString(binary.path);
+  if (!path) return void 0;
+  return {
+    kind: "binary",
+    path,
+    tool: "Bash.binary",
+    ok: record.exitCode === 0,
+    checks: compactCheckRecord(binary)
+  };
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function readServiceTargetFromHostPort(service) {
+  const host = readString(service.targetHost);
+  const port = typeof service.targetPort === "number" ? service.targetPort : void 0;
+  return host && port !== void 0 ? `${host}:${port}` : void 0;
+}
+function checksOk(checks) {
+  if (!checks) return true;
+  return Object.values(checks).every((value) => {
+    const check = readRecord(value);
+    return !check || check.ok !== false;
+  });
+}
+function compactArtifactChecks(value) {
+  const checks = readRecord(value);
+  if (!checks) return {};
+  const compact = {};
+  for (const key of ["header", "json", "executable", "text", "preserve"]) {
+    const check = readRecord(checks[key]);
+    if (check) compact[key] = compactCheckRecord(check);
+  }
+  return compact;
+}
+function compactCheckRecord(record) {
+  const compact = {};
+  for (const key of ["ok", "mode", "status", "expectedStatus", "missingBody", "contains", "lineSet", "exact", "magic", "size"]) {
+    if (record[key] !== void 0) compact[key] = record[key];
+  }
+  return compact;
+}
 async function budgetToolResultTranscriptContent(context, sessionId, toolUseId, content) {
   const contentText = stringifyToolResultContentForBudget(content);
   if (!contentText || contentText.startsWith("<persisted-tool-result>")) return content;

package/dist/{chunk-5CXN4JLE.js → chunk-EGHM55EV.js}

@@ -1,17 +1,17 @@
 import {
   createCompactBoundaryBlock
-} from "./chunk-HIIYRATQ.js";
+} from "./chunk-ESAACKVG.js";
 import {
   createEvidenceRecord,
   rememberEvidence
-} from "./chunk-L2GU3PWU.js";
+} from "./chunk-DEIYY6NI.js";
 import {
   applyToolResultBudgetToMessages
 } from "./chunk-O7S3HYE6.js";
 import {
   injectDeepCompactSummary,
   maybeRunDeepCompactBeforeProvider
-} from "./chunk-RMLTVKOY.js";
+} from "./chunk-L4YVE3RG.js";
 import {
   getContextWindowForModel
 } from "./chunk-K4FSYBSY.js";
@@ -28,7 +28,7 @@ import {
   sanitizeDiagnosticText,
   sanitizeDisplayPaths,
   truncateDisplay
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 
 // src/compact-preflight-runtime.ts
 import "@linghun/providers";

package/dist/{chunk-HIIYRATQ.js → chunk-ESAACKVG.js}

@@ -2,7 +2,7 @@ import {
   buildTranscriptScreenBuffer,
   selectionLineIndexesForBlock,
   selectionLineRangesForBlock
-} from "./chunk-NKFKOEYX.js";
+} from "./chunk-WCMHJ6SS.js";
 import {
   buildHelpPanelData
 } from "./chunk-3AKXDMVS.js";
@@ -24,16 +24,16 @@ import {
   formatPermissionModeLabel,
   permissionModeColor,
   permissionModeSymbol
-} from "./chunk-KI7C6ZOD.js";
+} from "./chunk-VIJ7GDKI.js";
 import {
   sanitizeMainScreenLeakage
-} from "./chunk-7TYK55JT.js";
+} from "./chunk-BEDD7OFL.js";
 import {
   SLASH_COMMAND_REGISTRY
 } from "./chunk-PGNALDEH.js";
 import {
   formatElapsedSince
-} from "./chunk-UDQT5CWK.js";
+} from "./chunk-PI6T2AGS.js";
 import {
   DEFAULT_KEYBINDINGS
 } from "./chunk-6SMM5CMP.js";
@@ -42,7 +42,7 @@ import {
 } from "./chunk-K4FSYBSY.js";
 import {
   truncateMiddle
-} from "./chunk-APJIC2O5.js";
+} from "./chunk-GTIZNO5O.js";
 
 // src/shell/view-model.ts
 import { basename } from "path";
@@ -1136,7 +1136,9 @@ function buildPermissionExplanationLinesFromVerdict(verdict, risk, language) {
 function inferSemanticByToolName(toolName) {
   if (toolName === "Bash") return "destructive";
   if (toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit") return "mutating";
-  if (toolName === "Read" || toolName === "Glob" || toolName === "Grep") return "readonly";
+  if (toolName === "Read" || toolName === "ReadSnippets" || toolName === "SourcePack" || toolName === "Glob" || toolName === "Grep") {
+    return "readonly";
+  }
   if (toolName === "WebSearch" || toolName === "WebFetch") return "network";
   return "unknown";
 }
@@ -1169,9 +1171,11 @@ function buildPermissionActionSummary(language, toolName, input) {
     const path = str("file_path") ?? str("path");
     if (path) return zh ? `\u4FEE\u6539\u6587\u4EF6\uFF1A${path}` : `Edit file: ${path}`;
   }
-  if (toolName === "Read") {
+  if (toolName === "Read" || toolName === "ReadSnippets" || toolName === "SourcePack") {
     const path = str("path") ?? str("file_path");
     if (path) return zh ? `\u8BFB\u53D6\u6587\u4EF6\uFF1A${path}` : `Read file: ${path}`;
+    if (toolName === "ReadSnippets") return zh ? "\u8BFB\u53D6\u4EE3\u7801\u7247\u6BB5" : "Read snippets";
+    if (toolName === "SourcePack") return zh ? "\u5B9A\u4F4D\u4EE3\u7801\u7247\u6BB5" : "Locate source snippets";
   }
   if (toolName === "Glob" || toolName === "Grep") {
     const target = str("pattern") ?? str("path");

package/dist/{chunk-O6MKVGVK.js → chunk-G7O26P5X.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-GTP2KPLY.js";
 import {
   showCommandPanel
-} from "./chunk-AZU7HXIT.js";
+} from "./chunk-6JPUBF7B.js";
 import {
   MANAGED_WORKTREE_DIRNAME,
   redactWorktreePath,

package/dist/{chunk-APJIC2O5.js → chunk-GTIZNO5O.js}

@@ -47,6 +47,89 @@ function displayWidth(value) {
   for (const char of value) width += charWidth(char);
   return width;
 }
+function computeWrappedInputState(input) {
+  const normalizedText = String(input.text ?? "").replace(/\r/g, "");
+  const chars = Array.from(normalizedText);
+  const cursorOffset = clamp(input.cursorOffset, 0, chars.length);
+  const safeWidth = Math.max(0, Math.floor(Number.isFinite(input.width) ? input.width : 0));
+  const safePrefixWidth = Math.max(0, Math.floor(input.prefixWidth ?? 0));
+  const safePaddingLeft = Math.max(0, Math.floor(input.paddingLeft ?? 0));
+  const safePaddingRight = Math.max(0, Math.floor(input.paddingRight ?? 0));
+  const safeMinContentWidth = Math.max(0, Math.floor(input.minContentWidth ?? 0));
+  const contentWidth = Math.max(
+    safeMinContentWidth,
+    safeWidth - safePaddingLeft - safePaddingRight
+  );
+  const firstLineWidth = Math.max(1, contentWidth - safePrefixWidth);
+  const wrappedLines = [];
+  let cursorRow = 0;
+  let cursorCol = 0;
+  let cursorResolved = false;
+  const logicalLines = normalizedText.split("\n");
+  let logicalLineStart = 0;
+  let fallbackLineStart = 0;
+  let fallbackLineChars = [];
+  for (let logicalIndex = 0; logicalIndex < logicalLines.length; logicalIndex += 1) {
+    const lineText = logicalLines[logicalIndex] ?? "";
+    const lineChars = Array.from(lineText);
+    const lineStartOffset = logicalLineStart;
+    const lineEndOffset = lineStartOffset + lineChars.length;
+    const wrapWidth = logicalIndex === 0 ? firstLineWidth : Math.max(1, contentWidth);
+    const segments = wrapInputLine(lineChars, wrapWidth);
+    fallbackLineStart = lineStartOffset;
+    fallbackLineChars = lineChars;
+    for (const segment of segments) {
+      const segmentText = lineChars.slice(segment.start, segment.end).join("");
+      wrappedLines.push(segmentText);
+      if (!cursorResolved && cursorOffset >= lineStartOffset && cursorOffset <= lineEndOffset) {
+        const lineCursorOffset = cursorOffset - lineStartOffset;
+        if (lineCursorOffset >= segment.start && lineCursorOffset <= segment.end) {
+          cursorRow = wrappedLines.length - 1;
+          cursorCol = displayWidth(lineChars.slice(segment.start, lineCursorOffset).join(""));
+          cursorResolved = true;
+        }
+      }
+    }
+    logicalLineStart += lineChars.length + 1;
+  }
+  if (!cursorResolved) {
+    cursorRow = Math.max(0, wrappedLines.length - 1);
+    cursorCol = displayWidth(
+      fallbackLineChars.slice(0, clamp(cursorOffset - fallbackLineStart, 0, fallbackLineChars.length)).join("")
+    );
+    if (chars.length === 0) cursorCol = 0;
+  }
+  return {
+    lines: wrappedLines.length > 0 ? wrappedLines : [""],
+    cursorRow,
+    cursorCol,
+    contentWidth
+  };
+}
+function wrapInputLine(chars, wrapWidth) {
+  const safeWrapWidth = Math.max(1, Math.floor(wrapWidth));
+  const segments = [];
+  let start = 0;
+  while (start < chars.length || chars.length === 0 && start === 0) {
+    let end = start;
+    let width = 0;
+    while (end < chars.length) {
+      const nextWidth = charWidth(chars[end] ?? "");
+      if (width > 0 && width + nextWidth > safeWrapWidth) break;
+      width += nextWidth;
+      end += 1;
+    }
+    if (end === start && chars.length > 0) end += 1;
+    segments.push({ start, end });
+    if (chars.length === 0) break;
+    start = end;
+  }
+  return segments;
+}
+function clamp(value, min, max) {
+  if (!Number.isFinite(value)) return min;
+  return Math.min(max, Math.max(min, Math.floor(value)));
+}
 function truncateDisplay(value, max) {
   const normalized = String(value || "").replace(/\s+/gu, " ").trim();
   if (displayWidth(normalized) <= max) return normalized;
@@ -140,6 +223,7 @@ export {
   wrapText,
   charWidth,
   displayWidth,
+  computeWrappedInputState,
   truncateDisplay,
   truncateMiddle,
   composerMaxWidth,

package/dist/{chunk-UOHZQIVL.js → chunk-GXFYUZAM.js}

@@ -5,7 +5,7 @@ import {
   fitText,
   lineChar,
   wrapText
-} from "./chunk-APJIC2O5.js";
+} from "./chunk-GTIZNO5O.js";
 
 // src/shell/components/CommandPanel.tsx
 import { Box, Text } from "@linghun/ink-runtime";