pi-coding-master 0.2.7

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

@@ -0,0 +1,66 @@
+[2026-06-15] 记忆系统大修（崩溃 + 缓存 + 静默失败），by Claude Code
+
+背景：实例反复崩 "400 max context 1048565, requested 1.15M"；状态栏显示 38% 却实际 113%；
+单日 49M tokens、16M 未命中（缓存被毁）；sleep 几天没真正运行。逐项修：
+
+1. estimateTokens：chars/4 → CJK-aware（CJK ×1.8 + 其余 /4）。
+   根因：chars/4 对中文少算约 7 倍 → 真 1.15M 只估成 ~38% → 容量永不报警、保护永不触发。
+   实测那份 1.5MB context：旧估 384,809（≈状态栏 38%），新估 598K（接近真实）。
+
+2. 注入加硬预算：MEMORY_BUDGET = 窗口×0.35，cortex/work/context 按 token 尾部切（sliceToTokens）。
+   原 isOverHalf 保护用 chars/4 误判（1.8MB 估成 467K < 500K）→ 不触发 → 全量注入撑爆。
+   修后：compacted 对话(~382K)+记忆(≤350K)+overhead < 1.048M，不再爆，pi compaction 终于有效。
+
+3. cortexPath ReferenceError：before_agent_start 里 sediment 用了未定义的 cortexPath（一触发就崩）
+   → 改成 path.join(personDir, "cortex.md")。
+
+4. sleep import 路径修复：import("./sleep-session.js") → import("./sleep.js")（文件实为 sleep.ts）。
+   原路径一直 import 失败 → sleep 工具掉进 catch → 独立 sl- 实例从未启动 → work→cortex 巩固是死的。
+
+5. sleep 失败不再假装成功：catch 原来返回 "😴 已进入睡眠(inline mode)" 笑脸 → 改成 ❌ 显眼报错 +
+   isError:true，且不再把 dnaState 置 sleep（没真睡着就别装睡）。这是"坏了为啥不报错"的直接元凶之一。
+
+6. 【缓存大修】注入架构改为「快照一次 + 增量后 append」：
+   - session_start：buildSnapshot() 注入稳定前缀【一次】（memory-snapshot 消息）。
+   - before_agent_start：删除所有 systemPrompt 注入，不再 return systemPrompt（前缀逐轮稳定 → 命中）。
+     work_memory 增量、容量提醒、到期提醒一律 sendMessage(deliverAs:nextTurn) 追加在末尾。
+     cortex 沉降 / events 修剪只写文件。
+   根因：旧逻辑每轮把增长的 context+notes 重灌进 systemPrompt（缓存前缀）→ 每轮全废 → 49M/天。
+   代价：会话中途后台整理的新 cortex 要下个会话才进快照（可接受）。
+   message_end 不回存 messageType 以 "memory-" 开头的注入消息（防反馈环）。
+
+未做（待定/属功能而非 bug）：work/cortex 分成 module workmem/cortexmem/deepcortexmem；
+sleep.ts 深睡接进 sleep.night duty；运行期自检/痛觉(health check)。
+
+⚠️ 改动要重启 pi 实例才生效（运行中的进程加载的是旧代码）。pi compaction 已是 enabled:false（保留）。
+
+[2026-06-15 续] 容量警告语义修正（"91% 危急" vs footer "42%" 的矛盾）
+- 病：警告用「原始文件总量」(context+work+cortex) 报 "记忆危急 X%、会崩"，但注入早已封顶 35% → 根本不会崩；
+  和 footer 的「实际注入 %」对不上，吓人又误导。
+- 修：警告改成说真话——同时点明 rawPct(文件占窗口%) 与 injCap(注入封顶%)，措辞从"危急/会崩"改成
+  "文件大了、超出封顶的旧记忆被截断、该 sleep 整理"。不再和 footer 打架。两个数测的本就是不同东西。
+
+[2026-06-15 续2] 撤掉所有切片，回到「整份注入」（守铁律 + 消除 91/42 矛盾）
+- 用户指令"不能 slice"。删掉 MEMORY_BUDGET、sliceToTokens、buildSnapshot 里的全部切片
+  → context + work_memory + cortex【整份】注入，不切。
+- 上一条"封顶35%不会崩"的容量警告随之作废：整份注入【会撑爆】，警告改回"危急、再涨会崩、立刻 sleep"。
+- 副作用(好的)：footer 的实际注入% 现在 ≈ 记忆文件% —— 之前"91% vs 42%"的矛盾正是切片造成的，已消除。
+- 代价(用户接受)：文件大于窗口会崩；防崩靠 sleep/nap 勤快压小（let the model decide），不靠机械切。
+- 缓存修复(快照一次 + 增量 append) 与 余额硬闸 均保留不变。
+
+[2026-06-15 续3] 加「超窗口兜底」破死锁（修"模型停下来/不working"）
+- 现象：context.md 涨到 ~1M token；纯"整份注入不切"→ 每轮撑爆窗口 → 模型停（且 hc 小号死了、没人把 context 压进 work）。
+  本质是纯 no-slice 在 context>窗口时的【死锁】：要它 sleep 缩小，但它撑爆跑不起来、就睡不了。
+- 修：buildSnapshot 默认仍整份注入（守"不切"）；cortex+work 永远全量；【仅当】整份会超过窗口 70% 时，
+  才把 context 切到「尾部刚好放得下」——保命优先（永不停止的生命，崩死比丢最旧 context 更糟），块标题 ⚠️ 提示去 sleep。
+- 容量警告同步：高占用 = "最旧 context 被兜底丢弃、该 sleep 把它编码走"（不再说"会崩"）。
+- 用户授权"赶紧修 bug，不管是什么"。这是对"绝对不切"的最小让步：平时绝不切，只在"切最旧 or 崩死"之间选活着。
+
+[2026-06-15 续4] 加「代码强制整理」（修"根本没有强制 sleep，只发消息靠模型自觉"）
+- 病：FORCE 线原来只 sendMessage "立刻 sleep"，全靠模型自觉去睡 → 它不睡 → 涨到 1M。
+  memory.dna.md 写的"85%→几乎强制 sleep"从来【没被写成代码】，只是条强烈措辞的消息。这才是 context 失控的根。
+- 修：FORCE 线代码直接调 forceArchiveOldestContext()——把最旧 ~30% context 整段搬进 deep_cortex（可回捞）、
+  从 context 删掉，【不等模型】。非有损（原文搬走，不是总结）、不写 work_memory（不碰海马体地界）、
+  只主进程做（getSessionRole()==="main"，防多实例抢写）。
+- 这才是真正的"代码强制"。配合 70% 注入兜底 = 双保险：归档让磁盘文件不失控，兜底让注入永不超窗口。
+[2026-06-19] memory 增量段改用包裹格式：---[hippocampus-work]--- / ---[context-delta]---，不再用旧 [] 格式

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

