@linghun/tui 0.1.0

package/dist/chunk-L4XXW6Y5.js

@@ -0,0 +1,374 @@
+// src/log-artifact.ts
+import { createReadStream } from "fs";
+import { open, realpath, stat } from "fs/promises";
+import { basename, resolve } from "path";
+import { createInterface } from "readline";
+import { isPathInside, normalizePathSeparators } from "@linghun/shared";
+var DEFAULT_TAIL_LINES = 40;
+var MAX_TAIL_LINES = 200;
+var DEFAULT_MAX_BYTES = 64 * 1024;
+var DEFAULT_SCAN_BYTES = 1024 * 1024;
+var DEFAULT_MAX_MATCHES = 20;
+var DEFAULT_MAX_OUTPUT_LINES = 200;
+var DEFAULT_TIMEOUT_MS = 2e3;
+var MAX_CONTEXT_LINES = 5;
+var UTF8_BOUNDARY_PADDING_BYTES = 4;
+var MAX_EXACT_LINE_PREFIX_BYTES = 256 * 1024;
+var RELATIVE_LINE_NUMBER_WARNING = "Line numbers are relative to the bounded scan window; exact prefix scan was skipped for performance.";
+var COMPLETE_ARTIFACT_WITHHELD_WARNING = "Complete artifact withheld; showing a bounded slice only.";
+var ERROR_CANDIDATE_PATTERN = /\b(error|failed|exception|panic|fatal)\b|traceback|AssertionError|TypeError|SyntaxError|\bFAIL(?:ED)?\b|TS\d{4}|exitCode=[1-9]\d*|exit code [1-9]\d*|non-zero|command failed/iu;
+async function readLogArtifactSlice(source, request, registry) {
+  const sourcePath = await resolveLogArtifactPath(source, registry);
+  const info = await stat(sourcePath).catch((error) => {
+    if (error.code === "ENOENT") {
+      throw new Error(`\u65E5\u5FD7 artifact \u4E0D\u5B58\u5728\uFF1A${sourcePath}\u3002\u8BF7\u786E\u8BA4\u4EFB\u52A1\u5DF2\u4EA7\u751F\u8F93\u51FA\u3002`);
+    }
+    throw error;
+  });
+  if (!info.isFile()) {
+    throw new Error(`\u65E5\u5FD7 artifact \u4E0D\u662F\u6587\u4EF6\uFF1A${sourcePath}\u3002`);
+  }
+  if (request.mode === "tail") {
+    return readTail(sourcePath, info.size, request);
+  }
+  if (request.mode === "grep") {
+    return readGrep(sourcePath, info.size, request, compileUserPattern(request.pattern));
+  }
+  return readErrors(sourcePath, info.size, request);
+}
+function formatLogArtifactSlice(slice, language) {
+  const title = language === "en-US" ? `Log artifact ${slice.mode}` : `Log artifact ${slice.mode} \u5207\u7247`;
+  const lines = [
+    title,
+    `- sourcePath: ${formatDisplaySourcePath(slice.sourcePath)}`,
+    `- mode: ${slice.mode}`,
+    `- range: ${formatRange(slice)}`,
+    `- truncated: ${slice.truncated ? "true" : "false"}`
+  ];
+  if (slice.matches) {
+    lines.push(`- matches: ${slice.matches.length}`);
+  }
+  if (slice.warnings?.length) {
+    for (const warning of slice.warnings) {
+      lines.push(`- warning: ${warning}`);
+    }
+  }
+  lines.push(
+    language === "en-US" ? "- boundary: bounded read only; full log was not inserted into the main screen, prompt, memory, or handoff." : "- boundary: \u4EC5\u6709\u754C\u8BFB\u53D6\uFF1B\u5B8C\u6574\u65E5\u5FD7\u4E0D\u4F1A\u8FDB\u5165\u4E3B\u5C4F\u3001prompt\u3001memory \u6216 handoff\u3002"
+  );
+  if (slice.content.trim()) {
+    lines.push("", slice.content);
+  } else {
+    lines.push("", language === "en-US" ? "No matching log content." : "\u672A\u627E\u5230\u5339\u914D\u65E5\u5FD7\u5185\u5BB9\u3002");
+  }
+  return lines.join("\n");
+}
+async function resolveLogArtifactPath(source, registry) {
+  if (source.backgroundId) {
+    const background = registry.backgrounds?.find(
+      (item) => item.id === source.backgroundId || item.id.endsWith(source.backgroundId ?? "")
+    );
+    if (!background) {
+      throw new Error(`\u672A\u627E\u5230 background\uFF1A${source.backgroundId}\u3002\u8BF7\u7528 /background \u67E5\u770B\u53EF\u7528\u4EFB\u52A1\u3002`);
+    }
+    const candidate = background.outputPath ?? background.logPath;
+    if (!candidate) {
+      throw new Error(`Background ${background.id} \u5C1A\u65E0 log/output artifact\u3002`);
+    }
+    return ensureAllowedPath(candidate, registry);
+  }
+  if (source.evidenceId) {
+    const evidence = registry.evidence?.find(
+      (item) => item.id === source.evidenceId || item.id.endsWith(source.evidenceId ?? "")
+    );
+    if (!evidence) {
+      throw new Error(
+        `\u672A\u627E\u5230 evidence\uFF1A${source.evidenceId}\u3002\u8BF7\u7528 /details evidence \u67E5\u770B\u53EF\u7528\u8BC1\u636E\u3002`
+      );
+    }
+    const explicitArtifact = evidence.fullOutputPath ?? evidence.outputPath ?? evidence.logPath;
+    if (explicitArtifact) {
+      return ensureAllowedPath(explicitArtifact, registry);
+    }
+    if (!evidence.source) {
+      throw new Error(`Evidence ${evidence.id} \u5C1A\u65E0 source artifact\u3002`);
+    }
+    return ensureEvidenceSourceArtifactPath(evidence.source, registry);
+  }
+  if (source.path) {
+    return ensureAllowedPath(source.path, registry);
+  }
+  throw new Error("\u7F3A\u5C11 log artifact source\uFF1A\u9700\u8981 backgroundId\u3001evidenceId \u6216 path\u3002");
+}
+async function ensureAllowedPath(path, registry) {
+  const resolved = resolve(registry.workspaceRoot, path);
+  const roots = [registry.workspaceRoot, ...registry.logRoots ?? []].map((root) => resolve(root));
+  if (!roots.some((root) => isPathInside(resolved, root))) {
+    throw new Error("\u62D2\u7EDD\u8BFB\u53D6\u65E5\u5FD7 artifact\uFF1A\u8DEF\u5F84\u4E0D\u5728 workspace \u6216\u5DF2\u77E5 log root \u5185\u3002");
+  }
+  const realResolved = await realpath(resolved).catch(() => resolved);
+  const realRoots = await Promise.all(roots.map((root) => realpath(root).catch(() => root)));
+  if (!realRoots.some((root) => isPathInside(realResolved, root))) {
+    throw new Error("\u62D2\u7EDD\u8BFB\u53D6\u65E5\u5FD7 artifact\uFF1A\u8DEF\u5F84\u4E0D\u5728 workspace \u6216\u5DF2\u77E5 log root \u5185\u3002");
+  }
+  return realResolved;
+}
+async function ensureEvidenceSourceArtifactPath(path, registry) {
+  const resolved = await ensureAllowedPath(path, registry);
+  const logRoots = (registry.logRoots?.length ? registry.logRoots : [resolve(registry.workspaceRoot, ".linghun", "logs")]).map((root) => resolve(root));
+  const realLogRoots = await Promise.all(logRoots.map((root) => realpath(root).catch(() => root)));
+  if (realLogRoots.some((root) => isPathInside(resolved, root))) {
+    return resolved;
+  }
+  throw new Error(
+    "Evidence source \u4E0D\u662F log/output artifact\uFF1A\u8BF7\u7528 Read \u6216\u5176\u4ED6\u5408\u9002\u5DE5\u5177\u67E5\u770B\u666E\u901A workspace \u6587\u4EF6\u3002"
+  );
+}
+async function readTail(sourcePath, fileSize, request) {
+  const maxBytes = clampPositive(request.maxBytes, DEFAULT_MAX_BYTES, DEFAULT_MAX_BYTES);
+  const lines = clampPositive(request.lines, DEFAULT_TAIL_LINES, MAX_TAIL_LINES);
+  const readStart = Math.max(0, fileSize - maxBytes - UTF8_BOUNDARY_PADDING_BYTES);
+  const readLength = Math.max(0, fileSize - readStart);
+  const buffer = Buffer.alloc(readLength);
+  const file = await open(sourcePath, "r");
+  try {
+    await file.read(buffer, 0, readLength, readStart);
+  } finally {
+    await file.close();
+  }
+  const decoded = buffer.toString("utf8");
+  const allLines = decoded.split(/\r?\n/u);
+  const usableLines = readStart > 0 ? allLines.slice(1) : allLines;
+  const selected = preventCompleteLineDump(usableLines.slice(-lines), usableLines.length);
+  const truncated = readStart > 0 || usableLines.length > selected.lines.length;
+  const numbering = await resolveLineNumberOffset(sourcePath, readStart);
+  const firstUsableLine = readStart > 0 ? numbering.countBeforeStart + 2 : 1;
+  const tailStartLine = firstUsableLine + Math.max(0, usableLines.length - lines);
+  const selectedStartLine = selected.lines.length > 0 ? tailStartLine + (selected.withheld ? 1 : 0) : void 0;
+  const selectedEndLine = selectedStartLine === void 0 ? void 0 : selectedStartLine + selected.lines.length - 1;
+  const warnings = [
+    ...selected.withheld ? [COMPLETE_ARTIFACT_WITHHELD_WARNING] : [],
+    ...truncated ? ["Output capped; increase --tail lines only when necessary."] : [],
+    ...!numbering.exact ? [RELATIVE_LINE_NUMBER_WARNING] : []
+  ];
+  return {
+    sourcePath,
+    mode: "tail",
+    byteRange: { start: readStart, end: fileSize },
+    lineRange: { start: selectedStartLine, end: selectedEndLine },
+    truncated,
+    content: redactLogContent(selected.lines.join("\n")),
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
+}
+async function readGrep(sourcePath, fileSize, request, pattern) {
+  const maxBytes = clampPositive(request.maxBytes, DEFAULT_SCAN_BYTES, DEFAULT_SCAN_BYTES);
+  const maxMatches = clampPositive(request.maxMatches, DEFAULT_MAX_MATCHES, DEFAULT_MAX_MATCHES);
+  const maxOutputLines = clampPositive(
+    request.maxLines,
+    DEFAULT_MAX_OUTPUT_LINES,
+    DEFAULT_MAX_OUTPUT_LINES
+  );
+  const timeoutMs = clampPositive(request.timeoutMs, DEFAULT_TIMEOUT_MS, DEFAULT_TIMEOUT_MS);
+  const startedAt = Date.now();
+  const contextLines = Math.min(
+    clampPositive(request.contextLines, 0, MAX_CONTEXT_LINES),
+    MAX_CONTEXT_LINES
+  );
+  const readStart = Math.max(0, fileSize - maxBytes - UTF8_BOUNDARY_PADDING_BYTES);
+  const numbering = await resolveLineNumberOffset(sourcePath, readStart);
+  let lineNumber = numbering.countBeforeStart;
+  const stream = createReadStream(sourcePath, { encoding: "utf8", start: readStart });
+  const reader = createInterface({ input: stream, crlfDelay: Number.POSITIVE_INFINITY });
+  const before = [];
+  const outputLines = [];
+  const emitted = /* @__PURE__ */ new Set();
+  const matches = [];
+  let skippedPartialLine = readStart === 0;
+  let afterRemaining = 0;
+  let truncated = fileSize > maxBytes;
+  for await (const line of reader) {
+    if (Date.now() - startedAt > timeoutMs) {
+      truncated = true;
+      break;
+    }
+    if (!skippedPartialLine) {
+      skippedPartialLine = true;
+      lineNumber += 1;
+      continue;
+    }
+    lineNumber += 1;
+    if (pattern.test(line)) {
+      matches.push({ line: lineNumber, text: redactLogContent(line) });
+      for (const item of before) {
+        pushLine(outputLines, emitted, item);
+      }
+      pushLine(outputLines, emitted, { line: lineNumber, text: line });
+      afterRemaining = contextLines;
+      if (matches.length >= maxMatches || outputLines.length >= maxOutputLines) {
+        truncated = true;
+        break;
+      }
+      continue;
+    }
+    if (afterRemaining > 0) {
+      pushLine(outputLines, emitted, { line: lineNumber, text: line });
+      afterRemaining -= 1;
+      if (outputLines.length >= maxOutputLines) {
+        truncated = true;
+        break;
+      }
+    }
+    before.push({ line: lineNumber, text: line });
+    if (before.length > contextLines) {
+      before.shift();
+    }
+  }
+  reader.close();
+  stream.destroy();
+  const selected = preventCompleteNumberedLineDump(
+    outputLines,
+    lineNumber,
+    truncated,
+    new Set(matches.map((match) => match.line))
+  );
+  const warnings = [
+    ...selected.withheld ? [COMPLETE_ARTIFACT_WITHHELD_WARNING] : [],
+    ...truncated ? ["Output capped; narrow the pattern or inspect a smaller artifact slice."] : [],
+    ...!numbering.exact ? [RELATIVE_LINE_NUMBER_WARNING] : [],
+    ...matches.length === 0 ? ["No matches found in the bounded scan window."] : []
+  ];
+  return {
+    sourcePath,
+    mode: "grep",
+    byteRange: { start: readStart, end: fileSize },
+    lineRange: { start: selected.lines[0]?.line, end: selected.lines.at(-1)?.line },
+    truncated: truncated || selected.withheld,
+    matches,
+    content: formatNumberedLines(selected.lines),
+    warnings: warnings.length > 0 ? warnings : void 0
+  };
+}
+async function readErrors(sourcePath, fileSize, request) {
+  const slice = await readGrep(
+    sourcePath,
+    fileSize,
+    { ...request, contextLines: request.contextLines ?? 2 },
+    ERROR_CANDIDATE_PATTERN
+  );
+  return {
+    ...slice,
+    mode: "errors",
+    warnings: [
+      "Error candidates are diagnostic slices only; they do not change verification PASS/PARTIAL/FAIL semantics or identify root cause.",
+      ...slice.warnings ?? []
+    ]
+  };
+}
+function pushLine(outputLines, emitted, item) {
+  if (emitted.has(item.line)) {
+    return;
+  }
+  emitted.add(item.line);
+  outputLines.push({ line: item.line, text: redactLogContent(item.text) });
+}
+async function resolveLineNumberOffset(sourcePath, offset) {
+  if (offset <= 0) {
+    return { countBeforeStart: 0, exact: true };
+  }
+  if (offset > MAX_EXACT_LINE_PREFIX_BYTES) {
+    return { countBeforeStart: 0, exact: false };
+  }
+  return { countBeforeStart: await countLineBreaksBeforeOffset(sourcePath, offset), exact: true };
+}
+async function countLineBreaksBeforeOffset(sourcePath, offset) {
+  return new Promise((resolveCount, reject) => {
+    let count = 0;
+    const stream = createReadStream(sourcePath, { start: 0, end: offset - 1 });
+    stream.on("data", (chunk) => {
+      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      for (const byte of buffer) {
+        if (byte === 10) {
+          count += 1;
+        }
+      }
+    });
+    stream.on("error", reject);
+    stream.on("end", () => resolveCount(count));
+  });
+}
+function preventCompleteLineDump(lines, totalLinesInWindow) {
+  if (lines.length === 0 || lines.length < totalLinesInWindow) {
+    return { lines, withheld: false };
+  }
+  if (lines.length === 1) {
+    return { lines: [], withheld: true };
+  }
+  return { lines: lines.slice(1), withheld: true };
+}
+function preventCompleteNumberedLineDump(lines, scannedLines, alreadyTruncated, matchLineNumbers) {
+  if (alreadyTruncated || lines.length === 0 || lines.length < scannedLines) {
+    return { lines, withheld: false };
+  }
+  if (lines.length === 1) {
+    return { lines: [], withheld: true };
+  }
+  let indexToWithhold = 0;
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    if (!matchLineNumbers.has(lines[index]?.line ?? 0)) {
+      indexToWithhold = index;
+      break;
+    }
+  }
+  return {
+    lines: lines.filter((_, index) => index !== indexToWithhold),
+    withheld: true
+  };
+}
+function formatNumberedLines(lines) {
+  return lines.map((line) => `${line.line}: ${line.text}`).join("\n");
+}
+function compileUserPattern(pattern) {
+  if (!pattern?.trim()) {
+    throw new Error("grep \u6A21\u5F0F\u7F3A\u5931\u3002\u7528\u6CD5\uFF1A/details output <id> --grep <pattern> [--context N]");
+  }
+  return new RegExp(escapeRegExp(pattern), "iu");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function clampPositive(value, fallback, max) {
+  if (!Number.isFinite(value) || value === void 0 || value <= 0) {
+    return fallback;
+  }
+  return Math.min(Math.floor(value), max);
+}
+function formatDisplaySourcePath(sourcePath) {
+  const normalized = normalizePathSeparators(sourcePath);
+  const logRootIndex = normalized.indexOf("/.linghun/logs/");
+  if (logRootIndex >= 0) {
+    return normalized.slice(logRootIndex + 1);
+  }
+  if (normalized.startsWith(".linghun/logs/")) {
+    return normalized;
+  }
+  return `redacted:${basename(sourcePath)}`;
+}
+function formatRange(slice) {
+  if (slice.byteRange) {
+    return `bytes ${slice.byteRange.start}-${slice.byteRange.end}`;
+  }
+  if (slice.lineRange) {
+    return `lines ${slice.lineRange.start ?? "?"}-${slice.lineRange.end ?? "?"}`;
+  }
+  return "bounded";
+}
+function redactLogContent(text) {
+  return text.replace(/(Authorization\s*:\s*)[^\r\n]+/giu, "$1[REDACTED]").replace(/(Cookie\s*:\s*)[^\r\n]+/giu, "$1[REDACTED]").replace(/\bBearer\s+[A-Za-z0-9._~+/=-]+/giu, "Bearer [REDACTED]").replace(/\bsk-[A-Za-z0-9_-]{8,}\b/gu, "sk-[REDACTED]").replace(/((?:api[_-]?key|token|cookie)\s*[:=]\s*)[^\s;]+/giu, "$1[REDACTED]");
+}
+
+export {
+  readLogArtifactSlice,
+  formatLogArtifactSlice,
+  redactLogContent
+};

package/dist/chunk-L5GOCMZP.js

@@ -0,0 +1,18 @@
+// src/shell/components/MessageResponse.tsx
+import { Box, Text } from "@linghun/ink-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+function MessageResponse({
+  children,
+  width
+}) {
+  const prefixWidth = 5;
+  const childWidth = width ? Math.max(8, width - prefixWidth) : void 0;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "row", width, children: [
+    /* @__PURE__ */ jsx(Box, { flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "  \u23BF  " }) }),
+    /* @__PURE__ */ jsx(Box, { flexShrink: 1, flexGrow: 1, width: childWidth, children })
+  ] });
+}
+
+export {
+  MessageResponse
+};

