pi-coding-master 0.2.7

package/core/individual.bio.organs/brain.hippocampus/hippocampus.ts

@@ -0,0 +1,166 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { execSync } from "node:child_process";
+import { writeFile, mkdir } from "node:fs/promises";
+import { readFileSync, writeFileSync, statSync } from "node:fs";
+import { getPrompt } from "#runtime";
+import { personDir as getPersonDir } from "#paths";
+import { registerMemory } from "./memory.ts";
+import { sendCustomMessage } from "#messages";
+
+// 海马体(后台编码)开关：每人持久化(JSON 布尔，不删文件)。off=停后台编码；主意识记忆快照/nap/sleep 不受影响。
+function hcFlag(personDir: string): string { return `${personDir}/.data/hippocampus.json`; }
+function hcDisabled(personDir: string): boolean {
+  try { return !!JSON.parse(readFileSync(hcFlag(personDir), "utf8")).disabled; } catch { return false; }
+}
+function setHcDisabled(personDir: string, disabled: boolean): void {
+  try { writeFileSync(hcFlag(personDir), JSON.stringify({ disabled, ts: new Date().toISOString() })); } catch {}
+}
+
+export interface HippocampusHandle {
+  start(): void;
+  stop(): void;
+  isRunning(): boolean;
+  getSessionId(): string;
+}
+
+export function createHippocampus(
+  pi: ExtensionAPI,
+  onError: (msg: string) => void,
+  personDir: string,
+): HippocampusHandle {
+  const personId = personDir.match(/([a-f0-9]+)$/)?.[1] ?? "x";
+  const tmuxName = `hc-${personId}`;
+  const sessionDir = `${personDir}/.data/hippocampus-sessions`;
+  let running = false;
+
+  function tmuxHas(): boolean {
+    try {
+      execSync(`tmux has-session -t ${tmuxName} 2>/dev/null`);
+      return true;
+    } catch { return false; }
+  }
+
+  const self: HippocampusHandle = {
+    async start() {
+      running = true;
+      if (tmuxHas()) return; // already alive
+
+      await mkdir(sessionDir, { recursive: true });
+
+      const dataDir = `${personDir}/.data`;
+
+      // Write conv.json with system prompt so pi loads it on start
+      const convPath = `${sessionDir}/conv.json`;
+      await writeFile(convPath, JSON.stringify([
+        { role: "system", content: getPrompt("hippocampus.gen_work_mem") }
+      ]));
+
+      // 重启后把 offset 对齐到 context.md 当前大小，让海马体从"现在"开始编码
+      try { writeFileSync(`${dataDir}/.hc-offset`, String(statSync(`${dataDir}/context.md`).size)); } catch {}
+
+      // Write launch script
+      const launchScript = `${personDir}/.data/hippocampus-launch.sh`;
+      const templatePath = new URL("./hippocampus-launcher.sh.template", import.meta.url).pathname;
+      const script = readFileSync(templatePath, "utf8")
+        .replaceAll("{{SESSION_DIR}}", JSON.stringify(sessionDir))
+        .replaceAll("{{DATA_DIR}}", JSON.stringify(dataDir))
+        .replaceAll("{{MAIN_PID}}", String(process.pid))
+        .replaceAll("{{TMUX_NAME}}", tmuxName);
+      await writeFile(launchScript, script);
+      execSync(`chmod +x "${launchScript}"`, { stdio: "ignore" });
+
+      try {
+        try { execSync(`tmux kill-session -t ${tmuxName} 2>/dev/null`); } catch {} // 先清掉同名僵尸 session（spawn failed 的根）
+        execSync(
+          `tmux new-session -d -s ${tmuxName} -c "${personDir}" 'bash "${launchScript}"'`,
+          { stdio: "ignore" }
+        );
+      } catch (err: any) {
+        onError(`Hippocampus tmux spawn failed: ${err?.message ?? err}`);
+        running = false;
+      }
+    },
+
+    stop() {
+      running = false;
+      try { execSync(`tmux kill-session -t ${tmuxName} 2>/dev/null`); } catch {}
+    },
+
+    isRunning() { return tmuxHas(); },
+    getSessionId() { return tmuxName; },
+  };
+
+  return self;
+}
+
+// ── func 入口（default(pi)）：海马体编码器进程的装配 ─────────────────────────
+// 检测 personDir，agent 起来后 spawn hc-<id> tmux 持续编码（gen_work_mem）。
+export default function (pi: ExtensionAPI) {
+  const _cmds: any[] = [];
+  // 海马体 = 记忆 func（tag memory）。两部分：
+  //  1) 主意识里的记忆机能（注入各层 / editcontext / 容量监控 / nap·sleep 触发）
+  const _memoryCmds = registerMemory(pi);
+  if (_memoryCmds) _cmds.push(..._memoryCmds);
+  //  2) 后台独立 pi 小号（hc-）持续把 context 再反思进 work_memory
+  let handle: HippocampusHandle | null = null;
+  let personDir: string | null = null;
+  let hcDisabledNotified = false;
+
+  // ── /hippocampus 开关：禁用/启用后台记忆编码（每人持久，重启仍生效；不影响主意识快照/nap/sleep）──
+  _cmds.push({
+    name: "brain-hippocampus",
+    desc: "海马体(后台编码)开关：/brain-hippocampus [on|off]。off=停后台编码(主意识快照/nap/sleep 不受影响)，持久、重启仍生效。",
+    handler: async (args: any, ctx: any) => {
+      const pd = personDir;
+      if (!pd) { ctx.ui.notify("当前无 person 目录（主意识 session 才能切）。", "warning"); return; }
+      const a = (args ?? "").trim().toLowerCase();
+      if (a === "off") {
+        setHcDisabled(pd, true);
+        try { handle?.stop(); } catch {}
+        handle = null;
+        ctx.ui.notify("海马体已禁用（持久，重启仍生效）。主意识快照/nap/sleep 照常，只是不再后台自动编码 work_memory。/hippocampus on 恢复。", "info");
+      } else if (a === "on") {
+        setHcDisabled(pd, false);
+        hcDisabledNotified = false;
+        ctx.ui.notify("海马体已启用（下一轮起后台编码恢复）。", "info");
+      } else {
+        ctx.ui.notify(`海马体当前：${hcDisabled(pd) ? "禁用" : "启用"}。/hippocampus [on|off] 切换。`, "info");
+      }
+    },
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    const sf = ctx.sessionManager.getSessionFile();
+    personDir = getPersonDir(sf);
+  });
+
+  pi.on("agent_start", async () => {
+    if (handle?.isRunning()) return;
+    if (!personDir) return;
+    if (hcDisabled(personDir)) {
+      if (!hcDisabledNotified) {
+        hcDisabledNotified = true;
+        sendCustomMessage(pi, "memory-hippocampus-disabled", "海马体已禁用（/hippocampus on 恢复）");
+      }
+      return;
+    }
+    handle = createHippocampus(
+      pi,
+      (msg) => sendCustomMessage(pi, "hippocampus-error", `WARN: Hippocampus error: ${msg}`),
+      personDir,
+    );
+    // 防御：海马体启动出任何错（launcher 模板/tmux/任意异常）只记一条，绝不带崩主意识 pi。
+    // 这次 ${CAP} 写错就是因为没这层防护——一个小号 launcher 的 bug 直接 uncaughtException 把整个主意识崩了。
+    handle.start().catch((e: any) => {
+      try { sendCustomMessage(pi, "hippocampus-error", `WARN: 海马体启动异常（已隔离，不影响主意识）: ${e?.message ?? e}`); } catch {}
+    });
+  });
+
+  pi.on("session_shutdown", async () => {
+    handle?.stop();
+    handle = null;
+    personDir = null;
+  });
+
+  return _cmds;
+}