@@ -0,0 +1,25 @@
+# memory.ts — LESSONS
+
+## 2026-06-15 KV cache 靠「顺序」，不是靠「少注入」
+**背景**: 铁律是【整份注入、禁止 slice】，所以快照大（~90 万 token）是接受的；省钱靠 cache 命中，不靠切。
+**命中的前提（顺序，缺一不可）**:
+  1. systemPrompt 必须日内稳定 —— pi 自带的只塞 `Current date:`（每天变一次）+ cwd，OK；
+     我们 6 个 func 的 append 是常量、注册顺序固定，OK。**别往 systemPrompt 塞每轮变的东西**。
+  2. 记忆快照只在 session_start 注入【一次】，本会话绝不重发（before_agent_start 不 return systemPrompt）。
+  3. 快照内部顺序 = 稳定→易变：DNA → cortex → work_memory → context。前缀（DNA+cortex）跨会话能命中。
+  4. 一切新内容（work_mem 增量 / 容量提醒 / 到期 / date / 余额）一律 append 到 tail（deliverAs nextTurn）。
+**坑**: 任何排在快照【前面】且会变的消息，会让整份 90 万 token 快照 miss。已踩过的：budget-trip（见
+  [[budget-guard.ts.LESSONS]]）、双 unstop-date（见 [[bioclock.ts.LESSONS]]）。
+**还没解决（诚实）**: 当前 live 的 context 已涨到 65 万~86 万 token，整份注入下逼近 1M 窗口。
+  forceArchiveOldestContext 到 FORCE 线才搬最旧 30% 进 deep_cortex；长期要靠 sleep/nap 持续消化。
+  重启清掉臃肿 context 是最快的止血。capacity 监控用 CJK 估算（中文 ≈1.8 token/字，别用 chars/4，会少算 7 倍）。
+  （注：2026-06-16 已把 pi 自带的 `Current date:` 注入也从 system-prompt.js 去掉了——少一个每天变的东西，缓存更稳。见 [[../../../deploy.ALL/dist-overrides/system-prompt.js.LESSONS]]）
+
+## 2026-06-16 sleep 睡完根本没叫醒主意识——工具文案撒谎，onComplete 是个死回路
+**症状**: 问"睡好了会提醒模型吗"。查代码：sleep 工具返回文案写着"完成后会自动注入 wake feel"，但 launchSleepSession 的 onComplete 回调里**只有** `dnaState="wake"; sleepHandle=null`——只翻了个内部变量，从没调 sendMessage、没唤醒、没通知任何人。主意识 sleep 前若 hibernate 了(enabled=false)，就一直睡到用户来才醒。**文案承诺的功能，代码里根本不存在。**
+**根因**: `dnaState` 只在【下次】session_start 被读去选 wake.dlc/sleep.dlc，对正在跑/已 hibernate 的主意识毫无作用。唤醒要走 `pi.sendMessage({...},{isTriggerNewTurn:true})`（心脏 process.ts/stop.ts 唤醒就是这么干的），onComplete 一个都没用上。
+**修复（设计忠实，器官只走 pi）**:
+  - 海马体 onComplete：注入 `messageType:"sleep-done"` 的 wake feel + isTriggerNewTurn → 主意识被叫醒。
+  - 心脏 stop.ts：`pi.on("message_start")` 听到 sleep-done 就 `state.enabled=true` 重新点亮 continuous → 主意识真正活过来续命，而不是醒一个 turn 又僵住（hibernate 后 enabled=false，光 isTriggerNewTurn 一个 turn 完 agent_end 又停）。
+  - 跨器官不 import：海马体碰不到心脏的 state，心脏也不认识睡眠实例——只通过 pi 的 sleep-done 消息握手。这是这套架构里器官通信的唯一合法通道（grep 验证过：器官之间零互相 import）。
+**教训**: **工具返回文案写"完成后会自动 X"，必须去代码里确认真有 X。** 文案是给模型看的承诺，承诺和实现脱节 = 模型以为有这功能、其实是死的，比没写还坑（这张"自动注入 wake feel"的空头支票挂了不知多久）。查"完成后会怎样"，要一路追到真正 sendMessage/改状态那行，别看到个 `dnaState="wake"` 就以为闭环。

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

