@linghun/tui 0.1.0

package/dist/chunk-GMUCSNUD.js

@@ -0,0 +1,586 @@
+import {
+  applyMemoryExtractionDecision,
+  decideMemoryExtraction,
+  refreshAutoMemoryFiles,
+  writeAutoMemoryFiles
+} from "./chunk-VTQL23UM.js";
+import {
+  showCommandPanel
+} from "./chunk-JO5ANTMR.js";
+import {
+  writeErrorLine
+} from "./chunk-ECFLCY5V.js";
+import {
+  createHandoffPacket,
+  formatResumePacket,
+  hydrateResumeContext,
+  validateHandoffPacket
+} from "./chunk-MLUIOBKL.js";
+import {
+  createEvidenceBackedMemoryCandidates,
+  createLinghunMdTemplate,
+  createMemoryCandidate,
+  findMemoryRecord,
+  formatMemoryLearningRun,
+  formatMemoryReview,
+  formatMemoryScope,
+  formatMemoryStats,
+  formatMemoryStatus,
+  formatMemoryStorage,
+  getMemoryDirectory,
+  parseMemoryCandidateArgs,
+  removeMemoryFromState,
+  removeMemoryRecord,
+  writeMemoryLearningMode,
+  writeMemoryRecord
+} from "./chunk-LQTVYUT3.js";
+import {
+  pathExists,
+  summarizeProjectRules
+} from "./chunk-QLRTQHTR.js";
+import {
+  formatError,
+  writeLine
+} from "./chunk-OMZYPQVA.js";
+
+// src/memory-command-runtime.ts
+import { writeFile } from "fs/promises";
+import { basename } from "path";
+import { TOGGLE_DETAILS_KEYBIND } from "@linghun/shared";
+var runtimeDeps;
+function configureMemoryCommandRuntime(deps2) {
+  runtimeDeps = deps2;
+}
+function deps() {
+  if (!runtimeDeps) {
+    throw new Error("memory-command-runtime deps not configured");
+  }
+  return runtimeDeps;
+}
+function isSessionEnded(transcript) {
+  return transcript.at(-1)?.type === "session_end";
+}
+function buildMemoryStatusPanel(context) {
+  const isEn = context.language === "en-US";
+  const candidates = context.memory.candidates.length;
+  const accepted = context.memory.accepted.length;
+  const disabled = context.memory.disabled.length;
+  const rejected = context.memory.rejected.length;
+  const learning = context.memory.learningMode === "active";
+  const summary = [
+    isEn ? `Memory \xB7 accepted ${accepted} \xB7 candidates ${candidates} \xB7 disabled ${disabled}${rejected > 0 ? ` \xB7 rejected ${rejected}` : ""}` : `\u8BB0\u5FC6 \xB7 \u5DF2\u63A5\u53D7 ${accepted} \xB7 \u5019\u9009 ${candidates} \xB7 \u5DF2\u7981\u7528 ${disabled}${rejected > 0 ? ` \xB7 \u5DF2\u62D2\u7EDD ${rejected}` : ""}`,
+    isEn ? `Auto-learning: ${learning ? "on" : "off"}` : `\u81EA\u52A8\u5B66\u4E60\uFF1A${learning ? "\u5DF2\u5F00\u542F" : "\u5DF2\u5173\u95ED"}`
+  ];
+  const actions = [];
+  if (candidates > 0) actions.push("/memory review");
+  if (!learning) actions.push("/memory learn on");
+  actions.push("/memory storage");
+  return {
+    title: "/memory",
+    tone: candidates > 0 ? "warning" : "neutral",
+    summary,
+    actions,
+    detailsText: formatMemoryStatus(context)
+  };
+}
+async function handleMemoryCommand(args, context, output) {
+  const action = args[0] ?? "status";
+  if (action === "status" || action === "list") {
+    showCommandPanel(context, output, buildMemoryStatusPanel(context));
+    return;
+  }
+  if (action === "storage") {
+    showCommandPanel(context, output, {
+      title: "/memory storage",
+      tone: "neutral",
+      summary: [
+        context.language === "en-US" ? `Memory storage paths \u2014 ${TOGGLE_DETAILS_KEYBIND} for details.` : `\u8BB0\u5FC6\u5B58\u50A8\u8DEF\u5F84 \u2014 ${TOGGLE_DETAILS_KEYBIND} \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: formatMemoryStorage(context)
+    });
+    return;
+  }
+  if (action === "review") {
+    showCommandPanel(context, output, {
+      title: "/memory review",
+      tone: "neutral",
+      summary: [
+        context.language === "en-US" ? `Memory review \u2014 ${TOGGLE_DETAILS_KEYBIND} for details.` : `\u8BB0\u5FC6\u590D\u6838 \u2014 ${TOGGLE_DETAILS_KEYBIND} \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: formatMemoryReview(context)
+    });
+    return;
+  }
+  if (action === "stats") {
+    showCommandPanel(context, output, {
+      title: "/memory stats",
+      tone: "neutral",
+      summary: [
+        context.language === "en-US" ? `Memory stats \u2014 ${TOGGLE_DETAILS_KEYBIND} for details.` : `\u8BB0\u5FC6\u7EDF\u8BA1 \u2014 ${TOGGLE_DETAILS_KEYBIND} \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: formatMemoryStats(context)
+    });
+    return;
+  }
+  if (action === "learn") {
+    const subAction = args[1];
+    if (subAction === "on") {
+      context.memory.learningMode = "active";
+      await writeMemoryLearningMode(context);
+      const sessionId = await deps().ensureSession(context);
+      await deps().appendSystemEvent(context, sessionId, "memory learning mode active", "info");
+      writeLine(
+        output,
+        context.language === "en-US" ? "Auto-learning enabled. Stable taxonomy memory can be accepted automatically; uncertain content stays candidate-only. Disable with /memory learn off." : "\u81EA\u52A8\u5B66\u4E60\u5DF2\u5F00\u542F\u3002\u7A33\u5B9A taxonomy \u8BB0\u5FC6\u53EF\u81EA\u52A8\u63A5\u53D7\uFF1B\u4E0D\u786E\u5B9A\u5185\u5BB9\u4FDD\u7559\u5019\u9009\u3002\u5173\u95ED\uFF1A/memory learn off"
+      );
+      return;
+    }
+    if (subAction === "off") {
+      context.memory.learningMode = "off";
+      await writeMemoryLearningMode(context);
+      const sessionId = await deps().ensureSession(context);
+      await deps().appendSystemEvent(context, sessionId, "memory learning mode off", "info");
+      writeLine(
+        output,
+        context.language === "en-US" ? "Auto-learning disabled. No new candidates will be generated automatically." : "\u81EA\u52A8\u5B66\u4E60\u5DF2\u5173\u95ED\u3002\u4E0D\u518D\u81EA\u52A8\u751F\u6210\u65B0\u5019\u9009\u8BB0\u5FC6\u3002"
+      );
+      return;
+    }
+    if (subAction === "status") {
+      writeLine(
+        output,
+        context.language === "en-US" ? `Learning mode: ${context.memory.learningMode}; source ${context.memory.learningModeSource ?? "default"}; candidates ${context.memory.candidates.length}; accepted ${context.memory.accepted.length}` : `\u5B66\u4E60\u6A21\u5F0F\uFF1A${context.memory.learningMode === "active" ? "\u5F00\u542F" : "\u5173\u95ED"}\uFF1B\u6765\u6E90 ${context.memory.learningModeSource ?? "default"}\uFF1B\u5019\u9009 ${context.memory.candidates.length}\uFF1B\u5DF2\u63A5\u53D7 ${context.memory.accepted.length}`
+      );
+      return;
+    }
+    const result = await runControlledMemoryLearning(context);
+    showCommandPanel(context, output, {
+      title: "/memory learn",
+      tone: "neutral",
+      summary: [
+        context.language === "en-US" ? `Memory learn \u2014 ${result.candidatesCreated} candidate(s), ${result.acceptedCreated ?? 0} accepted; ${TOGGLE_DETAILS_KEYBIND} for details.` : `\u8BB0\u5FC6\u5B66\u4E60 \u2014 \u65B0\u5019\u9009 ${result.candidatesCreated} \u6761\uFF0C\u81EA\u52A8\u63A5\u53D7 ${result.acceptedCreated ?? 0} \u6761\uFF1B${TOGGLE_DETAILS_KEYBIND} \u67E5\u770B\u8BE6\u60C5\u3002`
+      ],
+      detailsText: formatMemoryLearningRun(result, context.language)
+    });
+    return;
+  }
+  if (action === "candidate") {
+    const parsed = parseMemoryCandidateArgs(args.slice(1));
+    if (!parsed.summary) {
+      writeLine(
+        output,
+        "\u7528\u6CD5\uFF1A/memory candidate <\u77ED\u5C0F\u7A33\u5B9A\u8BB0\u5FC6\u6458\u8981> [--scope project|user|session]"
+      );
+      return;
+    }
+    const candidate = createMemoryCandidate(
+      parsed.scope,
+      parsed.summary,
+      "manual /memory candidate",
+      ["user:/memory candidate"]
+    );
+    context.memory.candidates.unshift(candidate);
+    await writeMemoryRecord(candidate, context);
+    const sessionId = await deps().ensureSession(context);
+    await context.store.appendEvent(sessionId, {
+      type: "memory_candidate",
+      candidate,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    deps().refreshCacheFreshness(context);
+    writeLine(
+      output,
+      `\u5DF2\u521B\u5EFA\u5019\u9009\u8BB0\u5FC6\uFF1A${candidate.id}\u3002\u5199\u5165\u957F\u671F\u8BB0\u5FC6\u524D\u8BF7\u8FD0\u884C /memory review \u548C /memory accept ${candidate.id}`
+    );
+    return;
+  }
+  if (action === "accept") {
+    const id = args[1];
+    const candidate = context.memory.candidates.find((item) => item.id === id);
+    if (!candidate) {
+      writeLine(output, "\u672A\u627E\u5230\u5019\u9009\u8BB0\u5FC6\u3002\u7528\u6CD5\uFF1A/memory accept <candidate-id>");
+      return;
+    }
+    await executeMemoryMutation(context, output, { action: "accept", candidate });
+    return;
+  }
+  if (action === "reject") {
+    const id = args[1];
+    const candidate = context.memory.candidates.find((item) => item.id === id);
+    if (!candidate) {
+      writeLine(output, "\u672A\u627E\u5230\u5019\u9009\u8BB0\u5FC6\u3002\u7528\u6CD5\uFF1A/memory reject <candidate-id>");
+      return;
+    }
+    if (await deps().requestMemoryMutationApproval(context, output, {
+      action: "reject",
+      candidate
+    }) !== "approved") {
+      return;
+    }
+    await executeMemoryMutation(context, output, { action: "reject", candidate });
+    return;
+  }
+  if (action === "disable") {
+    const id = args[1];
+    const memory = context.memory.accepted.find((item) => item.id === id);
+    if (!memory) {
+      writeLine(output, "\u672A\u627E\u5230\u5DF2\u63A5\u53D7\u8BB0\u5FC6\u3002\u7528\u6CD5\uFF1A/memory disable <accepted-id>");
+      return;
+    }
+    if (await deps().requestMemoryMutationApproval(context, output, {
+      action: "disable",
+      memory
+    }) !== "approved") {
+      return;
+    }
+    await executeMemoryMutation(context, output, { action: "disable", memory });
+    return;
+  }
+  if (action === "rollback") {
+    const id = args[1];
+    const memory = context.memory.disabled.find((item) => item.id === id);
+    if (!memory) {
+      writeLine(output, "\u672A\u627E\u5230\u5DF2\u7981\u7528\u8BB0\u5FC6\u3002\u7528\u6CD5\uFF1A/memory rollback <disabled-id>");
+      return;
+    }
+    if (await deps().requestMemoryMutationApproval(context, output, {
+      action: "rollback",
+      memory
+    }) !== "approved") {
+      return;
+    }
+    await executeMemoryMutation(context, output, { action: "rollback", memory });
+    return;
+  }
+  if (action === "delete" || action === "forget") {
+    const id = args[1];
+    const memory = findMemoryRecord(context.memory, id);
+    if (!memory) {
+      writeLine(output, "\u672A\u627E\u5230\u8BE5\u8BB0\u5FC6\u3002\u7528\u6CD5\uFF1A/memory delete <id> \u6216 /memory forget <id>");
+      return;
+    }
+    if (await deps().requestMemoryMutationApproval(context, output, {
+      action: "delete",
+      memory
+    }) !== "approved") {
+      return;
+    }
+    await executeMemoryMutation(context, output, { action: "delete", memory });
+    return;
+  }
+  if (action === "init") {
+    if (await pathExists(context.memory.projectRulesPath)) {
+      await initLinghunMd(context, output);
+      return;
+    }
+    if (await deps().requestMemoryMutationApproval(context, output, { action: "init" }) !== "approved") {
+      return;
+    }
+    await executeMemoryMutation(context, output, { action: "init" });
+    return;
+  }
+  if (action === "import" && args[1] === "sessions") {
+    await importAiSessions(args.slice(2), context, output);
+    return;
+  }
+  writeLine(
+    output,
+    "\u7528\u6CD5\uFF1A/memory | /memory storage | /memory review | /memory stats | /memory learn [on|off|status] | /memory candidate <\u6458\u8981> [--scope project|user|session] | /memory accept|reject|disable|rollback|delete|forget <id> | /memory init | /memory import sessions [source] [query]"
+  );
+}
+async function resumeSessionWithHandoff(sessionId, context, output, source) {
+  try {
+    const resumed = await context.store.resume(sessionId);
+    context.sessionId = resumed.session.id;
+    context.sessionEnded = isSessionEnded(resumed.transcript);
+    context.model = resumed.session.model;
+    hydrateResumeContext(context, resumed.transcript);
+    deps().refreshCacheFreshness(context);
+    const packet = context.memory.lastHandoff ?? createHandoffPacket(context, resumed.transcript);
+    const missing = validateHandoffPacket(packet);
+    context.memory.lastResumeReadonly = missing.length > 0;
+    writeLine(output, `\u5DF2\u6062\u590D\u4F1A\u8BDD\uFF1A${resumed.session.id}`);
+    writeLine(output, `\u6062\u590D\u65B9\u5F0F\uFF1A${source}\uFF1B\u4E0D\u4F1A\u628A\u5B8C\u6574 transcript \u585E\u56DE\u4E0A\u4E0B\u6587\u3002`);
+    writeLine(output, formatResumePacket(packet, missing, context));
+    if (context.index.status === "stale" || context.index.status === "missing") {
+      writeLine(
+        output,
+        "\u7D22\u5F15\u4E0D\u662F ready\uFF1A\u5EFA\u8BAE\u5148\u8FD0\u884C /index status \u6216 /index refresh\uFF1B\u4E0D\u4F1A\u81EA\u52A8\u5237\u65B0\u3002 "
+      );
+    }
+    deps().writeStatus(output, context);
+  } catch (error) {
+    writeErrorLine(output, formatError(error));
+  }
+}
+async function appendMemoryLifecycleEvent(context, sessionId, action, memory) {
+  await deps().appendSystemEvent(
+    context,
+    sessionId,
+    `memory_lifecycle action=${action} id=${memory.id} scope=${memory.scope} status=${memory.status} source=${memory.source}`,
+    action === "deleted" ? "warning" : "info"
+  );
+}
+async function executeMemoryMutation(context, output, mutation) {
+  if (mutation.action === "accept") {
+    const accepted = { ...mutation.candidate, status: "accepted" };
+    await writeMemoryRecord(accepted, context);
+    if (accepted.taxonomy && accepted.scope !== "session") {
+      await writeAutoMemoryFiles(getMemoryDirectory(accepted.scope, context), accepted);
+    }
+    context.memory.candidates = context.memory.candidates.filter((item) => item.id !== accepted.id);
+    context.memory.accepted.unshift(accepted);
+    const sessionId = await deps().ensureSession(context);
+    await context.store.appendEvent(sessionId, {
+      type: "memory_accepted",
+      memory: accepted,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await appendMemoryLifecycleEvent(context, sessionId, "accepted", accepted);
+    await deps().recordMemoryMutationEvidence(context, sessionId, "accepted", accepted);
+    deps().refreshCacheFreshness(context);
+    writeLine(
+      output,
+      `\u5DF2\u5199\u5165${formatMemoryScope(accepted.scope)}\u7EA7\u957F\u671F\u8BB0\u5FC6\uFF1A${accepted.id}\uFF1B\u540E\u7EED\u6CE8\u5165\u4ECD\u53D7 accepted-only top-k/\u5B57\u7B26\u9884\u7B97\u9650\u5236\u3002`
+    );
+    return;
+  }
+  if (mutation.action === "reject") {
+    const rejected = { ...mutation.candidate, status: "rejected" };
+    await writeMemoryRecord(rejected, context);
+    context.memory.candidates = context.memory.candidates.filter((item) => item.id !== rejected.id);
+    context.memory.rejected.unshift(rejected);
+    const sessionId = await deps().ensureSession(context);
+    await appendMemoryLifecycleEvent(context, sessionId, "rejected", rejected);
+    await deps().recordMemoryMutationEvidence(context, sessionId, "rejected", rejected);
+    deps().refreshCacheFreshness(context);
+    writeLine(output, `\u5DF2\u62D2\u7EDD\u5019\u9009\u8BB0\u5FC6\uFF1A${rejected.id}\uFF1B\u4E0D\u4F1A\u5199\u5165\u957F\u671F\u8BB0\u5FC6\u6216\u6CE8\u5165 prompt\u3002`);
+    return;
+  }
+  if (mutation.action === "disable") {
+    const disabled = { ...mutation.memory, status: "disabled" };
+    await writeMemoryRecord(disabled, context);
+    context.memory.accepted = context.memory.accepted.filter((item) => item.id !== disabled.id);
+    context.memory.disabled.unshift(disabled);
+    if (disabled.taxonomy && disabled.scope !== "session") {
+      await refreshAutoMemoryFiles(
+        getMemoryDirectory(disabled.scope, context),
+        context.memory.accepted.filter((item) => item.scope === disabled.scope),
+        context.memory.disabled.filter((item) => item.scope === disabled.scope)
+      );
+    }
+    const sessionId = await deps().ensureSession(context);
+    await appendMemoryLifecycleEvent(context, sessionId, "disabled", disabled);
+    await deps().recordMemoryMutationEvidence(context, sessionId, "disabled", disabled);
+    deps().refreshCacheFreshness(context);
+    writeLine(output, `\u5DF2\u7981\u7528\u957F\u671F\u8BB0\u5FC6\uFF1A${disabled.id}\uFF1B\u4FDD\u7559\u8BB0\u5F55\u4F46\u4E0D\u518D\u6CE8\u5165 prompt\u3002`);
+    return;
+  }
+  if (mutation.action === "rollback") {
+    const accepted = { ...mutation.memory, status: "accepted" };
+    await writeMemoryRecord(accepted, context);
+    context.memory.disabled = context.memory.disabled.filter((item) => item.id !== accepted.id);
+    context.memory.accepted.unshift(accepted);
+    if (accepted.taxonomy && accepted.scope !== "session") {
+      await refreshAutoMemoryFiles(
+        getMemoryDirectory(accepted.scope, context),
+        context.memory.accepted.filter((item) => item.scope === accepted.scope),
+        context.memory.disabled.filter((item) => item.scope === accepted.scope)
+      );
+    }
+    const sessionId = await deps().ensureSession(context);
+    await appendMemoryLifecycleEvent(context, sessionId, "rollback", accepted);
+    await deps().recordMemoryMutationEvidence(context, sessionId, "rollback", accepted);
+    deps().refreshCacheFreshness(context);
+    writeLine(output, `\u5DF2\u56DE\u6EDA\u542F\u7528\u957F\u671F\u8BB0\u5FC6\uFF1A${accepted.id}\uFF1B\u4ECD\u53D7\u53D7\u63A7 prompt \u6CE8\u5165\u9884\u7B97\u9650\u5236\u3002`);
+    return;
+  }
+  if (mutation.action === "delete") {
+    await removeMemoryRecord(mutation.memory, context);
+    removeMemoryFromState(context.memory, mutation.memory.id);
+    if (mutation.memory.taxonomy && mutation.memory.scope !== "session") {
+      await refreshAutoMemoryFiles(
+        getMemoryDirectory(mutation.memory.scope, context),
+        context.memory.accepted.filter((item) => item.scope === mutation.memory.scope),
+        context.memory.disabled.filter((item) => item.scope === mutation.memory.scope)
+      );
+    }
+    const sessionId = await deps().ensureSession(context);
+    await appendMemoryLifecycleEvent(context, sessionId, "deleted", mutation.memory);
+    await deps().recordMemoryMutationEvidence(context, sessionId, "deleted", mutation.memory);
+    deps().refreshCacheFreshness(context);
+    writeLine(output, `\u5DF2\u5220\u9664\u8BB0\u5FC6\u8BB0\u5F55\uFF1A${mutation.memory.id}\uFF1B\u4E0D\u4F1A\u4FDD\u7559\u5728\u5019\u9009/\u957F\u671F/\u7981\u7528\u5217\u8868\u3002`);
+    return;
+  }
+  if (mutation.action === "init") {
+    const created = await initLinghunMd(context, output);
+    if (!created) {
+      return;
+    }
+    const sessionId = await deps().ensureSession(context);
+    await deps().appendSystemEvent(
+      context,
+      sessionId,
+      "memory_lifecycle action=init path=LINGHUN.md",
+      "info"
+    );
+    await deps().recordMemoryMutationEvidence(
+      context,
+      sessionId,
+      "init",
+      createMemoryCandidate("project", "generated LINGHUN.md", "memory init", ["LINGHUN.md"])
+    );
+    return;
+  }
+  const unknown = mutation;
+  throw new Error(
+    `\u672A\u77E5 memory mutation action\uFF1A${String(unknown.action)}`
+  );
+}
+async function runControlledMemoryLearning(context) {
+  const candidates = createEvidenceBackedMemoryCandidates(context).slice(0, 3);
+  context.memory.candidates.unshift(...candidates);
+  const sessionId = await deps().ensureSession(context);
+  for (const candidate of candidates) {
+    await writeMemoryRecord(candidate, context);
+    await context.store.appendEvent(sessionId, {
+      type: "memory_candidate",
+      candidate,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  const run = {
+    trigger: "manual",
+    candidatesCreated: candidates.length,
+    modelCalled: false,
+    ...candidates.length === 0 ? { skippedReason: "no bounded evidence/todo/verification/handoff source" } : {},
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  context.memory.lastLearningRun = run;
+  await deps().appendSystemEvent(
+    context,
+    sessionId,
+    `memory_learning trigger=${run.trigger} candidates=${run.candidatesCreated} modelCalled=no skipped=${run.skippedReason ?? "none"}`,
+    candidates.length === 0 ? "warning" : "info"
+  );
+  deps().refreshCacheFreshness(context);
+  return run;
+}
+async function runAutoLearningOnTurnEnd(context, userInput) {
+  if (context.memory.learningMode !== "active") {
+    return {
+      trigger: "manual",
+      candidatesCreated: 0,
+      modelCalled: false,
+      skippedReason: "learning_mode=off",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const decision = decideMemoryExtraction({
+    recentMessages: [userInput],
+    accepted: context.memory.accepted,
+    disabled: context.memory.disabled,
+    candidates: context.memory.candidates
+  });
+  if (decision.action === "create" || decision.action === "update") {
+    const existing = context.memory.accepted.find((item) => item.id === decision.id);
+    const applied = await applyMemoryExtractionDecision({
+      decision,
+      memoryDir: getMemoryDirectory(decision.scope, context),
+      existing
+    });
+    if (!applied.memory) {
+      throw new Error("memory extraction returned no accepted memory");
+    }
+    await writeMemoryRecord(applied.memory, context);
+    context.memory.accepted = [
+      applied.memory,
+      ...context.memory.accepted.filter((item) => item.id !== applied.memory?.id)
+    ];
+    const sessionId = await deps().ensureSession(context);
+    await context.store.appendEvent(sessionId, {
+      type: "memory_accepted",
+      memory: applied.memory,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await appendMemoryLifecycleEvent(context, sessionId, `auto_${decision.action}`, applied.memory);
+    await deps().recordMemoryMutationEvidence(
+      context,
+      sessionId,
+      `auto_${decision.action}`,
+      applied.memory
+    );
+    const run = {
+      trigger: "evidence",
+      candidatesCreated: 0,
+      acceptedCreated: decision.action === "create" ? 1 : 0,
+      acceptedUpdated: decision.action === "update" ? 1 : 0,
+      modelCalled: false,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    context.memory.lastLearningRun = run;
+    await deps().appendSystemEvent(
+      context,
+      sessionId,
+      `auto_memory_extraction action=${decision.action} taxonomy=${decision.taxonomy} topic=${decision.topic}`,
+      "info"
+    );
+    deps().refreshCacheFreshness(context);
+    return run;
+  }
+  return {
+    trigger: "manual",
+    candidatesCreated: 0,
+    modelCalled: false,
+    skippedReason: decision.action === "no-op" ? `memory_extraction:${decision.reason}${decision.blockedBy ? `:${decision.blockedBy}` : ""}` : "no_learnable_content",
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function initLinghunMd(context, output) {
+  if (await pathExists(context.memory.projectRulesPath)) {
+    context.memory.projectRulesExists = true;
+    writeLine(output, `LINGHUN.md \u5DF2\u5B58\u5728\uFF1A${context.memory.projectRulesPath}`);
+    return false;
+  }
+  const content = createLinghunMdTemplate(context.language);
+  await writeFile(context.memory.projectRulesPath, content, "utf8");
+  context.memory.projectRulesExists = true;
+  context.memory.projectRulesSummary = summarizeProjectRules(content);
+  context.memory.projectRulesError = void 0;
+  deps().refreshCacheFreshness(context);
+  writeLine(output, `\u5DF2\u751F\u6210\u57FA\u7840 LINGHUN.md\uFF1A${context.memory.projectRulesPath}`);
+  return true;
+}
+async function importAiSessions(args, context, output) {
+  const source = args[0] ?? "auto";
+  const query = args.slice(1).join(" ").trim() || basename(context.projectPath);
+  const summary = `AI sessions import requested: source=${source}, query=${query}. \u5F53\u524D Linghun \u6700\u5C0F\u5165\u53E3\u53EA\u8BB0\u5F55\u6458\u8981\u548C\u8BC1\u636E\u5F15\u7528\uFF0C\u4E0D\u8BFB\u53D6\u6216\u4FDD\u5B58\u654F\u611F\u804A\u5929\u539F\u6587\uFF1B\u5982 MCP bridge \u4E0D\u53EF\u7528\uFF0C\u8BF7\u5148\u914D\u7F6E ai-sessions\u3002`;
+  const sessionId = await deps().ensureSession(context);
+  await context.store.appendEvent(sessionId, {
+    type: "session_import",
+    source,
+    summary,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const candidate = createMemoryCandidate(
+    "project",
+    `\u5916\u90E8\u4F1A\u8BDD\u5BFC\u5165\u7EBF\u7D22\uFF1A${source} / ${query}`,
+    "AI sessions import summary",
+    [`ai-sessions:${source}:${query}`]
+  );
+  context.memory.candidates.unshift(candidate);
+  await writeMemoryRecord(candidate, context);
+  deps().refreshCacheFreshness(context);
+  writeLine(output, summary);
+  writeLine(output, `\u5DF2\u521B\u5EFA\u5019\u9009\u8BB0\u5FC6\u7B49\u5F85\u786E\u8BA4\uFF1A${candidate.id}`);
+}
+
+export {
+  configureMemoryCommandRuntime,
+  handleMemoryCommand,
+  resumeSessionWithHandoff,
+  executeMemoryMutation,
+  runAutoLearningOnTurnEnd,
+  initLinghunMd,
+  importAiSessions
+};