@linghun/tui 0.1.2 → 0.1.3

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

@@ -6,6 +6,9 @@ import {
   formatToolResultBudgetEvidenceSummary,
   formatToolResultBudgetSystemEvent
 } from "./chunk-O7S3HYE6.js";
+import {
+  formatToolDiagnosticsSummary
+} from "./chunk-OI5TZ37D.js";
 import {
   LINGHUN_DEFAULT_TOOL_RESULT_CHARS,
   LINGHUN_MAX_TOOL_RESULT_BYTES
@@ -15,7 +18,7 @@ import {
 } from "./chunk-7ZMDQZ22.js";
 import {
   deriveToolSupportsClaims
-} from "./chunk-YKOXJQGX.js";
+} from "./chunk-NWZ44SFI.js";
 import {
   mergeFailureRecord,
   writeFailureRecord
@@ -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(),
@@ -220,15 +224,20 @@ async function recordToolEvidence(context, sessionId, name, output, input) {
     return null;
   }
   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",
@@ -420,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 {
@@ -431,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) {
@@ -474,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;
@@ -525,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",
@@ -541,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-5IFNLTOF.js → chunk-EGHM55EV.js}

@@ -1,10 +1,10 @@
 import {
   createCompactBoundaryBlock
-} from "./chunk-EKYXI6C7.js";
+} from "./chunk-ESAACKVG.js";
 import {
   createEvidenceRecord,
   rememberEvidence
-} from "./chunk-NK4NMYF5.js";
+} from "./chunk-DEIYY6NI.js";
 import {
   applyToolResultBudgetToMessages
 } from "./chunk-O7S3HYE6.js";

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

@@ -27,7 +27,7 @@ import {
 } from "./chunk-VIJ7GDKI.js";
 import {
   sanitizeMainScreenLeakage
-} from "./chunk-YLOJWSHB.js";
+} from "./chunk-BEDD7OFL.js";
 import {
   SLASH_COMMAND_REGISTRY
 } from "./chunk-PGNALDEH.js";

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

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

package/dist/{chunk-FGGY5KNM.js → chunk-GYHEUVR2.js}