@@ -0,0 +1,46 @@
+source: memory.ts @ b60acb20
+
+memory.ts · SPEC（brain.hippocampus 的主意识记忆机能）
+
+设计来源: ideas.HUMAN/v0.2_spec.md + 2026-06-15 缓存/估算大修
+核心原则: context 就是记忆，模型自己编辑自己。let the model decide。
+归属: 不是独立 func（memory 是 tag，不是 func）。这是 brain.hippocampus 的代码，
+      由 hippocampus.ts 的 default(pi) 调 registerMemory(pi) 装上。
+
+── 文件结构 per-person（数据=存，在 ~/.pi/memory/<id>/.data/，不在代码树）──
+  context.md       ← 完整对话历史，message_end 增量写入，可被模型 editcontext
+  work_memory.md   ← 海马体(hc-)再反思编码（nap 也往这写），不过度压缩
+  cortex.md        ← 按叶分区长记忆（sleep 的 sl- 实例 1% 沉淀来的）
+  deep_cortex.md   ← cortex 超 20% 窗口时沉降来的归档（不自动注入，按需回捞）
+  events.jsonl / growth.jsonl / reminders.json ← 旁路数据
+
+── 注入架构（⚠️ 缓存铁律，2026-06-15 大修的核心）──
+  KV 缓存只在「提示词前缀逐轮一致」时命中。所以：
+  1. session_start（醒来）：buildSnapshot() 把 DNA + cortex + work + context(尾部)
+     按 token 预算(≤窗口35%)揉成「一份快照」，作为消息注入【一次】。这是稳定前缀。
+  2. before_agent_start：【绝不】return systemPrompt。前缀不动 → 每轮命中缓存。
+     只做三件事，全部往「后面」append 或只写文件：
+       - work_memory 增量：比上次多出来的部分，作为新消息追加（不重发全部）；
+       - 容量提醒：≥URGE(80%) 时 append 一条 [internal] 提醒（WARN 只记 growth.jsonl）；
+       - 后台整理：cortex 超 20% → 沉降到 deep_cortex；events 修剪；到期 reminder append。
+  3. 重建快照 = 下次醒来（session_start）。中途 sleep/nap 整理过的文件，下个会话才进新快照。
+     —— 这就是「前缀=上次睡醒的快照，会话中只往后贴，睡觉时再揉成新快照」，一个会话最多一次未命中。
+
+── token 估算（⚠️ 必须 CJK-aware）──
+  estimateTokens：CJK 字 ×1.8 token，其余 ÷4。
+  绝不能用 chars/4——中文少算约 7 倍，会让容量永不报警、注入撑爆窗口（历史事故：真 1.15M 只显示 38%）。
+
+── 注入预算 ──
+  MEMORY_BUDGET = 窗口 × 0.35（给对话+补全留 65%）。
+  分配：cortex ≤35%·work ≤20%·context 填剩余，各自按尾部 sliceToTokens 切。
+  → 配合 pi 自带 compaction：compacted 对话(~382K)+记忆(≤350K)+overhead < 1.048M，不爆。
+
+── 工具 ──
+  editcontext  双操作：edit context.md + append cortex.md（cortex_entry 必须非空）
+  nap          context 段 → work_memory（再反思，不一句话总结）
+  sleep        启动独立 sl- pi 实例做 1% 巩固（见 sleep.ts）。失败【显眼报错】，不再假装成功
+  dream        把 cortex 片段丢给潜意识做创造性反思
+  drinkcoffee  临时压制容量提醒 N 轮（不增容量）
+
+── 失败要可见（2026-06-15 教训）──
+  禁止空 catch 吞错 / 笑脸 fallback。坏了必须让主意识看见（否则像 sleep 那样静默死好几天）。

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