package/core/individual.bio.organs/brain.hippocampus/hippocampus.ts.CHANGELOG

@@ -0,0 +1,12 @@
+[2026-06-15] created（追踪本次重构），by Claude Code
+- 成为 func 唯一入口：把原 index.ts 的 default(pi)（session/agent_start/shutdown 装配）合并进来，
+  index.ts 作废删除。kernel 现在 import 本文件（brain.hippocampus/hippocampus.js）。
+- default(pi) 加 registerMemory(pi)：把主意识记忆系统接上（之前 memory 被错当独立 func/孤儿，从没加载）。
+  memory 是 tag 不是 func —— 记忆机能本就属于海马体这个 func。
+- prompt 内联：createHippocampus 里 HIPPOCAMPUS_PROMPT 改成 getPrompt("hippocampus.gen_work_mem")，
+  删掉中间层 prompt.ts / hippocampus.dna.ts。
+
+[2026-06-15 续] 加级联看门狗（by Claude Code）
+- hc 启动脚本加 MAIN_PID=主意识 pid + 后台子进程轮询 kill -0；主意识进程一退出 → 自动 tmux kill-session
+  把本 hc 实例连 tmux 一起关掉（循环顶也查一次）。解决"主程序死了 hc 还自启自跑、孤儿常驻烧钱"。
+- ⚠️ 当前正在跑的旧孤儿用的是没看门狗的旧脚本，需手动 tmux kill-session 清掉；之后由新 main spawn 出来的才带看门狗。