@@ -6,10 +6,10 @@ import {
 } from "./chunk-TVNWAEJR.js";
 import {
   showCommandPanel
-} from "./chunk-PPUOHBAK.js";
+} from "./chunk-6JPUBF7B.js";
 import {
   writeErrorLine
-} from "./chunk-HPIHFENG.js";
+} from "./chunk-OH35XDD4.js";
 import {
   createHandoffPacket,
   formatResumePacket,

package/dist/{chunk-HZ5XNKWS.js → chunk-HMGYFENJ.js}

@@ -1,6 +1,6 @@
 import {
   createProcessGuard
-} from "./chunk-J6CYFWSW.js";
+} from "./chunk-VDQTNA4W.js";
 import {
   sanitizeDiagnosticText,
   truncateDisplay

package/dist/{chunk-ZJDPYOTK.js → chunk-IQS34W5A.js}

@@ -27,11 +27,11 @@ import {
 } from "./chunk-CFXB5SE5.js";
 import {
   showCommandPanel
-} from "./chunk-PPUOHBAK.js";
+} from "./chunk-6JPUBF7B.js";
 import {
   redactRemoteSummary,
   remoteTranscriptSummary
-} from "./chunk-42ZZUF7P.js";
+} from "./chunk-6C32YAB5.js";
 import {
   applyRemoteSessionDisables,
   createRemoteState

package/dist/{chunk-7BHMBWG2.js → chunk-J7AAPUTV.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-NMNOAFFT.js";
 import {
   showCommandPanel
-} from "./chunk-PPUOHBAK.js";
+} from "./chunk-6JPUBF7B.js";
 import {
   snapshotDeferredToolsSummary,
   snapshotDiscoveredDeferredToolsSummary

package/dist/{chunk-YDTJ7UBG.js → chunk-JMUAQUQQ.js}

@@ -1,6 +1,6 @@
 import {
   redactedPath
-} from "./chunk-HZ5XNKWS.js";
+} from "./chunk-HMGYFENJ.js";
 import {
   formatJobRunnerInline
 } from "./chunk-PI6T2AGS.js";

package/dist/{chunk-NL4M3V5D.js → chunk-KKZBBCHK.js}

@@ -5,7 +5,7 @@ import {
   detectEngineeringArtifactTargets,
   formatEngineeringFailureBoundaryHint,
   formatEngineeringProfileStrategyHint
-} from "./chunk-4UER2AKI.js";
+} from "./chunk-ZPFOP557.js";
 import {
   LINGHUN_AGENT_CHILD_TURNS_AGENT,
   LINGHUN_AGENT_CHILD_TURNS_BASE,

package/dist/{chunk-UIKN3CDF.js → chunk-NMOVU75L.js}

@@ -1,6 +1,6 @@
 import {
   formatApprovedRunnerSpecLine
-} from "./chunk-YDTJ7UBG.js";
+} from "./chunk-JMUAQUQQ.js";
 import {
   formatJobNextAction,
   formatJobRunnerInline,

package/dist/{chunk-YKOXJQGX.js → chunk-NWZ44SFI.js}

@@ -123,9 +123,84 @@ function createToolInputSchema(name) {
       ...base,
       properties: {
         command: { type: "string" },
-        timeoutMs: { type: "number" }
-      },
-      required: ["command"]
+        timeoutMs: { type: "number" },
+        runInBackground: { type: "boolean" },
+        run_in_background: { type: "boolean" },
+        service: {
+          type: "object",
+          additionalProperties: false,
+          anyOf: [
+            { required: ["action", "url"] },
+            { required: ["action", "serviceId"] },
+            { required: ["type", "port"] },
+            { required: ["type", "url"] }
+          ],
+          properties: {
+            action: { type: "string", enum: ["status", "probe", "logs", "stop", "fetch"] },
+            serviceId: { type: "string" },
+            type: { type: "string", enum: ["tcp", "http"] },
+            host: { type: "string" },
+            port: { type: "number" },
+            url: { type: "string" },
+            expectStatus: { type: "number" },
+            bodyContains: {
+              anyOf: [
+                { type: "string" },
+                { type: "array", items: { type: "string" } }
+              ]
+            },
+            timeoutMs: { type: "number" },
+            intervalMs: { type: "number" },
+            retry: { type: "number" },
+            tailBytes: { type: "number" }
+          }
+        },
+        artifact: {
+          type: "object",
+          additionalProperties: false,
+          required: ["path"],
+          properties: {
+            path: { type: "string" },
+            expectHeader: { type: "string" },
+            expectMagic: { type: "string" },
+            json: { type: "boolean" },
+            executable: { type: "boolean" },
+            protectPaths: { type: "array", items: { type: "string" } },
+            text: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                exact: { type: "string" },
+                contains: {
+                  anyOf: [
+                    { type: "string" },
+                    { type: "array", items: { type: "string" } }
+                  ]
+                },
+                lineSet: { type: "array", items: { type: "string" } }
+              }
+            },
+            preserve: {
+              type: "object",
+              additionalProperties: false,
+              properties: {
+                mode: { type: "string", enum: ["rawPreserve", "compareNormalizedHtml"] },
+                expectedPath: { type: "string" },
+                expectedText: { type: "string" }
+              }
+            }
+          }
+        },
+        binary: {
+          type: "object",
+          additionalProperties: false,
+          required: ["path"],
+          properties: {
+            path: { type: "string" },
+            previewBytes: { type: "number" }
+          }
+        }
+      }
     };
   }
   if (name === "Todo") {

package/dist/{chunk-HPIHFENG.js → chunk-OH35XDD4.js}

@@ -1,6 +1,6 @@
 import {
   createOutputBlock
-} from "./chunk-EKYXI6C7.js";
+} from "./chunk-ESAACKVG.js";
 import {
   writeLine
 } from "./chunk-UGYFQF6M.js";

package/dist/{chunk-WXTHKLNH.js → chunk-OI5TZ37D.js}

@@ -2,6 +2,8 @@
 var TODO_OUTPUT_ITEM_LIMIT = 8;
 var BASH_TAIL_LINE_LIMIT = 0;
 var PRIMARY_PREVIEW_LINE_CAP = 5;