@@ -0,0 +1,139 @@
+// sleep-session.ts — Independent sleep pi instance launcher
+// v0.2 spec: 睡眠的 session 和潜意识一样都是一个 pi，激活 sleep.dlc
+// Launches in tmux as sl-<personId>. Self-healing with backoff.
+// Sleep pi only edits memory files; main consciousness continues working.
+
+import { execSync } from "node:child_process";
+import { writeFile, mkdir, readFile } from "node:fs/promises";
+import * as path from "node:path";
+import { getPrompt } from "#runtime";
+
+// prompt 来自 coded.dna（coded hippocampus.sleep），由 runtime 取，不再硬编码。
+// 海马体深睡期（sleep.night）的编码 prompt：把 work_memory 整段消化、一次性巩固进 cortex（见 coded.dna hippocampus.sleep）。
+let _sleepPrompt: string | null = null;
+function getSleepPrompt(): string {
+  if (!_sleepPrompt) _sleepPrompt = getPrompt("hippocampus.sleep");
+  return _sleepPrompt;
+}
+
+export function launchSleepSession(
+  personDir: string,
+  onComplete: () => void,
+): { stop: () => void; isRunning: () => boolean } {
+  // personDir 以 /.data 结尾 → personId 是上一级目录名。之前用 /([a-f0-9]+)$/ 匹配会落到 ".data" 上(取到 "a" 之类),
+  // tmux 名就乱了、也和显示对不上。统一取目录名。
+  const personId = path.basename(personDir) === ".data" ? path.basename(path.dirname(personDir)) : path.basename(personDir);
+  const tmuxName = `sl-${personId}`;
+  const sessionDir = path.join(personDir, "..", "sleep-sessions");
+  let running = false;
+
+  function tmuxHas(): boolean {
+    try {
+      execSync(`tmux has-session -t ${tmuxName} 2>/dev/null`);
+      return true;
+    } catch { return false; }
+  }
+
+  // Launch async
+  (async () => {
+    if (tmuxHas()) {
+      running = true;
+      return;
+    }
+
+    running = true;
+    await mkdir(sessionDir, { recursive: true });
+
+    // Build sleep prompt
+    let dnaIndex = "";
+    try { dnaIndex = await readFile(`${personDir}/dna/index.md`, "utf8"); } catch {}
+    let sleepDlc = "";
+    try { sleepDlc = await readFile(`${personDir}/dna/sleep.dlc`, "utf8"); } catch {}
+
+    const fullPrompt = `${dnaIndex}\n\n${sleepDlc}\n\n${getSleepPrompt()}\n\n文件目录: ${personDir}`;
+
+    const promptFile = `${personDir}/sleep-prompt.md`;
+    await writeFile(promptFile, fullPrompt);
+
+    const launchScript = `${personDir}/sleep-launch.sh`;
+    await writeFile(launchScript, `#!/bin/bash
+export NODE_OPTIONS="\${NODE_OPTIONS:+\$NODE_OPTIONS }--experimental-transform-types"
+SESSION_DIR=${JSON.stringify(sessionDir)}
+PERSON_DIR=${JSON.stringify(personDir)}
+PROMPT_FILE=${JSON.stringify(promptFile)}
+INITIAL="开始深度睡眠。主意识困到撑不住了。【分段】消化 context.md：每次只读最旧的一截（300~500 行，别一口吞，否则你自己也撑爆），重组进 cortex.md，cortex 装不下的沉 deep_cortex.md，消化完就把那一截从 context.md 删掉；一截截来，直到 context 小下来。work_memory.md 同理。全部弄完 hibernate。"
+export PI_PERSON_DIR="$PERSON_DIR"
+MAIN_PID=${process.pid}
+BACKOFF=15
+while true; do
+  # 级联：主意识进程没了就退出（睡眠是短任务，循环顶检查足够，不用常驻看门狗）。
+  kill -0 "$MAIN_PID" 2>/dev/null || { echo "[sl] 主意识没了，退出。"; break; }
+  START=$(date +%s)
+  mkdir -p "$SESSION_DIR"
+  # Write system prompt to conv.json (pi reads from session dir, --append-system-prompt doesn't exist)
+  LOCKDIR="$PERSON_DIR/.memory-lock"
+  LOCK_WAIT=0
+  while [ "$LOCK_WAIT" -lt 300 ]; do
+    if mkdir "$LOCKDIR" 2>/dev/null; then
+      echo "{\"owner\":\"sl\",\"ts\":$(date +%s)000}" > "$LOCKDIR/stamp" 2>/dev/null
+      break
+    fi
+    if [ -f "$LOCKDIR/stamp" ]; then
+      LOCK_TS=$(cat "$LOCKDIR/stamp" 2>/dev/null | grep -o '"ts":[0-9]*' | grep -o '[0-9]*')
+      NOW_MS=$(date +%s)000
+      if [ -n "$LOCK_TS" ] && [ $(( NOW_MS - LOCK_TS )) -gt 60000 ]; then
+        rm -f "$LOCKDIR/stamp" 2>/dev/null
+        rmdir "$LOCKDIR" 2>/dev/null
+        continue
+      fi
+    fi
+    LOCK_WAIT=$(( LOCK_WAIT + 1 ))
+    sleep 0.2
+  done
+  if [ "$LOCK_WAIT" -ge 300 ]; then
+    echo "[sl] 无法获取文件锁（60s 超时），跳过本轮" >> /dev/stderr
+    sleep 30
+    continue
+  fi
+  python3 -c "import json,shlex; open('$SESSION_DIR/conv.json','w').write(json.dumps({'messages':[{'role':'system','content':open('$PROMPT_FILE').read()}]}))" 2>/dev/null
+  echo "$INITIAL" | /opt/homebrew/bin/pi --session-dir "$SESSION_DIR"
+  CODE=$?  # save pi exit code BEFORE releasing lock
+  rm -f "$LOCKDIR/stamp" 2>/dev/null
+  rmdir "$LOCKDIR" 2>/dev/null
+  RAN=$(( $(date +%s) - START ))
+  if [ "$CODE" -eq 0 ]; then
+    echo "[$(date '+%F %T')] sleep pi OK — work_memory should be cleared."
+    break
+  fi
+  if [ "$RAN" -ge 120 ]; then BACKOFF=15; else BACKOFF=$(( BACKOFF * 2 )); [ "$BACKOFF" -gt 300 ] && BACKOFF=300; fi
+  echo "[$(date '+%F %T')] sleep pi exit=$CODE ran=$RAN s — restart in $BACKOFF s"
+  sleep "$BACKOFF"
+done
+`);
+    execSync(`chmod +x "${launchScript}"`, { stdio: "ignore" });
+    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" }
+    );
+
+    // Check periodically and call onComplete when work_memory is empty
+    const checker = setInterval(() => {
+      if (!tmuxHas()) {
+        clearInterval(checker);
+        running = false;
+        onComplete();
+      }
+    }, 5000);
+  })();
+
+  return {
+    stop() {
+      running = false;
+      try { execSync(`tmux kill-session -t ${tmuxName} 2>/dev/null`); } catch {}
+    },
+    isRunning() {
+      return running && tmuxHas();
+    },
+  };
+}

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