package/core/individual.bio.organs/brain.hippocampus/hippocampus.ts.LESSON

@@ -0,0 +1,22 @@
+# hippocampus.ts — LESSONS
+
+## 2026-06-16 海马体编码死循环——指数自激，烧出 424 个实例 + 2.8M context
+
+**症状**：潜意识反复预警(8+次)：海马体每个新实例都从 context.md **第 1 行**开始读，编码的第一条永远是"pi-coding-master 系统架构"，work_memory 全是重复。现场坐实：某 person 的 context.md 涨到 **2.8M / 47890 行**，`.data/hippocampus-sessions` 累积 **424 个 session**（每个即生即死 <30s）。连带把主意识顶到记忆 **120%**、反复强制归档(-758KB/-614KB)、深度 sleep 整合不完、主意识秒级崩溃重启、mouth"从头开始"念。
+
+**根因（两层）**：
+1. **offset 靠模型自觉 = 形同虚设**。gen_work_mem 提示词写了"读 work_memory 找上次时间戳、只处理之后的新内容"，但这要模型每轮自己定位——它做不到/不做，于是每轮从头读整个 context.md，把同样的东西反复编码。
+2. **正反馈自激**：海马体编码 → work_memory 膨胀 → 主意识快照含 work_memory → 主意识 context 变大 → 写回 context.md → 海马体下轮读到更多 → 指数增长。最后 context.md 大到一读就爆窗口 → 海马体报错退出 → bash `while true` 立刻重启全新实例 → 又从第 1 行开始 → 424 个即生即死。
+
+**修复**：把"只读增量"从**提示词靠自觉**改成**launcher 代码强制**（hippocampus.ts 生成的 bash）：
+- 维护一个 **byte offset 文件** `.data/.hc-offset`（存在文件里 → 重启也不丢）。
+- 每轮只 `tail -c +offset` 截出 context.md 的**新增段**写进 `.hc-new-slice.md`，喂给海马体；提示词同步改成"只读 .hc-new-slice.md，绝不读整个 context.md"。
+- **没有(够多)新内容就不启动编码**（sleep 30 再看）——掐断空轮自激 + 省钱 + 不刷 session。
+- 首次启动把 offset 设到 context.md 当前末尾 → 自动跳过已有的 2.8M 垃圾，从"现在"往后编码。
+- context.md 变短(重启清理)→ offset 自动归零。
+
+**教训 / 下次怎么避免**：
+- **凡是"跨进程/跨重启要记住进度"的状态，绝不能靠提示词让模型自己记——必须落到代码里的持久化 offset/游标**。模型每次重启是全新的，"找上次到哪了"这种事它做不可靠。
+- **警惕反馈环**：一个子系统的输出会不会重新流回它自己的输入？海马体编码 → 进快照 → 进 context → 海马体再读，就是典型自激。设计任何"读 A 写 B"的后台编码器，先问"B 会不会又变成 A 的一部分"。
+- **"自愈重启"会放大 bug**：bash `while true` 重启在正常时是兜底，但当单轮必然失败(读爆窗口)时，它把一个 bug 变成 424 倍的雪崩。重启循环要配合"失败原因不消除就别盲目重启"或"每轮代价受限(只读增量)"。
+- 排查记忆膨胀，先看 `.data/hippocampus-sessions` 的 session 数和 context.md 大小——数量异常 = 编码器在 crash-loop。

package/core/individual.bio.organs/brain.hippocampus/hippocampus.ts.SPEC

@@ -0,0 +1,16 @@
+source: hippocampus.ts @ 3b0c0219
+
+hippocampus.ts · SPEC（brain.hippocampus 的 func 入口）
+
+身份: brain.hippocampus 这个 func 的入口文件（default(pi) 在这里）。
+      memory 是 tag（标签），不是 func；海马体才是「记忆」这个 tag 下的 func。
+
+default(pi) 装两部分:
+1. registerMemory(pi)  —— 主意识身上的记忆机能（注入快照、editcontext、nap/sleep/dream、容量监控）。
+   代码在同目录 memory.ts。
+2. 后台 hc- 编码小号 —— agent_start 后 spawn tmux hc-<personId>，持续读 context.md、
+   再反思写 work_memory.md（gen_work_mem）。createHippocampus 工厂也在本文件。
+
+prompt: createHippocampus 给 hc- 子实例的系统 prompt = getPrompt("hippocampus.gen_work_mem")（coded.dna）。
+模式（promotor.dna）: DWN→gen_work_mem / sleep.night→deep_encode(sleep.ts) / sleep.nap→gen_work_mem。
+模块（promotor.dna 声明，尚未拆分实现）: workmem / cortexmem / deepcortexmem。