+var DIAGNOSTICS_SUMMARY_LIMIT = 3;
+var DIAGNOSTICS_EVIDENCE_LIMIT = 120;
 var RAW_TOOL_USE_PATTERNS = [
   /<tool_use(?:_error)?\b[\s\S]*?<\/tool_use(?:_error)?>/giu,
   /<tool_use(?:_error)?\b[^>]*\/>/giu,
@@ -62,12 +64,36 @@ function formatToolOutput(name, output, language, evidenceId) {
   if (layered.preview) {
     lines.push(layered.preview);
   }
+  const diagnostics = formatToolDiagnosticsSummary(output);
+  if (diagnostics) {
+    lines.push(diagnostics);
+  }
   const bashEnd = formatBashEndSummary(name, output, language);
   if (bashEnd) {
     lines.push(bashEnd);
   }
   return lines.join("\n");
 }
+function formatToolDiagnosticsSummary(output) {
+  const metadata = output.data && typeof output.data === "object" ? output.data : void 0;
+  const diagnostics = Array.isArray(metadata?.diagnostics) ? metadata.diagnostics : [];
+  const lines = diagnostics.map(formatCompactDiagnosticLine).filter((line) => Boolean(line)).slice(0, DIAGNOSTICS_SUMMARY_LIMIT);
+  if (lines.length === 0) return void 0;
+  return ["Linghun diagnostics:", ...lines].join("\n");
+}
+function formatCompactDiagnosticLine(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const record = value;
+  const type = typeof record.type === "string" ? record.type.trim() : "";
+  const evidence = typeof record.evidence === "string" ? record.evidence.trim() : "";
+  if (!type || !evidence) return void 0;
+  return `- ${type}: ${compactDiagnosticEvidence(evidence)}`;
+}
+function compactDiagnosticEvidence(value) {
+  const singleLine = value.replace(/\s+/gu, " ").trim();
+  if (singleLine.length <= DIAGNOSTICS_EVIDENCE_LIMIT) return singleLine;
+  return `${singleLine.slice(0, DIAGNOSTICS_EVIDENCE_LIMIT - 3)}...`;
+}
 function formatPrimaryToolLead(name, output, layered, language) {
   const metadata = output.data && typeof output.data === "object" ? output.data : void 0;
   const count = readNumber(metadata, "count");
@@ -589,6 +615,7 @@ function looksLikeMojibake(text) {
 export {
   createLayeredToolOutput,
   formatToolOutput,
+  formatToolDiagnosticsSummary,
   formatToolStart,
   sanitizeAssistantPrimaryText,
   sanitizeAssistantPrimaryTextWithMetadata,

package/dist/{chunk-DIDRFIIW.js → chunk-OMWSM2DA.js}

@@ -1,6 +1,6 @@
 import {
   createProcessGuard
-} from "./chunk-J6CYFWSW.js";
+} from "./chunk-VDQTNA4W.js";
 import {
   sanitizeDiagnosticText
 } from "./chunk-UGYFQF6M.js";

package/dist/{chunk-X7E34LKV.js → chunk-OV5OT66G.js}

@@ -5,14 +5,14 @@ import {
   isPotentiallyMutatingMcpTool,
   runMcpStdioToolCall,
   runMcpStdioToolList
-} from "./chunk-DIDRFIIW.js";
+} from "./chunk-OMWSM2DA.js";
 import {
   buildIndexStatusPanel,
   buildMcpStatusPanel,
   formatIndexRefreshSummary,
   formatIndexStatus,
   formatMcpStatus
-} from "./chunk-O2U4XQVM.js";
+} from "./chunk-UYU4QN3P.js";
 import {
   runMcpSseToolCall
 } from "./chunk-BNC4F63N.js";
@@ -26,14 +26,14 @@ import {
 } from "./chunk-6CHUZ2NF.js";
 import {
   showCommandPanel
-} from "./chunk-PPUOHBAK.js";
+} from "./chunk-6JPUBF7B.js";
 import {
   writeDiagnosticLine
-} from "./chunk-HPIHFENG.js";
+} from "./chunk-OH35XDD4.js";
 import {
   redactedPath,
   runCommandCapture
-} from "./chunk-HZ5XNKWS.js";
+} from "./chunk-HMGYFENJ.js";
 import {
   findDeferredTool,
   getCodebaseMemoryToolRisk,

package/dist/{chunk-HGCTHBUY.js → chunk-PHPEPZAA.js}

@@ -4,7 +4,7 @@ import {
   formatPermissionSummary,
   getHardDenyReason,
   isPlanAllowedTool
-} from "./chunk-42ZZUF7P.js";
+} from "./chunk-6C32YAB5.js";
 import {
   classifyToolRequest
 } from "./chunk-LHHKPGLX.js";