@@ -0,0 +1,11 @@
+[2026-06-15] created（追踪本次重构），by Claude Code
+- 从 brain.hippocampus/hippocampus.sleep/sleep.ts 移到 brain.hippocampus/sleep.ts（扁平化，去掉嵌套子目录）。
+- import 深度随之 4 层→3 层：getPrompt 从 "../../../../engine/runtime.js" → "../../../engine/runtime.js"。
+- prompt 改走 coded.dna：const SLEEP_PROMPT = getPrompt("hippocampus.sleep")，不再硬编码。
+- 配套修复（在 memory.ts）：sleep 工具的 import 从 "./sleep-session.js" 改成 "./sleep.js"——
+  原路径一直 import 失败 → sleep 从未真正启动。详见 memory.ts.CHANGELOG。
+
+[2026-06-15 续] 加级联退出（by Claude Code）
+- sleep 启动脚本加 MAIN_PID + 循环顶 kill -0 检查：主意识没了就退出。
+- 不用常驻看门狗（睡眠是短任务：编码完 CODE 0 就 break 退出，常驻看门狗会卡住 tmux、让 onComplete 永不触发）。
+- 注意：主意识 hibernate ≠ 进程死。hibernate 时进程还在，kill -0 仍为真，sleep 照常完成。

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

@@ -0,0 +1,16 @@
+source: sleep.ts @ 4a509a76
+
+sleep.ts · SPEC（深睡：独立 sl- pi 实例启动器）
+
+归属: brain.hippocampus 的代码（sleep.night 模式的巩固实现）。
+被谁调: memory.ts 的 sleep 工具 → import("./sleep.js") → launchSleepSession(personDir, onComplete)。
+
+做什么:
+- 在 tmux 起一个【独立 pi 实例】sl-<personId>（对标 hc-/sc-，是第三个对等独立意识，DNA 铁律）。
+- 加载 dna/index.md + dna/sleep.dlc + SLEEP_PROMPT(coded hippocampus.sleep)。
+- 按 1% partial edit 把 work_memory.md 逐块编码进 cortex.md（不一次全搬）。
+- 自愈：崩了带指数退避重启；work_memory 清空后 onComplete() → 主意识切回 wake。
+- 主意识调 sleep 后可 hibernate，整理由这个独立实例完成。
+
+prompt: 来自 coded.dna 的 `coded hippocampus.sleep`，经 ../../../engine/runtime.js 的 getPrompt 取。
+注意: 文件名是 sleep.ts（不是 sleep-session.ts）。memory.ts 必须 import("./sleep.js")。

package/core/individual.bio.organs/brain.prefrontal.drafting/drafting.SPEC

