@linghun/tui 0.1.0

package/dist/chunk-WVAQYKGL.js

@@ -0,0 +1,269 @@
+import {
+  diffFreshness
+} from "./chunk-4T5DJW54.js";
+
+// src/break-cache-runtime.ts
+import { randomUUID } from "crypto";
+import { existsSync, readFileSync } from "fs";
+import { appendFile, mkdir, readFile, rm, writeFile } from "fs/promises";
+import { join } from "path";
+import { formatDiagnosticError, isNodeErrorWithCode } from "@linghun/shared";
+var BREAK_CACHE_ONCE_FILENAME = ".break-cache-once";
+var BREAK_CACHE_ALWAYS_FILENAME = ".break-cache-always";
+var BREAK_CACHE_EVENTS_FILENAME = "break-cache-events.jsonl";
+var BREAK_CACHE_EVENTS_MAX_LINES = 200;
+var BREAK_CACHE_EVENTS_TRIM_BATCH = 25;
+var breakCacheEventLineCounts = /* @__PURE__ */ new Map();
+function getBreakCacheDir(context) {
+  return join(context.projectPath, ".linghun");
+}
+function getBreakCacheOncePath(context) {
+  return join(getBreakCacheDir(context), BREAK_CACHE_ONCE_FILENAME);
+}
+function getBreakCacheAlwaysPath(context) {
+  return join(getBreakCacheDir(context), BREAK_CACHE_ALWAYS_FILENAME);
+}
+function getBreakCacheEventsPath(context) {
+  return join(getBreakCacheDir(context), BREAK_CACHE_EVENTS_FILENAME);
+}
+function readBreakCacheMarkerSync(context) {
+  try {
+    const alwaysPath = getBreakCacheAlwaysPath(context);
+    if (existsSync(alwaysPath)) {
+      const nonce = readFileSync(alwaysPath, "utf8").trim();
+      return { mode: "always", nonce: nonce || void 0 };
+    }
+    const oncePath = getBreakCacheOncePath(context);
+    if (existsSync(oncePath)) {
+      const nonce = readFileSync(oncePath, "utf8").trim();
+      return { mode: "once", nonce: nonce || void 0 };
+    }
+  } catch (error) {
+    logBreakCacheWarning(context, `read_marker_failed reason=${formatDiagnosticError(error)}`);
+  }
+  return { mode: "off" };
+}
+function readRecentBreakCacheEventsSync(context, limit) {
+  try {
+    const path = getBreakCacheEventsPath(context);
+    if (!existsSync(path)) return [];
+    const raw = readFileSync(path, "utf8");
+    const lines = raw.split(/\r?\n/).filter((line) => line.length > 0);
+    const recent = lines.slice(-Math.max(1, limit));
+    const events = [];
+    for (const line of recent) {
+      try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed.action === "string" && typeof parsed.createdAt === "string") {
+          events.push({ action: parsed.action, createdAt: parsed.createdAt });
+        }
+      } catch (error) {
+        logBreakCacheWarning(
+          context,
+          `read_events_parse_failed reason=${formatDiagnosticError(error)}`
+        );
+      }
+    }
+    return events;
+  } catch (error) {
+    if (!isNodeErrorWithCode(error, "ENOENT")) {
+      logBreakCacheWarning(context, `read_events_failed reason=${formatDiagnosticError(error)}`);
+    }
+    return [];
+  }
+}
+async function appendBreakCacheEvent(context, action) {
+  try {
+    await mkdir(getBreakCacheDir(context), { recursive: true });
+    const path = getBreakCacheEventsPath(context);
+    const currentCount = await getBreakCacheEventLineCount(path);
+    const event = { action, createdAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await appendFile(path, `${JSON.stringify(event)}
+`, "utf8");
+    breakCacheEventLineCounts.set(path, currentCount + 1);
+    await truncateBreakCacheEventsIfNeeded(path);
+  } catch (error) {
+    await appendRuntimeWarning(
+      context,
+      `break_cache_event_write_failed reason=${formatDiagnosticError(error)}`
+    );
+  }
+}
+async function getBreakCacheEventLineCount(path) {
+  const cached = breakCacheEventLineCounts.get(path);
+  if (typeof cached === "number") {
+    return cached;
+  }
+  const raw = await readFile(path, "utf8").catch((error) => {
+    if (!isNodeErrorWithCode(error, "ENOENT")) {
+      process.stderr.write(
+        `[linghun] break_cache_event_count_read_failed path=${path} reason=${formatDiagnosticError(error)}
+`
+      );
+    }
+    return "";
+  });
+  const count = raw.split(/\r?\n/).filter((line) => line.length > 0).length;
+  breakCacheEventLineCounts.set(path, count);
+  return count;
+}
+async function truncateBreakCacheEventsIfNeeded(path) {
+  const currentCount = breakCacheEventLineCounts.get(path) ?? 0;
+  if (currentCount < BREAK_CACHE_EVENTS_MAX_LINES + BREAK_CACHE_EVENTS_TRIM_BATCH) {
+    return;
+  }
+  const raw = await readFile(path, "utf8").catch((error) => {
+    process.stderr.write(
+      `[linghun] break_cache_event_truncate_read_failed path=${path} reason=${formatDiagnosticError(error)}
+`
+    );
+    return "";
+  });
+  const lines = raw.split(/\r?\n/).filter((line) => line.length > 0);
+  if (lines.length <= BREAK_CACHE_EVENTS_MAX_LINES) {
+    breakCacheEventLineCounts.set(path, lines.length);
+    return;
+  }
+  const trimmed = lines.slice(-BREAK_CACHE_EVENTS_MAX_LINES).join("\n");
+  await writeFile(path, `${trimmed}
+`, "utf8");
+  breakCacheEventLineCounts.set(path, BREAK_CACHE_EVENTS_MAX_LINES);
+}
+async function writeBreakCacheMarker(context, mode, nonce) {
+  await mkdir(getBreakCacheDir(context), { recursive: true });
+  const path = mode === "once" ? getBreakCacheOncePath(context) : getBreakCacheAlwaysPath(context);
+  await writeFile(path, nonce, "utf8");
+}
+async function clearBreakCacheMarker(context, mode) {
+  const targets = [];
+  if (mode === "once" || mode === "all") targets.push(getBreakCacheOncePath(context));
+  if (mode === "always" || mode === "all") targets.push(getBreakCacheAlwaysPath(context));
+  for (const target of targets) {
+    try {
+      if (existsSync(target)) {
+        await rm(target, { force: true });
+      }
+    } catch (error) {
+      await appendRuntimeWarning(
+        context,
+        `break_cache_marker_clear_failed path=${target} reason=${formatDiagnosticError(error)}`
+      );
+    }
+  }
+}
+function makeFakeContextForPath(projectPath) {
+  return { projectPath };
+}
+var breakCacheTestHooks = {
+  writeMarker: (projectPath, mode, nonce) => writeBreakCacheMarker(makeFakeContextForPath(projectPath), mode, nonce),
+  clearMarker: (projectPath, mode) => clearBreakCacheMarker(makeFakeContextForPath(projectPath), mode),
+  readMarker: (projectPath) => readBreakCacheMarkerSync(makeFakeContextForPath(projectPath)),
+  consumeNonce: (projectPath) => consumeBreakCacheNonceForRequest(makeFakeContextForPath(projectPath)),
+  appendEvent: (projectPath, action) => appendBreakCacheEvent(makeFakeContextForPath(projectPath), action),
+  readRecentEvents: (projectPath, limit) => readRecentBreakCacheEventsSync(makeFakeContextForPath(projectPath), limit),
+  buildPromptCacheFields: async (projectPath, enabled, systemTtl) => {
+    if (!enabled) return {};
+    const nonce = await consumeBreakCacheNonceForRequest(makeFakeContextForPath(projectPath));
+    return {
+      promptCacheEnabled: true,
+      ...systemTtl === "1h" ? { promptCacheTtl: "1h" } : {},
+      ...nonce ? { cacheBreakNonce: nonce } : {}
+    };
+  },
+  paths: (projectPath) => {
+    const ctx = makeFakeContextForPath(projectPath);
+    return {
+      onceMarker: getBreakCacheOncePath(ctx),
+      alwaysMarker: getBreakCacheAlwaysPath(ctx),
+      eventsLog: getBreakCacheEventsPath(ctx)
+    };
+  },
+  eventsMaxLines: BREAK_CACHE_EVENTS_MAX_LINES
+};
+async function consumeBreakCacheNonceForRequest(context) {
+  const marker = readBreakCacheMarkerSync(context);
+  if (marker.mode === "off") return void 0;
+  const nonce = marker.nonce && marker.nonce.length > 0 ? marker.nonce : randomUUID();
+  if (marker.mode === "once") {
+    try {
+      await rm(getBreakCacheOncePath(context), { force: true });
+    } catch (error) {
+      await appendRuntimeWarning(
+        context,
+        `break_cache_once_consume_failed reason=${formatDiagnosticError(error)}`
+      );
+    }
+    await appendBreakCacheEvent(context, "once_consumed");
+  }
+  return nonce;
+}
+function logBreakCacheWarning(context, message) {
+  process.stderr.write(`[linghun] break_cache_warning project=${context.projectPath} ${message}
+`);
+}
+async function appendRuntimeWarning(context, message) {
+  if (!context.sessionId) {
+    logBreakCacheWarning(context, message);
+    return;
+  }
+  try {
+    await context.store.appendEvent(context.sessionId, {
+      type: "system_event",
+      id: randomUUID(),
+      level: "warning",
+      message,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  } catch (error) {
+    logBreakCacheWarning(
+      context,
+      `${message}; warning_write_failed=${formatDiagnosticError(error)}`
+    );
+  }
+}
+async function buildPromptCacheRequestFields(context) {
+  const config = context.config.promptCache;
+  if (!config.enabled) return {};
+  const nonce = await consumeBreakCacheNonceForRequest(context);
+  return {
+    promptCacheEnabled: true,
+    ...config.systemTtl === "1h" ? { promptCacheTtl: "1h" } : {},
+    ...nonce ? { cacheBreakNonce: nonce } : {}
+  };
+}
+function formatBreakCacheStatus(context, current) {
+  const changed = diffFreshness(context.cache.lastFreshness, current);
+  const keys = changed.length > 0 ? changed : context.cache.lastFreshness?.changedKeys.length ? context.cache.lastFreshness.changedKeys : context.cache.history.at(-1)?.freshness.changedKeys ?? [];
+  const marker = readBreakCacheMarkerSync(context);
+  const recentEvents = readRecentBreakCacheEventsSync(context, 3);
+  return [
+    "Break-cache status",
+    `- systemPromptHash: ${current.systemPromptHash}`,
+    `- toolSchemaHash: ${current.toolSchemaHash}`,
+    `- mcpToolListHash: ${current.mcpToolListHash}`,
+    `- modelProviderHash: ${current.modelProviderHash}`,
+    `- reasoningEffortHash: ${current.reasoningEffortHash ?? "-"}`,
+    `- projectRulesHash: ${current.projectRulesHash ?? "-"}`,
+    `- memoryHash: ${current.memoryHash ?? "-"}`,
+    `- compactHash: ${current.compactHash ?? "-"}`,
+    `- pluginListHash: ${current.pluginListHash ?? "-"}`,
+    `- endpointProfileHash: ${current.endpointProfileHash ?? "-"}`,
+    `- cacheControlHash: ${current.cacheControlHash ?? "-"}`,
+    `- cacheTtlHash: ${current.cacheTtlHash ?? "-"}`,
+    `- prompt cache: enabled ${context.config.promptCache.enabled ? "yes" : "no"}; system ttl ${context.config.promptCache.systemTtl}`,
+    `- mode: ${marker.mode}${marker.nonce ? `; nonce ${marker.nonce.slice(0, 8)}\u2026` : ""}${marker.mode === "always" ? "\uFF08\u56FA\u5B9A break-cache namespace\uFF1B\u4E0D\u4F1A\u6BCF\u6B21\u8BF7\u6C42\u90FD\u7834\u574F\u7F13\u5B58\uFF09" : ""}`,
+    `- recent break-cache events: ${recentEvents.length === 0 ? "none" : recentEvents.map((event) => `${event.action}@${event.createdAt}`).join("; ")}`,
+    `- changed keys: ${keys.length > 0 ? keys.join(", ") : "none"}`,
+    "- usage: /break-cache status | once | always | off | --clear\uFF1Bmarker \u4E0E event \u4EC5\u8BB0\u5F55\u52A8\u4F5C\uFF0C\u4E0D\u8BB0\u5F55 prompt/key/raw request/response\u3002always=\u56FA\u5B9A nonce \u5207\u5230\u65B0 cache namespace\uFF08stable nonce\uFF09\uFF0C\u4E0D\u662F\u6BCF\u6B21\u8BF7\u6C42\u90FD\u7834\u574F\u7F13\u5B58\u3002",
+    "- suggestion: \u5982 system prompt / tool schema / MCP list / model/provider / memory / compact / plugin list / endpoint profile / cacheControl / cacheTtl \u53D8\u5316\uFF0C\u53EF\u8FD0\u884C /cache warmup \u6216 /cache refresh\uFF1B\u4E0D\u4F1A\u66FF\u4F60\u81EA\u52A8\u6267\u884C\u3002"
+  ].join("\n");
+}
+
+export {
+  appendBreakCacheEvent,
+  writeBreakCacheMarker,
+  clearBreakCacheMarker,
+  breakCacheTestHooks,
+  buildPromptCacheRequestFields,
+  formatBreakCacheStatus
+};

package/dist/chunk-X7A22JHP.js

@@ -0,0 +1,106 @@
+import {
+  selectActiveLessons
+} from "./chunk-GDQQNPBP.js";
+
+// src/failure-learning-presenter.ts
+var CATEGORY_LABEL_ZH = {
+  provider_failure: "\u6A21\u578B\u8BF7\u6C42\u5931\u8D25",
+  tool_failure: "\u5DE5\u5177\u5931\u8D25",
+  verification_failure: "\u9A8C\u8BC1\u5931\u8D25",
+  git_operation_failure: "Git \u64CD\u4F5C\u5931\u8D25",
+  final_gate_downgrade: "\u6700\u7EC8\u56DE\u7B54\u964D\u7EA7",
+  report_guard: "\u62A5\u544A\u5B88\u536B\u672A\u6EE1\u8DB3",
+  resource_cap: "\u5E76\u53D1\u4E0A\u9650\u62D2\u7EDD"
+};
+var CATEGORY_LABEL_EN = {
+  provider_failure: "provider request failure",
+  tool_failure: "tool failure",
+  verification_failure: "verification failure",
+  git_operation_failure: "git operation failure",
+  final_gate_downgrade: "final answer downgrade",
+  report_guard: "report guard unmet",
+  resource_cap: "concurrency cap denied"
+};
+function categoryLabel(record, language) {
+  return language === "en-US" ? CATEGORY_LABEL_EN[record.category] : CATEGORY_LABEL_ZH[record.category];
+}
+function buildFailureLearningPanel(state, language) {
+  const isEn = language === "en-US";
+  const active = state.records.filter((r) => r.status === "active");
+  const resolved = state.records.filter((r) => r.status === "resolved").length;
+  const ignored = state.records.filter((r) => r.status === "ignored").length;
+  const lessons = selectActiveLessons(state);
+  const degraded = state.degradedWarnings.length;
+  const summary = [
+    isEn ? `Failure learning \xB7 active ${active.length} \xB7 resolved ${resolved} \xB7 ignored ${ignored}${degraded > 0 ? ` \xB7 degraded ${degraded}` : ""}` : `\u5931\u8D25\u5B66\u4E60 \xB7 \u6D3B\u8DC3 ${active.length} \xB7 \u5DF2\u89E3\u51B3 ${resolved} \xB7 \u5DF2\u5FFD\u7565 ${ignored}${degraded > 0 ? ` \xB7 \u964D\u7EA7 ${degraded}` : ""}`
+  ];
+  if (active.length === 0) {
+    summary.push(
+      isEn ? "No active lessons from real failures yet." : "\u6682\u65E0\u6765\u81EA\u771F\u5B9E\u5931\u8D25\u7684\u6D3B\u8DC3\u6559\u8BAD\u3002"
+    );
+  } else {
+    for (const r of lessons.slice(0, 3)) {
+      summary.push(
+        isEn ? `[${categoryLabel(r, language)} \xD7${r.count}] avoid: ${r.avoidNextTime}` : `[${categoryLabel(r, language)} \xD7${r.count}] \u4E0B\u6B21\u907F\u514D\uFF1A${r.avoidNextTime}`
+      );
+    }
+    summary.push(
+      isEn ? "These are historical risk hints, not proof anything is fixed." : "\u8FD9\u4E9B\u662F\u5386\u53F2\u98CE\u9669\u63D0\u793A\uFF0C\u4E0D\u4EE3\u8868\u95EE\u9898\u5DF2\u4FEE\u590D\u3002"
+    );
+  }
+  const actions = [];
+  if (active.length > 0) {
+    actions.push("/failures resolve <id>");
+    actions.push("/failures ignore <id>");
+  }
+  return {
+    title: "/failures",
+    tone: active.length > 0 ? "warning" : "neutral",
+    summary,
+    actions,
+    detailsText: formatFailureLearningDetails(state, language)
+  };
+}
+function formatFailureLearningDetails(state, language) {
+  const isEn = language === "en-US";
+  const lines = [isEn ? "Failure learning (fact-based)" : "\u5931\u8D25\u5B66\u4E60\uFF08\u57FA\u4E8E\u4E8B\u5B9E\uFF09"];
+  if (state.degradedWarnings.length > 0) {
+    lines.push(isEn ? "- degraded warnings:" : "- \u964D\u7EA7\u8B66\u544A\uFF1A");
+    for (const warning of state.degradedWarnings) {
+      lines.push(`  - ${warning}`);
+    }
+  }
+  const ordered = [...state.records].sort((a, b) => {
+    if (a.status !== b.status) {
+      const rank = (s) => s === "active" ? 0 : s === "ignored" ? 1 : 2;
+      return rank(a.status) - rank(b.status);
+    }
+    return b.lastSeen.localeCompare(a.lastSeen);
+  });
+  if (ordered.length === 0) {
+    lines.push(
+      isEn ? "- none; lessons are only recorded from real failure events (provider/tool/verification/git/final-gate/report-guard/resource-cap)." : "- \u65E0\uFF1B\u6559\u8BAD\u53EA\u6765\u81EA\u771F\u5B9E\u5931\u8D25\u4E8B\u4EF6\uFF08provider/tool/verification/git/final-gate/report-guard/resource-cap\uFF09\u3002"
+    );
+    return lines.join("\n");
+  }
+  for (const r of ordered.slice(0, 20)) {
+    lines.push(
+      `- ${r.id} [${categoryLabel(r, language)}] ${r.status} \xD7${r.count}${r.relatedTarget ? ` (${r.relatedTarget})` : ""}`
+    );
+    lines.push(`    ${isEn ? "summary" : "\u6458\u8981"}: ${r.failureSummary}`);
+    lines.push(`    ${isEn ? "root cause (inferred)" : "\u6839\u56E0(\u63A8\u65AD)"}: ${r.rootCauseGuess}`);
+    lines.push(`    ${isEn ? "avoid next time" : "\u4E0B\u6B21\u907F\u514D"}: ${r.avoidNextTime}`);
+    lines.push(
+      `    ${isEn ? "severity" : "\u4E25\u91CD\u5EA6"} ${r.severity}; first seen ${r.createdAt}; last seen ${r.lastSeen}; source ${r.sourceRef}`
+    );
+  }
+  lines.push(
+    isEn ? "Note: inferred root causes are model guesses from evidence; treat as risk hints, not confirmed fixes. Use /failures resolve <id> after you actually fix it; /failures ignore <id> to mute." : "\u8BF4\u660E\uFF1A\u6839\u56E0\u4E3A\u57FA\u4E8E\u8BC1\u636E\u7684\u63A8\u65AD\uFF0C\u4E0D\u662F\u786E\u8BA4\u4E8B\u5B9E\uFF1B\u5F53\u4F5C\u98CE\u9669\u63D0\u793A\uFF0C\u4E0D\u4EE3\u8868\u5DF2\u4FEE\u590D\u3002\u771F\u6B63\u4FEE\u590D\u540E\u7528 /failures resolve <id>\uFF1B\u4E0D\u518D\u5173\u6CE8\u7528 /failures ignore <id>\u3002"
+  );
+  return lines.join("\n");
+}
+
+export {
+  buildFailureLearningPanel,
+  formatFailureLearningDetails
+};

package/dist/chunk-XFPNU42I.js

@@ -0,0 +1,59 @@
+// src/shell/stdout-flush-barrier.ts
+async function flushStdout(stdout) {
+  if (!stdout) return;
+  if (!stdout.isTTY) return;
+  if (stdout.destroyed || stdout.closed) return;
+  if (stdout.writableLength === 0) return;
+  return new Promise((resolve) => {
+    const timeout = setTimeout(() => {
+      stdout.off("drain", onDrain);
+      resolve();
+    }, 100);
+    const onDrain = () => {
+      clearTimeout(timeout);
+      resolve();
+    };
+    stdout.once("drain", onDrain);
+    if (stdout.writable && !stdout.destroyed) {
+      stdout.write("", (error) => {
+        if (error) {
+          clearTimeout(timeout);
+          stdout.off("drain", onDrain);
+          resolve();
+        }
+      });
+    } else {
+      clearTimeout(timeout);
+      stdout.off("drain", onDrain);
+      resolve();
+    }
+  });
+}
+async function writeSGRResetAndFlush(stdout) {
+  if (!stdout || stdout.destroyed || stdout.closed) return;
+  if (stdout.isTTY === false) return;
+  try {
+    const resetSequence = "\x1B[0m\x1B[?25h";
+    if (stdout.writable && !stdout.destroyed) {
+      stdout.write(resetSequence);
+    }
+    await flushStdout(stdout);
+  } catch {
+  }
+}
+function drainStdin(stdin) {
+  if (!stdin || stdin.destroyed || stdin.closed) return;
+  if (!stdin.readable || stdin.readableLength === 0) return;
+  try {
+    while (stdin.readable && stdin.readableLength > 0) {
+      stdin.read();
+    }
+  } catch {
+  }
+}
+
+export {
+  flushStdout,
+  writeSGRResetAndFlush,
+  drainStdin
+};

package/dist/chunk-YH6UIHNF.js

@@ -0,0 +1,161 @@
+import {
+  createShellTheme
+} from "./chunk-GC55DMZV.js";
+import {
+  fitText
+} from "./chunk-APJIC2O5.js";
+
+// src/shell/components/SessionsPanel.tsx
+import { Box, Text } from "@linghun/ink-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+var HINT_TEXT = {
+  "zh-CN": {
+    title: "/sessions",
+    nav: "\u2191\u2193 \u9009\u62E9 \xB7 Enter \u6062\u590D \xB7 Esc \u5173\u95ED \xB7 / \u641C\u7D22 \xB7 Ctrl+V \u9884\u89C8",
+    empty: "\uFF08\u6682\u65E0\u53EF\u6062\u590D\u7684\u4F1A\u8BDD\uFF09",
+    noMatch: "\uFF08\u65E0\u5339\u914D\u7ED3\u679C\uFF09",
+    current: "[\u5F53\u524D]",
+    currentDisabled: "[\u5F53\u524D \xB7 \u4E0D\u53EF\u6062\u590D]",
+    today: "\u4ECA\u5929",
+    yesterday: "\u6628\u5929",
+    older: "\u66F4\u65E9",
+    search: "\u641C\u7D22\uFF1A",
+    previewTitle: "\u9884\u89C8 \xB7 Ctrl+V",
+    previewNav: "Esc \u8FD4\u56DE \xB7 Enter \u6062\u590D"
+  },
+  "en-US": {
+    title: "/sessions",
+    nav: "\u2191\u2193 select \xB7 Enter resume \xB7 Esc close \xB7 / search \xB7 Ctrl+V preview",
+    empty: "(no sessions to resume)",
+    noMatch: "(no matches)",
+    current: "[current]",
+    currentDisabled: "[current \xB7 cannot resume]",
+    today: "Today",
+    yesterday: "Yesterday",
+    older: "Older",
+    search: "Search: ",
+    previewTitle: "Preview \xB7 Ctrl+V",
+    previewNav: "Esc back \xB7 Enter resume"
+  }
+};
+function SessionsPanel({
+  panel,
+  controller: _controller,
+  width,
+  noColor,
+  language
+}) {
+  const theme = createShellTheme(noColor);
+  const hint = HINT_TEXT[language] ?? HINT_TEXT["zh-CN"];
+  const cardWidth = Math.min(width, 84);
+  const innerWidth = Math.max(20, cardWidth - 4);
+  const getTimeGroup = (iso) => {
+    try {
+      const ms = new Date(iso).getTime();
+      if (Number.isNaN(ms)) return "older";
+      const now = /* @__PURE__ */ new Date();
+      const startOfDay = (d) => new Date(d.getFullYear(), d.getMonth(), d.getDate()).getTime();
+      const dayDiff = Math.round((startOfDay(now) - startOfDay(new Date(ms))) / 864e5);
+      if (dayDiff <= 0) return "today";
+      if (dayDiff === 1) return "yesterday";
+      return "older";
+    } catch {
+      return "older";
+    }
+  };
+  const groupLabel = (g) => {
+    if (g === "today") return hint.today;
+    if (g === "yesterday") return hint.yesterday;
+    return hint.older;
+  };
+  const query = panel.searchQuery?.trim() ?? "";
+  const filtered = query ? panel.entries.filter(
+    (e) => e.title.toLowerCase().includes(query.toLowerCase()) || e.id.toLowerCase().includes(query.toLowerCase())
+  ) : panel.entries;
+  if (panel.mode === "preview") {
+    const entry = panel.previewEntryId ? panel.entries.find((e) => e.id === panel.previewEntryId) : void 0;
+    if (!entry) {
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, marginTop: 1, width: cardWidth, children: [
+        /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: "\u2500".repeat(Math.min(cardWidth, 80)) }),
+        /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: fitText(hint.noMatch, innerWidth) })
+      ] });
+    }
+    const ts = formatSessionTime(entry.updatedAt, language);
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, marginTop: 1, width: cardWidth, children: [
+      /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: "\u2500".repeat(Math.min(cardWidth, 80)) }),
+      /* @__PURE__ */ jsx(Text, { bold: true, color: theme.accent, children: fitText(`${hint.previewTitle}: ${entry.title}`, innerWidth) }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, color: theme.muted, children: fitText(
+        `${ts} \xB7 ${entry.messageCount} ${language === "en-US" ? "msgs" : "\u6761"} \xB7 ${entry.id.slice(0, 10)}`,
+        innerWidth
+      ) }),
+      /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { dimColor: true, color: theme.muted, children: fitText(hint.previewNav, innerWidth) }) })
+    ] });
+  }
+  const searchActive = panel.mode === "search";
+  const renderEntry = (entry, idx) => {
+    const active = idx === panel.cursor;
+    const currentMark = entry.isCurrent ? ` ${hint.currentDisabled}` : "";
+    const titleLine = `${active ? "\u25B8 " : "  "}${entry.title}${currentMark}`;
+    const ts = formatSessionTime(entry.updatedAt, language);
+    const metaLine = `   ${ts} \xB7 ${entry.messageCount} ${language === "en-US" ? "msgs" : "\u6761"}`;
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(
+        Text,
+        {
+          color: entry.isCurrent ? theme.dim ?? theme.muted : active ? theme.accent : void 0,
+          bold: active && !entry.isCurrent,
+          dimColor: entry.isCurrent,
+          children: fitText(titleLine, innerWidth)
+        }
+      ),
+      /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: fitText(metaLine, innerWidth) })
+    ] }, entry.id);
+  };
+  const renderList = () => {
+    if (filtered.length === 0) {
+      return /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: fitText(query ? hint.noMatch : hint.empty, innerWidth) });
+    }
+    let lastGroup = "";
+    return filtered.map((entry, idx) => {
+      const group = getTimeGroup(entry.updatedAt);
+      const showHeader = group !== lastGroup;
+      lastGroup = group;
+      return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+        showHeader ? /* @__PURE__ */ jsx(Box, { marginTop: 1, children: /* @__PURE__ */ jsx(Text, { bold: true, color: theme.muted, children: groupLabel(group) }) }) : null,
+        renderEntry(entry, idx)
+      ] }, entry.id);
+    });
+  };
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", paddingX: 1, marginTop: 1, width: cardWidth, children: [
+    /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: "\u2500".repeat(Math.min(cardWidth, 80)) }),
+    /* @__PURE__ */ jsx(Text, { color: theme.accent, bold: true, children: fitText(hint.title, innerWidth) }),
+    searchActive ? /* @__PURE__ */ jsxs(Box, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx(Text, { dimColor: true, color: theme.muted, children: hint.search }),
+      /* @__PURE__ */ jsx(Text, { children: query }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "\u2588" })
+    ] }) : /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: fitText(
+      filtered.length < panel.entries.length ? `${hint.nav} \xB7 \u8FC7\u6EE4\u540E ${filtered.length}/${panel.entries.length}` : hint.nav,
+      innerWidth
+    ) }),
+    renderList()
+  ] });
+}
+function formatSessionTime(iso, language) {
+  try {
+    const t = new Date(iso).getTime();
+    const ms = Date.now() - t;
+    const min = Math.floor(ms / 6e4);
+    if (min < 1) return language === "en-US" ? "now" : "\u521A\u521A";
+    if (min < 60) return language === "en-US" ? `${min}m ago` : `${min} \u5206\u949F\u524D`;
+    const hr = Math.floor(min / 60);
+    if (hr < 24) return language === "en-US" ? `${hr}h ago` : `${hr} \u5C0F\u65F6\u524D`;
+    const day = Math.floor(hr / 24);
+    return language === "en-US" ? `${day}d ago` : `${day} \u5929\u524D`;
+  } catch {
+    return iso;
+  }
+}
+
+export {
+  SessionsPanel
+};

package/dist/chunk-YPQFSFYK.js

@@ -0,0 +1,19 @@
+// src/prompt-stash.ts
+function createPromptStash() {
+  return { text: void 0 };
+}
+function toggleStash(stash, currentText) {
+  if (currentText.length > 0) {
+    return { stash: { text: currentText }, bufferText: "" };
+  }
+  if (stash.text !== void 0) {
+    const restored = stash.text;
+    return { stash: { text: void 0 }, bufferText: restored };
+  }
+  return { stash, bufferText: void 0 };
+}
+
+export {
+  createPromptStash,
+  toggleStash
+};