@linghun/tui 0.1.0

package/dist/chunk-LL7LBRDL.js

@@ -0,0 +1,60 @@
+// src/shell/hooks/useScrollRuntime.ts
+import { useCallback, useEffect, useRef } from "react";
+var SCROLL_QUANTUM = 10;
+var DRAIN_PER_FRAME = 5;
+var DRAIN_IDLE_THRESHOLD_MS = 100;
+var DRAIN_INTERVAL_MS = 16;
+function useScrollRuntime(dispatch) {
+  const pendingDeltaRef = useRef(0);
+  const lastDispatchedBinRef = useRef(0);
+  const drainLoopActiveRef = useRef(false);
+  const lastWheelTimeRef = useRef(0);
+  const timerIdRef = useRef(null);
+  const drainLoop = useCallback(() => {
+    const now = Date.now();
+    const pending = pendingDeltaRef.current;
+    if (pending === 0 && now - lastWheelTimeRef.current > DRAIN_IDLE_THRESHOLD_MS) {
+      drainLoopActiveRef.current = false;
+      timerIdRef.current = null;
+      return;
+    }
+    if (pending !== 0) {
+      const drainAmount = Math.min(Math.abs(pending), DRAIN_PER_FRAME);
+      const drained = pending > 0 ? drainAmount : -drainAmount;
+      pendingDeltaRef.current -= drained;
+      const currentBin = Math.floor(pendingDeltaRef.current / SCROLL_QUANTUM);
+      const prevBin = lastDispatchedBinRef.current;
+      if (currentBin !== prevBin) {
+        const binDelta = (prevBin - currentBin) * SCROLL_QUANTUM;
+        lastDispatchedBinRef.current = currentBin;
+        dispatch(binDelta);
+      }
+    }
+    timerIdRef.current = setTimeout(drainLoop, DRAIN_INTERVAL_MS);
+  }, [dispatch]);
+  const ensureDrainLoop = useCallback(() => {
+    if (!drainLoopActiveRef.current) {
+      drainLoopActiveRef.current = true;
+      timerIdRef.current = setTimeout(drainLoop, DRAIN_INTERVAL_MS);
+    }
+  }, [drainLoop]);
+  useEffect(() => {
+    return () => {
+      if (timerIdRef.current !== null) {
+        clearTimeout(timerIdRef.current);
+      }
+    };
+  }, []);
+  return useCallback(
+    (delta) => {
+      pendingDeltaRef.current += delta;
+      lastWheelTimeRef.current = Date.now();
+      ensureDrainLoop();
+    },
+    [ensureDrainLoop]
+  );
+}
+
+export {
+  useScrollRuntime
+};

package/dist/chunk-LQTVYUT3.js