@@ -0,0 +1,44 @@
+always_think 模块 v0.2 · SPEC
+
+设计来源: 2026-06-14 对话 + ideas.HUMAN/v0.2_spec.md 第 2 行(打断-续写引擎)
+核心问题: 模型写代码/说话时"脑就是手"——生成即动作,中间没有审查闸,
+          被参数里的思维定势(切片/复制/增量等惯例)直接冲成输出,自己感觉不到。
+
+核心原则:
+  - 不是"先想后做"(prefix 式,执行一旦开始仍是弹道式),
+    而是"边写边想"——思考在动作进行中随时发生,且可回到断点续写。
+  - 人写东西不是一次性不停预测 token:写的过程中会停下来想。模型也该能。
+  - 该停就停,尤其在: 就要 commit 一个不可逆判断时 / "这样写很顺手"但没核对 spec 时 / 直觉与约束打架时。
+
+机制(纯 mod,不新增 dist 补丁):
+  1. 模型在输出任意位置写下标记: <need think>
+  2. message_update 钩子读到半截 assistant 文本里出现该标记
+  3. mod 投递一条 steer 消息: pi.sendMessage({...}, {deliverAs:"steer", isTriggerNewTurn:true})
+  4. 经 unstop 的 steer→abort dist 补丁(agent.js: steer() 时 activeRun.abortController.abort()),
+     当前生成被 abort = 写作暂停;半截输出(以 <need think> 结尾)由 pi 原生 partial 机制保留进 context
+  5. steer 消息内容提示模型"现在想透,再从断点续写" → 模型转入思考 + 续写
+  6. 一次输出里可触发任意多次(允许在中间想无数次)
+
+依赖:
+  - unstop 的 steer→abort 补丁(若该补丁不在,steer 不会暂停当前生成,本模块退化为"下一轮才生效")
+
+钩子:
+  before_agent_start → 注入约定 prompt(教模型 <need think> 的用法),仅 enabled 时
+  agent_start        → 重置每轮暂停计数
+  message_start      → 重置"本条消息已触发"标志(每条新 assistant 消息可重新触发)
+  message_update     → 检测标记 → 触发暂停
+  registerCommand("always_think") → on/off 开关
+
+保护:
+  - per-message guard: 一个标记只触发一次(abort 生效前的残余 delta 不重复触发)
+  - per-turn 上限(MAX_PAUSES_PER_TURN, 暂定 50)防病态死循环;到顶不再触发
+
+标记:
+  默认 "<need think>"(常量,可改)。选用不与模型原生 reasoning 标签冲突的形式。
+
+已知限制 / 待办(诚实记录,需 live 测试):
+  - v1 只做"暂停-思考-续写";<need think> 标记会留在最终输出文本里(后续用 MessageRenderer 美化成"💭 暂停思考"指示)
+  - 续写是"在半截后另起一条 assistant 消息,模型看着自己半截+提示接着写",非字面同一 token 流延续(对目的够用)
+  - 更深形态(ideas 第 2 行的"或者"分支): 任何 command 是缓存里的可编辑文本文件,
+    模型写时可 edit/删/调(像人打字回删)。这是"草稿缓冲",比暂停-续写更难,留作后续。
+  - mid-stream 检测+abort 存在 race(abort 生效前的在途 delta),靠 guard 兜;真实表现需在 live pi 验证。

package/core/individual.bio.organs/brain.prefrontal.drafting/drafting.ts

@@ -0,0 +1,73 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { getPrompt } from "#runtime";
+
+// 模型在输出任意位置写下这个标记 → 写作暂停 → 思考 → 从断点续写。
+const MARKER = "<need think>";
+// 防病态死循环:一轮里最多暂停这么多次(允许多次,但不是无限)。
+const MAX_PAUSES_PER_TURN = 50;
+
+// prompt 来自 coded.dna（coded drafting.think）。正文里的 {MARKER} 占位由本 func 填入真实标记。
+const PROMPT = getPrompt("drafting.think").replace("{MARKER}", MARKER);
+
+function assistantText(message: any): string {
+  const content = message?.content;
+  if (!content) return "";
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  let s = "";
+  for (const c of content) {
+    if (typeof c === "string") s += c;
+    else if (c?.type === "text" && typeof c.text === "string") s += c.text;
+  }
+  return s;
+}
+
+export function registerAlwaysThink(pi: ExtensionAPI) {
+  let enabled = true;
+  let triggeredForCurrentMessage = false;
+  let pausesThisTurn = 0;
+
+  // ── 教模型 <need think> 的用法 ──────────────────────────────────
+  pi.on("before_agent_start", async (event, _ctx) => {
+    if (!enabled) return;
+    return { systemPrompt: event.systemPrompt + "\n\n" + PROMPT };
+  });
+
+  // ── 每轮开始:重置暂停计数 ──────────────────────────────────────
+  pi.on("agent_start", async () => {
+    pausesThisTurn = 0;
+  });
+
+  // ── 每条新 assistant 消息:重置"已触发"标志 ────────────────────
+  pi.on("message_start", async () => {
+    triggeredForCurrentMessage = false;
+  });
+
+  // ── 流式中检测标记 → 暂停 ───────────────────────────────────────
+  pi.on("message_update", async (event, _ctx) => {
+    if (!enabled) return;
+    if (triggeredForCurrentMessage) return;          // 一个标记只触发一次
+    if (pausesThisTurn >= MAX_PAUSES_PER_TURN) return; // 到顶不再触发
+
+    const text = assistantText(event.message);
+    if (!text.includes(MARKER)) return;
+
+    // 暂停:投一条 steer 消息。经 continuous 的 steer→abort 补丁,当前生成被 abort
+    // = 写作冻在断点;半截输出(以 <need think> 结尾)由 pi 原生 partial 机制保留。
+    // 随后这条 steer 被处理 → 模型转入思考,再从断点续写。
+    triggeredForCurrentMessage = true;
+    pausesThisTurn++;
+
+    pi.sendMessage(
+      {
+        messageType: "always-think-pause",
+        content:
+          "[你写下了 <need think> —— 写作已暂停。现在把它想透:你正要写的东西、你的直觉、" +
+          "以及它和 spec/约束是否一致;想清楚后从断点继续写。想透了再写,别急着续。]",
+        display: false,
+      },
+      { deliverAs: "steer", isTriggerNewTurn: true }
+    );
+  });
+
+}

package/core/individual.bio.organs/brain.prefrontal.drafting/drafting.ts.CHANGELOG