package/dist/chunk-LDABZV5V.js

@@ -0,0 +1,278 @@
+import {
+  formatPercent
+} from "./chunk-QBCGAIU7.js";
+import {
+  calculateContextPercentages,
+  formatContextProgressBar,
+  getContextWindowForModel
+} from "./chunk-K4FSYBSY.js";
+import {
+  getSelectedModelRuntime
+} from "./chunk-3LT6OWQ2.js";
+import {
+  diffFreshness
+} from "./chunk-4T5DJW54.js";
+import {
+  sanitizeDiagnosticText
+} from "./chunk-OMZYPQVA.js";
+
+// src/cache-command-runtime.ts
+import { randomUUID } from "crypto";
+import { redactCommonSecrets } from "@linghun/shared";
+var DEFAULT_LIGHT_HINT_COOLDOWN_MS = 5 * 60 * 1e3;
+var MAX_LIGHT_HINTS_PER_TURN = 1;
+function buildCacheStatusPanel(context, currentFreshness) {
+  const isEn = context.language === "en-US";
+  const last = context.cache.history.at(-1);
+  const hitRate = last?.hitRate ?? null;
+  const summary = [];
+  if (hitRate === null || Number.isNaN(hitRate)) {
+    summary.push(isEn ? "Cache \xB7 no usage yet" : "\u7F13\u5B58 \xB7 \u5C1A\u65E0\u6837\u672C");
+  } else {
+    const pct = `${Math.round(hitRate * 100)}%`;
+    summary.push(isEn ? `Cache hit rate: ${pct}` : `\u7F13\u5B58\u547D\u4E2D\u7387\uFF1A${pct}`);
+  }
+  const isLow = typeof hitRate === "number" && Number.isFinite(hitRate) && hitRate < 0.3;
+  const tone = isLow ? "warning" : "neutral";
+  if (isLow) {
+    summary.push(
+      isEn ? "Hit rate is low \u2014 try /cache warmup or check provider usage." : "\u547D\u4E2D\u7387\u504F\u4F4E \u2014 \u53EF\u8FD0\u884C /cache warmup \u6216\u6838\u5BF9 provider usage\u3002"
+    );
+  }
+  return {
+    title: "/cache",
+    tone,
+    summary,
+    actions: ["/cache warmup", "/cache refresh"],
+    detailsText: formatCacheStatus(context, currentFreshness)
+  };
+}
+function formatCacheLog(context) {
+  if (context.cache.history.length === 0) {
+    return "\u6700\u8FD1\u7F13\u5B58\u65E5\u5FD7\u4E3A\u7A7A\u3002\u771F\u5B9E usage \u9700\u8981 provider \u8FD4\u56DE token/cache \u5B57\u6BB5\uFF1B\u53EF\u7528 /cache warmup \u5C1D\u8BD5\u9884\u70ED\u3002";
+  }
+  return [
+    `Cache log \u6700\u8FD1 ${context.cache.history.length}/${context.cache.config.maxTurns} \u8F6E\uFF1A`,
+    ...context.cache.history.map(
+      (item) => `#${item.turn} \u547D\u4E2D\u7387 ${formatPercent(item.hitRate)} \u8F93\u5165 ${item.inputTokens} \u8F93\u51FA ${item.outputTokens} \u7F13\u5B58\u8BFB\u53D6 ${item.cacheReadTokens} \u7F13\u5B58\u5199\u5165 ${item.cacheWriteTokens} \u6765\u6E90 ${formatCacheWriteSource(item.cacheWriteTokensSource)} \u6A21\u578B ${item.model} provider ${item.provider}`
+    )
+  ].join("\n");
+}
+function formatCacheWriteSource(source) {
+  if (source === "reported") return "provider reported";
+  if (source === "zero_reported") return "provider reported zero";
+  if (source === "estimated") return "estimated";
+  return "not reported";
+}
+function formatCacheStatus(context, currentFreshness) {
+  const latest = context.cache.history.at(-1);
+  const freshness = latest?.freshness ?? currentFreshness;
+  const changed = latest?.freshness.changedKeys ?? diffFreshness(context.cache.lastFreshness, freshness);
+  const source = latest?.cacheWriteTokensSource ?? "missing";
+  const zeroNote = source === "zero_reported" ? "provider \u5F53\u524D\u8FD4\u56DE cache_creation/cache write \u4E3A 0\uFF1B\u8FD9\u53EA\u662F\u5B57\u6BB5\u53E3\u5F84\uFF0C\u4E0D\u4EE3\u8868\u96F6\u5199\u5165\u6210\u672C\u3002" : source === "missing" ? "provider \u672A\u8FD4\u56DE cache_creation/cache write \u5B57\u6BB5\uFF1B\u4E0D\u652F\u6301\u771F\u5B9E\u7F13\u5B58\u5199\u5165\u7EDF\u8BA1\u3002" : "cache write/create \u5B57\u6BB5\u6765\u81EA provider/API usage\u3002";
+  return [
+    "Cache status",
+    `- history: ${context.cache.history.length}/${context.cache.config.maxTurns}`,
+    `- latest hitRate: ${formatPercent(latest?.hitRate ?? null)}\uFF08\u516C\u5F0F\uFF1AcacheRead / (input + cacheWrite + cacheRead)\uFF0Coutput \u4E0D\u8FDB\u5206\u6BCD\uFF09`,
+    `- read/write tokens: ${latest?.cacheReadTokens ?? 0}/${latest?.cacheWriteTokens ?? 0}`,
+    `- cache write source: ${source}`,
+    `- compact: ${context.cache.compacted ? "yes" : "no"}`,
+    `- workspace reference: hits ${context.cache.workspaceReference.hits}; misses ${context.cache.workspaceReference.misses}; failures ${context.cache.workspaceReference.failures}; latest ${context.cache.workspaceReference.latest?.source ?? "none"}`,
+    `- workspace snapshot lite: ${formatWorkspaceSnapshotLiteStatus(context)}`,
+    `- freshness changedKeys: ${changed.length > 0 ? changed.join(", ") : "none"}`,
+    `- note: ${zeroNote}`
+  ].join("\n");
+}
+function formatWorkspaceSnapshotLiteStatus(context) {
+  const snapshot = context.cache.workspaceReference.latest?.workspaceSnapshot;
+  if (!snapshot) {
+    return "none";
+  }
+  const changed = snapshot.changedSummary?.changedKeys.length ? snapshot.changedSummary.changedKeys.join(",") : "none";
+  return `files ${snapshot.counts.files}; dirs ${snapshot.counts.directories}; ignored ${snapshot.counts.ignored}; stored ${snapshot.counts.storedEntries}; partial ${snapshot.partial ? "yes" : "no"}; changed ${changed}`;
+}
+function formatCompactStatus(context) {
+  const latest = context.cache.compactBoundaries.at(-1);
+  const pressure = context.cache.compactPressure;
+  const runtime = getSelectedModelRuntime(context);
+  const contextUsage = pressure ? calculateContextPercentages(
+    Math.ceil(pressure.estimatedChars / 4),
+    Math.ceil(pressure.maxChars / 4) || getContextWindowForModel(runtime.model)
+  ) : void 0;
+  const projection = context.cache.compactProjection;
+  const deep = context.cache.deepCompact;
+  const failure = context.cache.compactFailure;
+  const lines = [
+    "Context Compact status",
+    `- pressure: ${pressure ? `${formatPercent(pressure.ratio)} (${pressure.estimatedChars}/${pressure.maxChars} chars; trigger ${pressure.triggerChars})` : "unknown"}`,
+    `- compacted: ${context.cache.compacted ? "yes" : "no"} \xB7 boundaries: ${context.cache.compactBoundaries.length}`,
+    `- latest: ${latest ? `${latest.kind}/${latest.id}` : "none"}`,
+    `- latest tokens: ${latest ? `${latest.preCompactTokenEstimate ?? "-"}\u2192${latest.postCompactTokenEstimate ?? "-"}` : "-"}`,
+    `- latest compact time: ${deep?.createdAt ?? projection?.createdAt ?? latest?.createdAt ?? "none"}`
+  ];
+  if (contextUsage) {
+    const bar = formatContextProgressBar(contextUsage.ratio, 24);
+    lines.push(`  context ${bar} ${contextUsage.usedTokens}/${contextUsage.maxTokens}`);
+  }
+  const apiInputTokens = context.lastApiTokenCount?.inputTokens;
+  if (apiInputTokens !== void 0) {
+    const inputK = Math.round(apiInputTokens / 1e3);
+    lines.push(`  latest request tokens: input ${inputK}k`);
+  }
+  lines.push(
+    "- deep scope: full transcript semantic compact",
+    "- projection scope: provider-visible recent context projection",
+    `- deep packet: ${deep ? `${deep.id}; trigger ${deep.trigger}; events ${deep.transcriptEventCount}` : "none"}`,
+    `- deep summary: ${deep ? sanitizeCompactStatusText(deep.summary.split(/\r?\n/u).slice(0, 4).join(" | ")) : "none"}`,
+    `- projection summary: ${projection ? sanitizeCompactStatusText(projection.summary.split(/\r?\n/u).slice(0, 4).join(" | ")) : "none"}`,
+    `- discarded/degraded scope: ${projection ? sanitizeCompactStatusText(projection.discardedRange) : "none"}`,
+    `- tool pairing safe: ${projection ? projection.toolPairingSafe ? "yes" : "no" : pressure ? pressure.toolPairingSafe ? "yes" : "no" : "unknown"}`,
+    `- failure/cooldown: ${failure ? `${failure.blocked ? "blocked" : "partial"}; ${sanitizeCompactStatusText(failure.reason)}; cooldown until ${failure.cooldownUntil}` : "none"}`,
+    `- preserved evidence refs: ${deep?.preservedEvidenceRefs.length ?? latest?.preservedEvidenceRefs.length ?? 0}`,
+    `- preserved files: ${deep?.preservedFiles.length ?? latest?.preservedFiles.length ?? 0}`,
+    "- boundary: deep summary and projection are redacted; raw transcript, secrets, large tool results, provider raw requests, and absolute paths stay out."
+  );
+  const suggestions = buildCompactSuggestions(context, contextUsage, pressure);
+  if (suggestions.length > 0) {
+    lines.push("", ...suggestions);
+  }
+  return lines.join("\n");
+}
+function buildCompactSuggestions(context, usage, pressure) {
+  const out = [];
+  const en = context.language === "en-US";
+  if (!usage || !pressure) return out;
+  if (usage.ratio > 0.85) {
+    out.push(
+      en ? `\u26A0 Suggestion: Context at ${(usage.ratio * 100).toFixed(0)}% \u2014 run /compact deep to semantically summarize older context and free capacity.` : `\u26A0 \u5EFA\u8BAE\uFF1A\u4E0A\u4E0B\u6587\u4F7F\u7528\u7387 ${(usage.ratio * 100).toFixed(0)}% \u2014 \u8FD0\u884C /compact deep \u8BED\u4E49\u6458\u8981\u8F83\u65E9\u4E0A\u4E0B\u6587\u4EE5\u91CA\u653E\u5BB9\u91CF\u3002`
+    );
+  } else if (usage.ratio > 0.7) {
+    out.push(
+      en ? `Suggestion: Context at ${(usage.ratio * 100).toFixed(0)}% \u2014 approaching limit. Deep compact is available when needed.` : `\u5EFA\u8BAE\uFF1A\u4E0A\u4E0B\u6587\u4F7F\u7528\u7387 ${(usage.ratio * 100).toFixed(0)}% \u2014 \u63A5\u8FD1\u4E0A\u9650\u3002\u9700\u8981\u65F6\u53EF\u8FD0\u884C deep compact\u3002`
+    );
+  }
+  if (usage.ratio > 0.6 && !context.cache.compacted) {
+    out.push(
+      en ? "Tip: Auto-compact triggers around 80%. You can also /compact manual for a semantic rewrite of older context." : "\u63D0\u793A\uFF1A\u81EA\u52A8\u538B\u7F29\u7EA6\u5728 80% \u89E6\u53D1\u3002\u4F60\u4E5F\u53EF\u4EE5 /compact manual \u5BF9\u8F83\u65E9\u4E0A\u4E0B\u6587\u505A\u8BED\u4E49\u91CD\u5199\u3002"
+    );
+  }
+  return out;
+}
+function sanitizeCompactStatusText(value) {
+  return sanitizeDiagnosticText(redactCommonSecrets(value));
+}
+function collectLightHints(context) {
+  const latest = context.cache.history.at(-1);
+  const hints = [];
+  if (latest?.hitRate !== null && latest?.hitRate !== void 0 && latest.hitRate < context.cache.config.warnBelowHitRate) {
+    hints.push(
+      createLightHint(
+        "cache-hit-low",
+        "info",
+        10,
+        context.language === "en-US" ? "Reuse became less effective in the latest turn" : "\u6700\u8FD1\u4E00\u8F6E\u590D\u7528\u6548\u679C\u53D8\u4F4E",
+        "/break-cache status"
+      )
+    );
+  }
+  if ((latest?.inputTokens ?? 0) > 96e3) {
+    hints.push(
+      createLightHint(
+        "context-long",
+        "info",
+        4,
+        context.language === "en-US" ? "This conversation is getting long; compact only if it starts feeling slow" : "\u8FD9\u8F6E\u5BF9\u8BDD\u8F83\u957F\uFF1B\u5982\u679C\u5F00\u59CB\u53D8\u6162\uFF0C\u518D\u6309\u9700\u538B\u7F29",
+        "/compact"
+      )
+    );
+  }
+  if (latest?.cacheWriteTokensSource === "zero_reported" && latest.cacheReadTokens > 0) {
+    hints.push(
+      createLightHint(
+        "cache-zero-create-with-read",
+        "info",
+        2,
+        context.language === "en-US" ? "Usage numbers may need checking before cost claims" : "\u8981\u4E0B\u6210\u672C\u7ED3\u8BBA\u524D\uFF0C\u5EFA\u8BAE\u5148\u6838\u5BF9\u7528\u91CF\u53E3\u5F84",
+        "/usage"
+      )
+    );
+  }
+  const changedKeys = latest?.freshness.changedKeys ?? [];
+  if (changedKeys.some(
+    (key) => ["systemPromptHash", "toolSchemaHash", "mcpToolListHash"].includes(key)
+  )) {
+    hints.push(
+      createLightHint(
+        "freshness-changed",
+        "warning",
+        8,
+        context.language === "en-US" ? "Project context changed; refresh reuse data when results look stale" : "\u9879\u76EE\u4E0A\u4E0B\u6587\u6709\u53D8\u5316\uFF1B\u7ED3\u679C\u50CF\u65E7\u4FE1\u606F\u65F6\u518D\u5237\u65B0\u590D\u7528\u6570\u636E",
+        "/cache warmup"
+      )
+    );
+  }
+  return hints;
+}
+function createLightHint(dedupeKey, severity, priority, message, suggestedCommand) {
+  return {
+    id: randomUUID(),
+    severity,
+    priority,
+    message,
+    suggestedCommand,
+    dedupeKey,
+    cooldownMs: DEFAULT_LIGHT_HINT_COOLDOWN_MS
+  };
+}
+function writeLightHints(_output, context) {
+  if (context.cache.config.hintsMuted) {
+    return;
+  }
+  const now = Date.now();
+  const visibleHints = collectLightHints(context).filter((hint) => now - (context.cache.hintLastShownAt[hint.dedupeKey] ?? 0) >= hint.cooldownMs).sort((a, b) => b.priority - a.priority).slice(0, MAX_LIGHT_HINTS_PER_TURN);
+  if (visibleHints.length === 0) return;
+  if (!context.notifications) context.notifications = [];
+  for (const hint of visibleHints) {
+    context.cache.hintLastShownAt[hint.dedupeKey] = now;
+    const text = formatPlainLightHint(hint, context.language);
+    context.notifications.push({
+      key: `lighthint:${hint.dedupeKey}`,
+      text,
+      priority: hint.severity === "warning" ? "medium" : "low",
+      timeoutMs: 5e3,
+      createdAt: now,
+      tone: hint.severity === "warning" ? "warning" : "dim"
+    });
+  }
+}
+function formatPlainLightHint(hint, language) {
+  const isEn = language === "en-US";
+  switch (hint.dedupeKey) {
+    case "cache-hit-low":
+      return isEn ? "Cache reuse dipped a bit; the next response may be slower." : "\u6700\u8FD1\u7F13\u5B58\u590D\u7528\u53D8\u4F4E\uFF0C\u540E\u7EED\u54CD\u5E94\u53EF\u80FD\u4F1A\u6162\u4E00\u70B9\u3002";
+    case "context-long":
+      return isEn ? "This conversation is getting long; compact only if it starts feeling slow." : "\u8FD9\u8F6E\u5BF9\u8BDD\u8F83\u957F\uFF1B\u5982\u679C\u5F00\u59CB\u53D8\u6162\uFF0C\u518D\u6309\u9700\u538B\u7F29\u3002";
+    case "cache-zero-create-with-read":
+      return isEn ? "Usage numbers may need a quick check before drawing cost conclusions." : "\u7528\u91CF\u6570\u636E\u53EF\u80FD\u9700\u8981\u590D\u6838\u540E\u518D\u4E0B\u7ED3\u8BBA\u3002";
+    case "freshness-changed":
+      return isEn ? "Project context changed; refresh reuse data when results look stale." : "\u9879\u76EE\u4E0A\u4E0B\u6587\u6709\u53D8\u5316\uFF1B\u7ED3\u679C\u50CF\u65E7\u4FE1\u606F\u65F6\u518D\u5237\u65B0\u3002";
+    default:
+      return hint.message;
+  }
+}
+function writeLightHintsForTest(output, context) {
+  writeLightHints(output, context);
+}
+
+export {
+  buildCacheStatusPanel,
+  formatCacheLog,
+  formatCacheStatus,
+  formatWorkspaceSnapshotLiteStatus,
+  formatCompactStatus,
+  collectLightHints,
+  createLightHint,
+  writeLightHints,
+  formatPlainLightHint,
+  writeLightHintsForTest
+};