@@ -0,0 +1,421 @@
+import {
+  normalizeMemoryStatus,
+  pathExists,
+  summarizeProjectRules
+} from "./chunk-QLRTQHTR.js";
+import {
+  MEMORY_LEARNING_STATE_FILE
+} from "./chunk-5H7RRF7C.js";
+import {
+  formatDisplayPath,
+  truncateDisplay
+} from "./chunk-OMZYPQVA.js";
+
+// src/tui-memory-runtime.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { join } from "path";
+import { resolveStoragePaths } from "@linghun/config";
+var MEMORY_PROMPT_TOP_K = 3;
+var MEMORY_PROMPT_ITEM_WIDTH = 180;
+var MEMORY_PROMPT_TOTAL_WIDTH = 720;
+var PROJECT_RULES_STATUS_WIDTH = 160;
+function createMemoryCandidate(scope, summary, source, sourceRefs) {
+  return {
+    id: randomUUID(),
+    scope,
+    status: "candidate",
+    summary: truncateDisplay(summary.replace(/\s+/g, " "), 240),
+    source,
+    sourceRefs: sourceRefs.slice(0, 6),
+    risk: "low",
+    inferred: false,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function parseMemoryCandidateArgs(args) {
+  const scopeIndex = args.findIndex((arg) => arg === "--scope");
+  const rawScope = scopeIndex >= 0 ? args[scopeIndex + 1] : void 0;
+  const scope = rawScope === "user" || rawScope === "session" || rawScope === "project" ? rawScope : "project";
+  const summary = args.filter((_, index) => scopeIndex < 0 || index !== scopeIndex && index !== scopeIndex + 1).join(" ").trim();
+  return { scope, summary };
+}
+async function writeMemoryRecord(candidate, context) {
+  if (candidate.scope === "session") {
+    return;
+  }
+  const directory = getMemoryDirectory(candidate.scope, context);
+  await mkdir(directory, { recursive: true });
+  const path = join(directory, `${candidate.id}.json`);
+  await writeFile(path, `${JSON.stringify(candidate, null, 2)}
+`, "utf8");
+}
+async function writeMemoryLearningMode(context) {
+  const userDir = resolveStoragePaths(context.config, context.projectPath).memoryUser;
+  await mkdir(userDir, { recursive: true });
+  await writeFile(
+    join(userDir, MEMORY_LEARNING_STATE_FILE),
+    `${JSON.stringify(
+      {
+        learningMode: context.memory.learningMode,
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      },
+      null,
+      2
+    )}
+`,
+    "utf8"
+  );
+  context.memory.userDir = userDir;
+  context.memory.learningModeSource = "persisted";
+}
+async function removeMemoryRecord(candidate, context) {
+  if (candidate.scope === "session") {
+    return;
+  }
+  const directory = getMemoryDirectory(candidate.scope, context);
+  await Promise.all([
+    rm(join(directory, `${candidate.id}.json`), { force: true }),
+    rm(join(directory, "candidates", `${candidate.id}.json`), { force: true })
+  ]);
+}
+function getMemoryDirectory(scope, context) {
+  if (scope === "project") return context.memory.projectDir;
+  if (scope === "user") return context.memory.userDir;
+  return context.memory.sessionDir;
+}
+function findMemoryRecord(memory, id) {
+  if (!id) return void 0;
+  return [
+    ...memory.candidates,
+    ...memory.accepted,
+    ...memory.rejected,
+    ...memory.disabled,
+    ...memory.retired
+  ].find((item) => item.id === id);
+}
+function removeMemoryFromState(memory, id) {
+  memory.candidates = memory.candidates.filter((item) => item.id !== id);
+  memory.accepted = memory.accepted.filter((item) => item.id !== id);
+  memory.rejected = memory.rejected.filter((item) => item.id !== id);
+  memory.disabled = memory.disabled.filter((item) => item.id !== id);
+  memory.retired = memory.retired.filter((item) => item.id !== id);
+}
+function formatMemoryScope(scope) {
+  if (scope === "project") return "\u9879\u76EE";
+  if (scope === "user") return "\u7528\u6237";
+  return "\u4F1A\u8BDD";
+}
+function formatProjectRulesContext(context) {
+  if (context.memory.projectRulesError) {
+    return "unreadable; \u53EF\u68C0\u67E5\u6587\u4EF6\u6743\u9650\u6216\u8FD0\u884C /memory storage \u5B9A\u4F4D\u8DEF\u5F84";
+  }
+  if (!context.memory.projectRulesExists) {
+    return "missing; \u53EF\u8FD0\u884C /memory init \u751F\u6210\u57FA\u7840\u6A21\u677F\uFF0C\u4E0D\u4F1A\u81EA\u52A8\u751F\u6210";
+  }
+  return truncateDisplay(context.memory.projectRulesSummary, PROJECT_RULES_STATUS_WIDTH);
+}
+function formatMemoryStatus(context) {
+  const injected = createControlledMemoryInjection(context);
+  const learningLabel = context.memory.learningMode === "active" ? "on" : "off";
+  const learningSource = context.memory.learningModeSource ?? "default";
+  return [
+    "Memory status",
+    `- LINGHUN.md: ${context.memory.projectRulesExists ? "found" : "missing"}; summary ${formatProjectRulesContext(context)}`,
+    `- review queue: candidates ${context.memory.candidates.length}; accepted ${context.memory.accepted.length}; disabled ${context.memory.disabled.length}; rejected ${context.memory.rejected.length}`,
+    `- auto learning: ${learningLabel}; auto extraction accepted for stable taxonomy memory; source ${learningSource}; uncertain content stays candidate-only`,
+    `- prompt injection: accepted-only topK ${MEMORY_PROMPT_TOP_K}; injected ${injected.items.length}; estimated tokens ${estimateMemoryTokens(injected.text)}; details /memory stats`,
+    "- next: /memory review to accept/reject; /memory disable <id> to pause accepted memory; /memory rollback <id> to re-enable",
+    `- lastHandoff: ${context.memory.lastHandoff ? context.memory.lastHandoff.createdAt : "none"}`,
+    context.memory.projectRulesError ? "- hint: LINGHUN.md \u8BFB\u53D6\u5931\u8D25\uFF1B\u53EF\u8FD0\u884C /memory storage \u5B9A\u4F4D\u8DEF\u5F84\uFF0C\u4E0D\u4F1A\u81EA\u52A8\u751F\u6210\u6216\u6253\u65AD\u8F93\u5165\u3002" : context.memory.projectRulesExists ? "- note: LINGHUN.md \u53EA\u663E\u793A\u622A\u65AD\u6458\u8981\uFF1B\u5B8C\u6574\u89C4\u5219\u4E0D\u5237\u4E3B\u5C4F\u3001\u4E0D\u6CE8\u5165\u5B8C\u6574\u804A\u5929\u3002" : "- hint: \u7F3A\u5C11 LINGHUN.md\u3002\u53EF\u8FD0\u884C /memory init \u751F\u6210\u57FA\u7840\u6A21\u677F\uFF1B\u4E0D\u4F1A\u6253\u65AD\u8F93\u5165\u3002"
+  ].join("\n");
+}
+function formatMemoryStorage(context) {
+  const paths = resolveStoragePaths(context.config, context.projectPath);
+  return [
+    "Memory storage",
+    `- project rules: ${formatDisplayPath(context.memory.projectRulesPath, context.projectPath)}`,
+    `- project memory: ${formatDisplayPath(paths.memoryProject, context.projectPath)}`,
+    `- user memory: ${formatDisplayPath(paths.memoryUser, context.projectPath)}`,
+    `- session memory/handoff: ${formatDisplayPath(paths.memorySession, context.projectPath)}`,
+    `- sessions: ${formatDisplayPath(paths.sessions, context.projectPath)}`,
+    `- logs: ${formatDisplayPath(paths.logs, context.projectPath)}`,
+    `- jobs: ${formatDisplayPath(paths.jobs, context.projectPath)}`,
+    `- cache: ${formatDisplayPath(paths.cache, context.projectPath)}`,
+    `- index metadata: ${formatDisplayPath(paths.index, context.projectPath)}`,
+    `- LINGHUN_DATA_DIR: ${process.env.LINGHUN_DATA_DIR ? formatDisplayPath(process.env.LINGHUN_DATA_DIR, context.projectPath) : "not set; default user data is under ~/.linghun/data"}`
+  ].join("\n");
+}
+function formatMemoryReview(context) {
+  const accepted = context.memory.accepted.slice(0, 5).map(
+    (item) => `- accepted ${item.id} [${item.scope}] ${truncateDisplay(item.summary, 96)}; disable /memory disable ${item.id}`
+  );
+  const disabled = context.memory.disabled.slice(0, 5).map(
+    (item) => `- disabled ${item.id} [${item.scope}] ${truncateDisplay(item.summary, 96)}; rollback /memory rollback ${item.id}; delete /memory delete ${item.id}`
+  );
+  if (context.memory.candidates.length === 0) {
+    return [
+      "Memory review\uFF1A\u6682\u65E0\u5019\u9009\u8BB0\u5FC6\uFF1B\u7A33\u5B9A taxonomy \u957F\u671F\u8BB0\u5FC6\u53EF\u7531 extraction runtime \u81EA\u52A8\u5199\u5165\u4E13\u7528 memory dir\u3002",
+      "\u6765\u6E90\u8FB9\u754C\uFF1A\u81EA\u52A8\u62BD\u53D6\u53EA\u4FDD\u5B58\u957F\u671F\u7A33\u5B9A\u4E8B\u5B9E\uFF1B/memory learn \u53EA\u770B bounded evidence/Todo/verification/handoff\uFF0C\u4E0D\u8BFB\u53D6\u5B8C\u6574\u804A\u5929\u3001\u5B8C\u6574\u65E5\u5FD7\u6216\u5B8C\u6574\u7D22\u5F15\u3002",
+      "\u4E0B\u4E00\u6B65\uFF1A\u9700\u8981\u624B\u52A8\u590D\u6838\u65F6\u7528 /memory candidate <\u77ED\u5C0F\u7A33\u5B9A\u6458\u8981> [--scope project|user|session] \u521B\u5EFA\u5019\u9009\uFF0C\u518D /memory accept\u3002",
+      ...accepted,
+      ...disabled,
+      "\u52A8\u4F5C\u533A\u522B\uFF1Aaccept=\u5199\u5165\u957F\u671F\u4E14\u53EF\u88AB topK \u6CE8\u5165\uFF1Breject=\u4E22\u5F03\u5019\u9009\uFF1Bdisable=\u6682\u505C\u5DF2\u63A5\u53D7\u6CE8\u5165\uFF1Brollback=\u91CD\u65B0\u542F\u7528\uFF1Bdelete=\u5220\u9664\u8BB0\u5F55\u3002"
+    ].join("\n");
+  }
+  return [
+    "Memory review\uFF08\u5019\u9009 \u2260 \u957F\u671F\u8BB0\u5FC6\uFF09",
+    ...context.memory.candidates.slice(0, 8).map(
+      (item) => `- candidate ${item.id} [${item.scope}] ${truncateDisplay(item.summary, 100)}; source ${truncateDisplay(item.source, 48)}; accept /memory accept ${item.id}; reject /memory reject ${item.id}`
+    ),
+    ...accepted,
+    ...disabled,
+    "\u52A8\u4F5C\u533A\u522B\uFF1Aaccept=\u5199\u5165\u957F\u671F\u4E14\u53EF\u88AB topK \u6CE8\u5165\uFF1Breject=\u4E22\u5F03\u5019\u9009\uFF1Bdisable=\u6682\u505C\u5DF2\u63A5\u53D7\u6CE8\u5165\uFF1Brollback=\u91CD\u65B0\u542F\u7528\uFF1Bdelete=\u5220\u9664\u8BB0\u5F55\u3002"
+  ].join("\n");
+}
+function formatMemoryStats(context) {
+  const injection = createControlledMemoryInjection(context);
+  const acceptedScopeCounts = countMemoryScopes(context.memory.accepted);
+  const candidateScopeCounts = countMemoryScopes(context.memory.candidates);
+  const learningLabel = context.memory.learningMode === "active" ? "on" : "off";
+  const lastRun = context.memory.lastLearningRun ? `${context.memory.lastLearningRun.trigger}; candidates ${context.memory.lastLearningRun.candidatesCreated}; accepted created ${context.memory.lastLearningRun.acceptedCreated ?? 0}; accepted updated ${context.memory.lastLearningRun.acceptedUpdated ?? 0}; model called ${context.memory.lastLearningRun.modelCalled ? "yes" : "no"}` : "none";
+  if (context.language === "en-US") {
+    return [
+      "Memory stats (controlled learning / cost guard)",
+      `- candidates ${context.memory.candidates.length}; accepted ${context.memory.accepted.length}; disabled ${context.memory.disabled.length}; rejected ${context.memory.rejected.length}`,
+      `- session scope: accepted ${acceptedScopeCounts.session}; current TuiContext only, not persisted across new sessions`,
+      `- project/user persistent scope: accepted ${acceptedScopeCounts.project + acceptedScopeCounts.user} (project ${acceptedScopeCounts.project}; user ${acceptedScopeCounts.user}); accepted-only topK prompt injection`,
+      `- candidate scope: project ${candidateScopeCounts.project}; user ${candidateScopeCounts.user}; session ${candidateScopeCounts.session}; candidates are not auto-accepted or injected`,
+      `- prompt injection: accepted-only topK ${MEMORY_PROMPT_TOP_K}; injected ${injection.items.length}; chars ${injection.text.length}; estimated tokens ${estimateMemoryTokens(injection.text)}`,
+      `- last learning run: ${lastRun}`,
+      `- auto learning: ${learningLabel}; stable taxonomy memory auto accepted; uncertain content stays candidate-only; toggle with /memory learn on|off`,
+      "- long-term write: auto extraction is limited to the dedicated memory dir; manual candidates still use /memory accept <id>; memory never bypasses ordinary Write/Edit permissions",
+      "- full candidates, transcripts, logs, and index dumps are not injected into the prompt"
+    ].join("\n");
+  }
+  return [
+    "Memory stats\uFF08\u53D7\u63A7\u5B66\u4E60 / \u6210\u672C\u5B88\u536B\uFF09",
+    `- \u5019\u9009 ${context.memory.candidates.length}\uFF1B\u5DF2\u63A5\u53D7 ${context.memory.accepted.length}\uFF1B\u5DF2\u7981\u7528 ${context.memory.disabled.length}\uFF1B\u5DF2\u62D2\u7EDD ${context.memory.rejected.length}`,
+    `- session-scope\uFF1A\u5DF2\u63A5\u53D7 ${acceptedScopeCounts.session}\uFF1B\u4EC5\u5F53\u524D TuiContext / \u5F53\u524D\u4F1A\u8BDD\u751F\u6548\uFF0C\u4E0D\u8DE8\u65B0\u4F1A\u8BDD\u6301\u4E45\u5316`,
+    `- project/user persistent scope\uFF1A\u5DF2\u63A5\u53D7 ${acceptedScopeCounts.project + acceptedScopeCounts.user}\uFF08project ${acceptedScopeCounts.project}\uFF1Buser ${acceptedScopeCounts.user}\uFF09\uFF1B\u4EC5 accepted-only topK \u6CE8\u5165 prompt`,
+    `- candidate\uFF1Aproject ${candidateScopeCounts.project}\uFF1Buser ${candidateScopeCounts.user}\uFF1Bsession ${candidateScopeCounts.session}\uFF1B\u5019\u9009\u4E0D\u4F1A\u81EA\u52A8\u63A5\u53D7\u6216\u6CE8\u5165`,
+    `- prompt \u6CE8\u5165\uFF1Aaccepted-only topK ${MEMORY_PROMPT_TOP_K}\uFF1Binjected ${injection.items.length}\uFF1Bchars ${injection.text.length}\uFF1Bestimated tokens ${estimateMemoryTokens(injection.text)}`,
+    `- \u4E0A\u6B21\u5B66\u4E60\uFF1A${lastRun}`,
+    `- \u81EA\u52A8\u5B66\u4E60\uFF1A${learningLabel === "on" ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF1B\u7A33\u5B9A taxonomy \u8BB0\u5FC6\u4F1A\u81EA\u52A8\u63A5\u53D7\uFF0C\u4E0D\u786E\u5B9A\u5185\u5BB9\u4FDD\u7559\u5019\u9009\uFF1B\u5207\u6362\uFF1A/memory learn on|off`,
+    "- \u957F\u671F\u5199\u5165\uFF1A\u81EA\u52A8 extraction \u53EA\u5199\u4E13\u7528 memory dir\uFF1B\u624B\u52A8\u5019\u9009\u4ECD\u7528 /memory accept <id>\uFF1Bmemory \u4E0D\u7ED5\u8FC7\u666E\u901A Write/Edit \u6743\u9650",
+    "- \u5B8C\u6574\u5019\u9009\u3001\u804A\u5929\u3001\u65E5\u5FD7\u548C\u7D22\u5F15 dump \u4E0D\u6CE8\u5165 prompt"
+  ].join("\n");
+}
+function countMemoryScopes(items) {
+  return {
+    project: items.filter((item) => item.scope === "project").length,
+    user: items.filter((item) => item.scope === "user").length,
+    session: items.filter((item) => item.scope === "session").length
+  };
+}
+function createEvidenceBackedMemoryCandidates(context) {
+  const existing = new Set(
+    [...context.memory.candidates, ...context.memory.accepted, ...context.memory.disabled].map(
+      (item) => item.summary
+    )
+  );
+  const summaries = [];
+  const add = (summary, source, refs) => {
+    const normalized = truncateDisplay(summary.replace(/\s+/g, " "), 240);
+    if (!normalized || existing.has(normalized)) {
+      return;
+    }
+    existing.add(normalized);
+    summaries.push(createMemoryCandidate("project", normalized, source, refs));
+  };
+  for (const evidence of context.evidence.slice(0, 3)) {
+    add(`\u8BC1\u636E\u7EBF\u7D22\uFF1A${evidence.summary}`, `evidence:${evidence.kind}`, [evidence.id]);
+  }
+  for (const todo of context.tools.todos.slice(0, 3)) {
+    if (todo.status === "completed") {
+      add(`\u5DF2\u5B8C\u6210\u4EFB\u52A1\u7EBF\u7D22\uFF1A${todo.content}`, "todo:completed", [`todo:${todo.id}`]);
+    }
+  }
+  if (context.lastVerification?.status === "pass") {
+    add(`\u9A8C\u8BC1\u901A\u8FC7\u7EBF\u7D22\uFF1A${context.lastVerification.summary}`, "verification:pass", [
+      context.lastVerification.id
+    ]);
+  }
+  if (context.memory.lastHandoff) {
+    add(`handoff \u7EBF\u7D22\uFF1A${context.memory.lastHandoff.goal}`, "handoff", [
+      context.memory.lastHandoff.id
+    ]);
+  }
+  return summaries;
+}
+var MEMORY_SECRET_PATTERNS = [
+  /\b[A-Za-z0-9_-]{20,}(?:key|token|secret|password|credential)/i,
+  /\b(?:sk|pk|api|token|secret|key|password|credential)[_-][A-Za-z0-9_-]{16,}/i,
+  /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{36,}/,
+  /\b(?:AKIA|ASIA)[A-Z0-9]{16}/,
+  /\b(?:xox[bpras])-[A-Za-z0-9-]+/,
+  /-----BEGIN (?:RSA |EC |DSA )?PRIVATE KEY-----/,
+  /\b[A-Za-z0-9+/]{40,}={0,2}\b/
+];
+function containsSecret(text) {
+  return MEMORY_SECRET_PATTERNS.some((pattern) => pattern.test(text));
+}
+function formatMemoryLearningRun(run, language) {
+  if (language === "en-US") {
+    return [
+      "Memory learn (controlled / extraction runtime)",
+      `- source: bounded evidence/Todo/verification/handoff only; trigger ${run.trigger}`,
+      `- candidates created: ${run.candidatesCreated}`,
+      `- accepted created: ${run.acceptedCreated ?? 0}; accepted updated: ${run.acceptedUpdated ?? 0}`,
+      `- model called: ${run.modelCalled ? "yes" : "no"}`,
+      `- skipped reason: ${run.skippedReason ?? "none"}`,
+      "- next: stable taxonomy memory is accepted automatically into the dedicated memory dir; review uncertain candidates with /memory review."
+    ].join("\n");
+  }
+  return [
+    "Memory learn\uFF08\u53D7\u63A7 / extraction runtime\uFF09",
+    `- \u6765\u6E90\uFF1A\u4EC5 bounded evidence/Todo/verification/handoff\uFF1Btrigger ${run.trigger}`,
+    `- \u65B0\u5019\u9009\uFF1A${run.candidatesCreated}`,
+    `- \u81EA\u52A8\u63A5\u53D7\uFF1A\u65B0\u589E ${run.acceptedCreated ?? 0}\uFF1B\u66F4\u65B0 ${run.acceptedUpdated ?? 0}`,
+    `- \u8C03\u7528\u6A21\u578B\uFF1A${run.modelCalled ? "yes" : "no"}`,
+    `- \u8DF3\u8FC7\u539F\u56E0\uFF1A${run.skippedReason ?? "none"}`,
+    "- \u4E0B\u4E00\u6B65\uFF1A\u7A33\u5B9A taxonomy \u8BB0\u5FC6\u4F1A\u81EA\u52A8\u5199\u5165\u4E13\u7528 memory dir\uFF1B\u4E0D\u786E\u5B9A\u5019\u9009\u7528 /memory review \u590D\u6838\u3002"
+  ].join("\n");
+}
+function createControlledMemoryInjection(context) {
+  const items = context.memory.accepted.filter((item) => normalizeMemoryStatus(item) === "accepted").sort((a, b) => a.id.localeCompare(b.id)).slice(0, MEMORY_PROMPT_TOP_K);
+  const text = truncateDisplay(
+    items.map(
+      (item) => `- ${item.id} [${item.scope}] ${truncateDisplay(item.summary.replace(/\s+/g, " "), MEMORY_PROMPT_ITEM_WIDTH)} (source ${truncateDisplay(item.source, 80)})`
+    ).join("\n"),
+    MEMORY_PROMPT_TOTAL_WIDTH
+  );
+  return { items, text };
+}
+function estimateMemoryTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function formatControlledMemoryForModel(context) {
+  const injection = createControlledMemoryInjection(context);
+  if (injection.items.length === 0) {
+    return "[]";
+  }
+  return JSON.stringify(
+    injection.items.map((item) => ({
+      id: item.id,
+      scope: item.scope,
+      summary: truncateDisplay(item.summary.replace(/\s+/g, " "), MEMORY_PROMPT_ITEM_WIDTH),
+      source: truncateDisplay(item.source, 80)
+    }))
+  );
+}
+function createLinghunMdTemplate(language) {
+  if (language === "en-US") {
+    return `# Project Rules
+
+## Purpose
+- LINGHUN.md records long-lived project rules, stable facts, common commands, and explicit constraints.
+- Keep this file concise so it can be loaded into context without adding unnecessary tokens.
+
+## What to write here
+- Stable engineering rules, validation commands, architecture boundaries, coding style, and project-specific do/don't items.
+- Facts that have been checked against code, index results, command output, or project documents.
+
+## What not to write here
+- Temporary plans, phase progress, full transcripts, large logs, raw index dumps, secrets, tokens, billing details, or private credentials.
+- Short-term handoff content belongs in structured handoff/todo/verification records, not in long-term rules.
+
+## Work rules
+- Prefer facts over guesses: read code, project index, documentation, or command results before making claims.
+- Natural-language commands do not bypass Start Gate or permission approval.
+- Writing files, Bash, network access, dependency installation, and permission/config changes require explicit user confirmation.
+- Long-term memory uses the controlled extraction runtime by default: stable taxonomy facts may be auto-written to the dedicated memory directory; uncertain content remains candidate-only.
+- After code changes, run the smallest project-approved validation that covers the touched area.
+- Do not paste full transcripts, huge logs, large index results, or full memory stores back into model context.
+- Keep clean rewrite boundaries: reference public behavior and project docs, but do not copy suspicious or proprietary source.
+- Be friendly to Chinese and English projects; keep names, commands, and errors readable for both when practical.
+`;
+  }
+  return `# \u9879\u76EE\u89C4\u5219
+
+## \u7528\u9014
+- LINGHUN.md \u8BB0\u5F55\u9879\u76EE\u957F\u671F\u7A33\u5B9A\u89C4\u5219\u3001\u7A33\u5B9A\u4E8B\u5B9E\u3001\u5E38\u7528\u547D\u4EE4\u548C\u660E\u786E\u7981\u6B62\u4E8B\u9879\u3002
+- \u4FDD\u6301\u77ED\u5C0F\u6E05\u6670\uFF0C\u907F\u514D\u628A\u5B8C\u6574\u6587\u4EF6\u585E\u8FDB\u4E0A\u4E0B\u6587\u9020\u6210 token \u8D1F\u62C5\u3002
+
+## \u5E94\u8BE5\u5199\u5165
+- \u7A33\u5B9A\u5DE5\u7A0B\u89C4\u5219\u3001\u9A8C\u8BC1\u547D\u4EE4\u3001\u67B6\u6784\u8FB9\u754C\u3001\u4EE3\u7801\u98CE\u683C\u3001\u9879\u76EE\u4E13\u5C5E\u7EA6\u5B9A\u548C\u7981\u6B62\u4E8B\u9879\u3002
+- \u5DF2\u901A\u8FC7\u4EE3\u7801\u3001\u9879\u76EE\u7D22\u5F15\u3001\u6587\u6863\u6216\u547D\u4EE4\u7ED3\u679C\u786E\u8BA4\u8FC7\u7684\u4E8B\u5B9E\u3002
+
+## \u4E0D\u5E94\u8BE5\u5199\u5165
+- \u4E34\u65F6\u8BA1\u5212\u3001\u9636\u6BB5\u8FDB\u5EA6\u3001\u5B8C\u6574 transcript\u3001\u5927\u65E5\u5FD7\u3001\u539F\u59CB\u7D22\u5F15\u7ED3\u679C\u3001\u5BC6\u94A5\u3001token\u3001\u8D26\u5355\u7EC6\u8282\u6216\u79C1\u6709\u51ED\u636E\u3002
+- \u77ED\u671F\u4EA4\u63A5\u5185\u5BB9\u5E94\u8FDB\u5165\u7ED3\u6784\u5316 handoff\u3001Todo \u6216\u9A8C\u8BC1\u8BB0\u5F55\uFF0C\u4E0D\u8981\u8FFD\u52A0\u5230\u957F\u671F\u89C4\u5219\u3002
+
+## \u5DE5\u4F5C\u89C4\u5219
+- \u4E8B\u5B9E\u4F18\u5148\uFF1A\u5148\u8BFB\u4EE3\u7801\u3001\u9879\u76EE\u7D22\u5F15\u3001\u6587\u6863\u6216\u547D\u4EE4\u7ED3\u679C\uFF0C\u518D\u5224\u65AD\u548C\u4E0B\u7ED3\u8BBA\u3002
+- \u81EA\u7136\u8BED\u8A00\u547D\u4EE4\u4E0D\u80FD\u7ED5\u8FC7 Start Gate \u6216\u6743\u9650\u5BA1\u6279\u3002
+- \u5199\u6587\u4EF6\u3001Bash\u3001\u8054\u7F51\u3001\u5B89\u88C5\u4F9D\u8D56\u3001\u6743\u9650\u6216\u914D\u7F6E\u53D8\u66F4\uFF0C\u90FD\u5FC5\u987B\u5148\u5F97\u5230\u7528\u6237\u660E\u786E\u786E\u8BA4\u3002
+- \u957F\u671F\u8BB0\u5FC6\u9ED8\u8BA4\u8D70\u53D7\u63A7 extraction runtime\uFF1A\u7A33\u5B9A taxonomy \u4E8B\u5B9E\u53EF\u81EA\u52A8\u5199\u5165\u4E13\u7528 memory dir\uFF1B\u4E0D\u786E\u5B9A\u5185\u5BB9\u4ECD\u4FDD\u7559\u5019\u9009\u3002
+- \u6539\u4EE3\u7801\u540E\u8FD0\u884C\u9879\u76EE\u8BA4\u53EF\u7684\u6700\u5C0F\u5FC5\u8981\u9A8C\u8BC1\uFF0C\u8986\u76D6\u672C\u6B21\u6539\u52A8\u8303\u56F4\u3002
+- \u4E0D\u8981\u628A\u5B8C\u6574 transcript\u3001\u5927\u65E5\u5FD7\u3001\u5927\u7D22\u5F15\u7ED3\u679C\u6216\u5B8C\u6574 memory \u585E\u56DE\u6A21\u578B\u4E0A\u4E0B\u6587\u3002
+- \u9075\u5B88 clean rewrite\uFF1A\u53EF\u53C2\u8003\u516C\u5F00\u884C\u4E3A\u548C\u9879\u76EE\u6587\u6863\uFF0C\u4E0D\u590D\u5236\u53EF\u7591\u6216\u4E13\u6709\u6E90\u7801\u3002
+- \u4E2D\u6587\u53CB\u597D\uFF0C\u540C\u65F6\u5C3D\u91CF\u4FDD\u7559\u4E2D\u82F1\u6587\u9879\u76EE\u540D\u3001\u547D\u4EE4\u548C\u9519\u8BEF\u4FE1\u606F\u7684\u53EF\u8BFB\u6027\u3002
+
+## \u5DE5\u7A0B\u7EAA\u5F8B
+- \u9ED8\u8BA4\u53EA\u505A\u5B8C\u6210\u5F53\u524D\u4EFB\u52A1\u6240\u5FC5\u9700\u7684\u6700\u5C0F\u6539\u52A8\uFF0C\u4E0D\u987A\u624B\u4FEE\u65E0\u5173\u95EE\u9898\u3002
+- \u4E0D\u4E3B\u52A8\u65B0\u589E\u62BD\u8C61\u3001helper\u3001wrapper\u3001\u76EE\u5F55\u5C42\u7EA7\u6216\u7ED3\u6784\u6027\u6539\u9020\u3002
+- \u4F18\u5148\u5C40\u90E8\u8865\u4E01\u548C\u73B0\u6709\u4EE3\u7801\u98CE\u683C\uFF0C\u907F\u514D\u7EE7\u7EED\u653E\u5927\u5C4E\u5C71\u3001\u8D85\u957F\u6587\u4EF6\u548C\u590D\u6742\u5206\u652F\u3002
+- \u91CD\u6784\u4EC5\u5728\u5FC5\u8981\u3001\u5B58\u5728\u76F4\u63A5\u98CE\u9669\u6216\u7528\u6237\u660E\u786E\u8981\u6C42\u65F6\u8FDB\u884C\u3002
+- \u9ED8\u8BA4\u4E0D\u6539\u516C\u5171\u63A5\u53E3\u3001\u4F9D\u8D56\u3001\u914D\u7F6E\u3001\u6784\u5EFA\u811A\u672C\u3001\u6587\u4EF6\u540D\u548C\u76EE\u5F55\u7ED3\u6784\u3002
+- \u6D89\u53CA\u8D85\u8FC7 3 \u4E2A\u6587\u4EF6\u3001\u516C\u5171\u63A5\u53E3\u3001\u4F9D\u8D56/\u914D\u7F6E\u3001\u5220\u9664/\u91CD\u547D\u540D\u6216\u660E\u663E\u91CD\u6784\u65F6\uFF0C\u5148\u8BF4\u660E\u7406\u7531\u548C\u8303\u56F4\u3002
+- \u4FEE bug \u8981\u5B9A\u4F4D\u76F4\u63A5\u539F\u56E0\uFF0C\u4E0D\u63A5\u53D7\u53EA\u63A9\u76D6\u75C7\u72B6\u7684\u8865\u4E01\u3002
+`;
+}
+async function formatProjectRulesRead(context) {
+  if (!await pathExists(context.memory.projectRulesPath)) {
+    context.memory.projectRulesExists = false;
+    context.memory.projectRulesSummary = "missing";
+    return context.language === "en-US" ? `Project rules file is missing: ${context.memory.projectRulesPath}
+- To create a template, run /memory init. I will not generate it automatically.` : `\u9879\u76EE\u89C4\u5219\u6587\u4EF6\u4E0D\u5B58\u5728\uFF1A${context.memory.projectRulesPath}
+- \u5982\u9700\u751F\u6210\u6A21\u677F\uFF0C\u8BF7\u8FD0\u884C /memory init\u3002\u672C\u6B21\u4E0D\u4F1A\u81EA\u52A8\u751F\u6210\u3002`;
+  }
+  try {
+    const content = await readFile(context.memory.projectRulesPath, "utf8");
+    context.memory.projectRulesExists = true;
+    context.memory.projectRulesSummary = summarizeProjectRules(content);
+    context.memory.projectRulesError = void 0;
+    return context.language === "en-US" ? `Project rules: ${context.memory.projectRulesPath}
+${truncateDisplay(content, 2e3)}` : `\u9879\u76EE\u89C4\u5219\uFF1A${context.memory.projectRulesPath}
+${truncateDisplay(content, 2e3)}`;
+  } catch (error) {
+    context.memory.projectRulesExists = false;
+    context.memory.projectRulesSummary = "unreadable";
+    context.memory.projectRulesError = error instanceof Error ? error.message : String(error);
+    return context.language === "en-US" ? `Failed to read project rules: ${context.memory.projectRulesError}` : `\u8BFB\u53D6\u9879\u76EE\u89C4\u5219\u5931\u8D25\uFF1A${context.memory.projectRulesError}`;
+  }
+}
+
+export {
+  createMemoryCandidate,
+  parseMemoryCandidateArgs,
+  writeMemoryRecord,
+  writeMemoryLearningMode,
+  removeMemoryRecord,
+  getMemoryDirectory,
+  findMemoryRecord,
+  removeMemoryFromState,
+  formatMemoryScope,
+  formatProjectRulesContext,
+  formatMemoryStatus,
+  formatMemoryStorage,
+  formatMemoryReview,
+  formatMemoryStats,
+  countMemoryScopes,
+  createEvidenceBackedMemoryCandidates,
+  containsSecret,
+  formatMemoryLearningRun,
+  createControlledMemoryInjection,
+  estimateMemoryTokens,
+  formatControlledMemoryForModel,
+  createLinghunMdTemplate,
+  formatProjectRulesRead
+};