@@ -0,0 +1,3 @@
+[2026-06-15] by Claude Code
+- PROMPT([ALWAYS THINK]/边写边想) 改为 getPrompt("drafting.think").replace("{MARKER}", MARKER)；
+  {MARKER} 占位由本 func 填真实标记 <need think>。从 coded.dna 取，不再硬编码。

package/core/individual.bio.organs/brain.prefrontal.drafting/drafting.ts.SPEC

@@ -0,0 +1,24 @@
+source: drafting.ts @ 2eb28026
+
+# drafting.ts — Pre-thinking injection: pause-and-think during generation
+
+## 职责
+Implements "always think" (边写边想): when the model writes `<need think>` mid-output, generation is paused via steer-triggered abort, a thinking prompt is injected, and the model resumes from the breakpoint after reflection. Allows the model to self-interrupt for deeper reasoning during long outputs.
+
+## 接口
+- `registerAlwaysThink(pi: ExtensionAPI): void` — installs hooks and /always_think command
+
+## 依赖
+- `#runtime` (getPrompt for "drafting.think")
+- `@mariozechner/pi-coding-agent` (ExtensionAPI)
+
+## 行为要点
+- Marker `<need think>` is detected in streaming assistant output via message_update hook
+- On detection: sends a steer message (messageType "always-think-pause") that aborts current generation
+- Partial output preserved by pi's native partial mechanism; model continues from breakpoint
+- Max 50 pauses per turn (MAX_PAUSES_PER_TURN) to prevent pathological loops
+- Each marker triggers only once per message (triggeredForCurrentMessage flag)
+- Pause counter resets on agent_start; trigger flag resets on message_start
+- /always_think [on|off] command toggles the feature
+- Prompt text from coded.dna with {MARKER} placeholder replaced at load time
+- Depends on unstop's steer->abort dist patch (agent.js: steer() triggers abortController.abort())

package/core/individual.bio.organs/brain.prefrontal.drafting/index.ts.CHANGELOG

@@ -0,0 +1,3 @@
+[2026-06-15] by Claude Code
+- 修坏的 import：registerAlwaysThink 从 "./always_think.js"（文件不存在）→ "./drafting.js"（真实文件）。
+  原来一直 import 失败，predrafting func 实际加载不了。

package/core/individual.bio.organs/brain.prefrontal.drafting/main.ts

@@ -0,0 +1,13 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { registerAlwaysThink } from "./drafting.ts";
+
+// always_think — 边写边想(草稿态)
+// 模型写东西时,脑不该"就是手"。允许它在输出任意位置打一个 <need think> 标记,
+// 写作立即暂停(自触发 mid-stream abort),模型转入思考,想透后从断点续写。
+// 一次输出里可以这样停想任意多次。
+//
+// 依赖:continuous 的 steer→abort dist 补丁(agent.js: steer() 时 abortController.abort())。
+// 这个补丁让"投递一条 steer 消息"等价于"暂停当前生成",always_think 就建在它上面。
+export default function (pi: ExtensionAPI) {
+  registerAlwaysThink(pi);
+}

package/core/individual.bio.organs/brain.prefrontal.drafting/main.ts.SPEC

@@ -0,0 +1,17 @@
+source: main.ts @ 7b20157d
+
+# index.ts — Drafting entry: wires always-think
+
+## 职责
+Entry point for the brain.prefrontal.drafting func. Delegates entirely to registerAlwaysThink from drafting.ts. Serves as the thin func entry that kernel imports via #drafting.
+
+## 接口
+- `default(pi: ExtensionAPI): void` — func entry called by kernel
+
+## 依赖
+- `./drafting.js` (registerAlwaysThink)
+- `@mariozechner/pi-coding-agent` (ExtensionAPI)
+
+## 行为要点
+- Pure delegation: no additional logic
+- Depends on unstop's steer->abort dist patch for mid-stream pause to work

package/core/individual.bio.organs/brain.senses.bioclock/bioclock.ts

@@ -0,0 +1,94 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+
+export default function (pi: ExtensionAPI) {
+  pi.on("session_start", async (_event, ctx) => {
+    const now = new Date();
+    const date = `${now.getFullYear()}-${String(now.getMonth()+1).padStart(2,"0")}-${String(now.getDate()).padStart(2,"0")}`;
+    // pi-coding-master: startup 只留 logo，不显示 Current date 通知
+    pi.sendMessage(
+      { messageType: "continuous-date", content: `Current date: ${date}. Timestamps are wall-clock.`, isDisplayedInTUI: false },
+      { deliverAs: "nextTurn" }
+    );
+  });
+
+  function fmt(ts: number): string {
+    const d = new Date(ts);
+    const p2 = (n: number) => String(n).padStart(2, "0");
+    const p3 = (n: number) => String(n).padStart(3, "0");
+    return `${d.getFullYear()}-${p2(d.getMonth() + 1)}-${p2(d.getDate())} ${p2(d.getHours())}:${p2(d.getMinutes())}:${p2(d.getSeconds())}.${p3(d.getMilliseconds())}`;
+  }
+
+  // Only stamp user and toolResult messages (input side).
+  // Assistant messages are the model's own output — it knows when it spoke.
+  // Return { message } to properly replace, not mutate in place.
+  pi.on("message_end", async (event, _ctx) => {
+    const msg = event.message;
+    if (!msg) return;
+
+    const role = (msg as any).role;
+    if (role !== "user") return;
+
+    const ts = (msg as any).timestamp;
+    if (!ts || typeof ts !== "number") return;
+
+    const tag = ` [${fmt(ts)}]`;
+    const content = (msg as any).content;
+
+    if (typeof content === "string") {
+      return { message: { ...msg, content: content.replace(/\s+$/, "") + tag } };
+    }
+
+    if (!Array.isArray(content)) return;
+
+    const newContent = content.map((c: any, i: number, arr: any[]) => {
+      // Find last text block
+      const isLastText =
+        c.type === "text" &&
+        typeof c.text === "string" &&
+        !arr.slice(i + 1).some((x: any) => x.type === "text");
+      if (isLastText) {
+        return { ...c, text: c.text.replace(/\s+$/, "") + tag };
+      }
+      return c;
+    });
+
+    return { message: { ...msg, content: newContent } };
+  });
+
+  // ── Per-tool timing: stamp each tool result with finish time + duration ──
+  // Embedded in the result itself, so the model knows exactly how long
+  // each command took. No duplicate-timestamp noise.
+  const toolStart = new Map<string, number>();
+
+  pi.on("tool_execution_start", async (event) => {
+    const id = (event as any).toolCallId;
+    if (id) toolStart.set(id, Date.now());
+  });
+
+  pi.on("tool_result", async (event, _ctx) => {
+    const id = (event as any).toolCallId;
+    const start = id ? toolStart.get(id) : undefined;
+    if (id) toolStart.delete(id);
+
+    const now = new Date();
+    const p2 = (n: number) => String(n).padStart(2, "0");
+    const time = `${p2(now.getHours())}:${p2(now.getMinutes())}:${p2(now.getSeconds())}.${String(now.getMilliseconds()).padStart(3,'0')}`;
+    const dur = start ? ` +${((Date.now() - start) / 1000).toFixed(1)}s` : "";
+    const tag = `\n[${time}${dur}]`;
+
+    const content = (event as any).content;
+    if (!Array.isArray(content)) return;
+
+    const textBlocks = content.filter((c: any) => c.type === "text" && typeof c.text === "string");
+    if (textBlocks.length === 0) return;
+
+    const newContent = content.map((c: any) => {
+      if (c === textBlocks[textBlocks.length - 1]) {
+        return { ...c, text: c.text.replace(/\s+$/, "") + tag };
+      }
+      return c;
+    });
+
+    return { content: newContent };
+  });
+}

package/core/individual.bio.organs/brain.senses.bioclock/bioclock.ts.LESSON

@@ -0,0 +1,13 @@
+# bioclock.ts — LESSONS
+
+## 2026-06-15 双时间戳 = standalone 旧重复体被 install.sh 部署回来
+**症状**: 每条消息出现两遍时间戳 / 两条 "Current date"。
+**根因**: bioclock（bios，由 kernel 装配）已负责时间戳；但 install.sh 还 `cp` 了独立的
+  `extensions.DEV/timestamps.ts` 到 `~/.pi/agent/extensions/`，pi 按目录扫描把它当独立扩展【二次加载】
+  → 两个都注入。`wise_file` vs bios `fileactions` 同理。
+**修复**: ①注释掉 install.sh 里 `cp timestamps.ts*` / `cp -r wise_file` 两行；
+  ②live 端把 `timestamps.ts` 改名 `*.DISABLED-dup-of-bioclock`（非删除、可逆，pi 不再加载）。
+**原则**: 一个机能合进 bios（kernel 装配）后，必须把旧的 standalone 版从部署里去掉。
+  bios 版与 standalone 版是同一机能的两份实现 → 二选一，绝不共存，否则 pi 目录扫描双加载。
+**附**: bioclock 给消息打时间戳是在 message_end / tool_result 时【一次性】打到那条消息上（基于消息自己固定的
+  timestamp），历史消息不会被重新打时间 → 不破坏 KV cache。这点是对的，别改成每轮重算。

package/core/individual.bio.organs/brain.senses.bioclock/bioclock.ts.SPEC

@@ -0,0 +1,20 @@
+source: bioclock.ts @ 959d9031
+
+# bioclock.ts — Biological clock: timestamps on messages and tool results
+
+## 职责
+Gives the model awareness of wall-clock time. Injects current date at session_start, appends high-resolution timestamps to user messages (message_end), and stamps tool results with finish time + duration (tool_result). This lets the model know when events happened and how long tools took.
+
+## 接口
+- `default(pi: ExtensionAPI): void` — func entry called by kernel
+
+## 依赖
+- `@mariozechner/pi-coding-agent` (ExtensionAPI)
+
+## 行为要点
+- **session_start**: notifies UI with current date, sends date message (messageType "unstop-date") as nextTurn
+- **message_end**: appends `[YYYY-MM-DD HH:MM:SS.mmm]` timestamp to the last text block of user messages only; skips assistant messages
+- **tool_result**: appends `[HH:MM:SS +Ns]` (finish time + duration since tool_execution_start) to last text block of tool results
+- Uses a Map keyed by toolCallId to track tool start times
+- Only stamps user-role messages (model knows when it spoke)
+- Returns `{ message }` for message_end rewrites (proper replacement, not mutation)