pi-coding-master 0.2.7

package/core/individual.bio.organs/brain.senses.subconscious/feed-format.SPEC

@@ -0,0 +1,56 @@
+# conscious-feed.jsonl 数据格式规范
+
+> 写入：subconscious/index.ts message_end
+> 读取：tools.ts read_conscious
+> 消费者：潜意识（通过 read_conscious 读历史，用 aware 发送反思）
+
+## 铁律
+
+- 每行一条 JSON，`role` + `type` 唯一确定一种记录
+- **role** = 谁产生的：`user` | `assistant` | `system`
+- **type** = 具体干什么：见下表
+- 所有记录必有 `ts` (unix ms)
+- **主意识和潜意识共用同一个 feed**，但 type 体系各自独立——潜意识的 type（如 aware）只由潜意识写入，主意识的 type 只由主意识写入。写入时按 role 区分来源，读取时按 role 过滤。
+
+---
+
+## role 枚举
+
+| role | 含义 | 写入者 |
+|------|------|--------|
+| `user` | 用户输入 | 主意识 session (input 事件) |
+| `assistant` | 模型产出 | 主意识 session (message_end 事件) |
+| `system` | 系统消息 | 主意识 + 潜意识 |
+
+---
+
+## type 枚举（主意识侧）
+
+| type | role | 内容字段 | 示例 |
+|------|------|---------|------|
+| `user_msg` | `user` | `content: string` | `{"role":"user","type":"user_msg","content":"你好","ts":...}` |
+| `think` | `assistant` | `think: string` | `{"role":"assistant","type":"think","think":"内部推理","ts":...}` |
+| `text` | `assistant` | `text: string` | `{"role":"assistant","type":"text","text":"回复内容","ts":...}` |
+| `mouth` | `assistant` | `content: string` | `{"role":"assistant","type":"mouth","content":"朗读文本","ts":...}` |
+| `toolCall` | `assistant` | `tool: {name, args}` | `{"role":"assistant","type":"toolCall","tool":{"name":"bash","args":"ls"},"ts":...}` |
+| `toolResult` | `system` | `content: string` | `{"role":"system","type":"toolResult","content":"file1 file2","ts":...}` |
+| `start_msg` | `system` | `content: string` | `{"role":"system","type":"start_msg","content":"系统提示词/date","ts":...}` |
+
+---
+
+## type 枚举（潜意识侧——独立体系，待设计）
+
+| type | role | 内容字段 | 示例 |
+|------|------|---------|------|
+| `aware` | `system` | `title, thought, strength` | `{"role":"system","type":"aware","title":"...","thought":"...","strength":0.8,"ts":...}` |
+
+⚠️ 潜意识目前有自己的 feed 写入逻辑，**不要用主意识的 type 去框它**。潜意识需要另外设计 role 和 type。当前只确保主意识侧的格式正确，潜意识侧不改动。
+
+---
+
+## 设计约束
+
+1. **不用 `content` 数组**：不再嵌套 `[{type:"thinking"}, {type:"text"}]`。一条 feed entry = 一个 think 或一个 text 或一个 toolCall。
+2. **`text` 和 `think` 分两条写**：模型一次产出包含 think+text 时，拆成两条独立 entry。
+3. **纯 think（无 text）不丢弃**：think 需要进入 feed，供潜意识反思主意识的思考过程。
+4. **mouth 保留 `content` 字段**：mouth 是 TTS 朗读文本，不需要拆分 text/think。

package/core/individual.bio.organs/brain.senses.subconscious/index.ts.CHANGELOG

@@ -0,0 +1,13 @@
+[2026-06-12 15:14:18] edited (auto-logged, no messageDescription)
+[2026-06-12 15:14:18] fix: register read_conscious tool in RPC subprocess (was missing after refactor, subconscious could only speak via aware but couldn't read main session history)
+[2026-06-12 16:22:37] edited (auto-logged, no messageDescription)
+[2026-06-12 16:22:42] edited (auto-logged, no messageDescription)
+[2026-06-12 16:22:50] edited (auto-logged, no messageDescription)
+[2026-06-15] fix: aware 显示不全/丢失（by Claude Code）
+  ① 渲染器正则 /^\[(...)\]\s*(.*)/  →  /^\[(...)\]\s*([\s\S]*)$/
+     —— .* 不匹配换行，多行 thought 被截成只剩第一行（这是"aware 没显示全"的根因）。
+  ② aware watcher 只消费"完整行"(以 \n 结尾)，末尾写了一半的 JSON 行留到下次事件再处理；
+     原来半截行 parse 失败被跳过、offset 却已推过 → 那条 aware 彻底丢失。现已防住。
+  也内联了 getPrompt("subconscious.observe")（去掉 prompt.ts 中间层）+ 级联看门狗（见 subconscious.ts.CHANGELOG）。
+[2026-06-19] 消息包裹转义：thought 内容中的 ---[/ 闭合标签被转义，防止包裹提前闭合
+[2026-06-19] 潜意识消息缩进对齐：paddingX 0→1，和工具调用卡片的缩进一致

package/core/individual.bio.organs/brain.senses.subconscious/spawner.ts

@@ -0,0 +1,130 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { execSync } from "node:child_process";
+import { writeFile, mkdir } from "node:fs/promises";
+import { appendFileSync } from "node:fs";
+import { getPrompt } from "#runtime";
+
+export interface SubconsciousHandle {
+  start(): void;
+  stop(): void;
+  isRunning(): boolean;
+  getMessages(): any[];
+  getSessionId(): string;
+  getSessionDir(): string;
+}
+
+export function createSubconscious(
+  pi: ExtensionAPI,
+  getTranscriptPath: () => string | undefined,
+  onError: (msg: string) => void,
+  onMessage: (msg: any) => void,
+  personDir: string,
+): SubconsciousHandle {
+  const personId = personDir.match(/([a-f0-9]+)$/)?.[1] ?? "x";
+  const tmuxName = `sc-${personId}`;
+  const sessionDir = `${personDir}/.data/conscious-sessions`;
+  let running = false;
+
+  function tmuxHas(): boolean {
+    try {
+      execSync(`tmux has-session -t ${tmuxName} 2>/dev/null`);
+      return true;
+    } catch { return false; }
+  }
+
+  const self: SubconsciousHandle = {
+    async start() {
+      running = true;
+      try { appendFileSync("/tmp/sc-spawn.log", `[${new Date().toISOString()}] start() called, tmuxHas=${tmuxHas()}\n`); } catch {}
+      if (tmuxHas()) {
+        // tmux session 在但进程可能死了（空壳）——检查 pane 是否有活进程
+        try {
+          const pid = execSync(`tmux list-panes -t ${tmuxName} -F '#{pane_pid}' 2>/dev/null`).toString().trim();
+          if (pid) {
+            const children = execSync(`pgrep -P ${pid} 2>/dev/null`).toString().trim();
+            if (children) return; // 有子进程在跑，真的活着
+          }
+        } catch {}
+        // 空壳，杀掉重建
+        try { execSync(`tmux kill-session -t ${tmuxName} 2>/dev/null`); } catch {}
+      }
+
+      await mkdir(sessionDir, { recursive: true });
+
+      const feedPath = getTranscriptPath() ?? `${personDir}/.data/conscious-feed.jsonl`;
+      const promptFile = `${personDir}/.data/conscious-prompt.md`;
+      await writeFile(promptFile, `${getPrompt("subconscious.observe")}
+
+Main session history (read it regularly for new content): ${feedPath}
+Send thoughts to the main session with the aware tool.`);
+
+      // Subconscious = a real pi running inside tmux (real TTY, native rendering).
+      // continuous extension inside keeps it alive during a run; this launcher keeps it
+      // alive ACROSS runs — if pi crashes/exits (e.g. insufficient balance exits the
+      // process outright), wait with backoff and restart. When the condition clears
+      // (balance topped up), it auto-recovers. Killed when the conscious session ends.
+      // User watches it with: tmux attach -t sc-<id> -r  (read-only)
+      try {
+        const initialPrompt = "开始你的工作：持续阅读主意识的历史记录，反思，发现问题就用 aware 告诉主意识。";
+        const launchScript = `${personDir}/.data/conscious-launch.sh`;
+        await writeFile(launchScript, `#!/bin/bash
+# Self-healing subconscious launcher (auto-generated). Restarts pi with backoff on exit.
+export NODE_OPTIONS="\${NODE_OPTIONS:+\$NODE_OPTIONS }--experimental-transform-types"
+SESSION_DIR=${JSON.stringify(sessionDir)}
+PROMPT_FILE=${JSON.stringify(promptFile)}
+INITIAL=${JSON.stringify(initialPrompt)}
+MAIN_PID=${process.pid}
+FEED_FILE=${JSON.stringify(feedPath)}
+# 级联看门狗：主意识进程一退出，就连本 tmux 一起关掉（防孤儿常驻烧钱）。
+( while kill -0 "$MAIN_PID" 2>/dev/null; do sleep 5; done; echo "[sc] 主意识已退出，自动关闭本实例。"; tmux kill-session -t ${tmuxName} 2>/dev/null ) &
+BACKOFF=15
+PREV_SIZE=0
+while true; do
+  kill -0 "$MAIN_PID" 2>/dev/null || { echo "[sc] 主意识没了，退出。"; break; }
+  # 只有 feed 有新内容（主意识有活动）才启动
+  CURR_SIZE=$(stat -f%z "$FEED_FILE" 2>/dev/null || echo 0)
+  if [ "$CURR_SIZE" -le "$PREV_SIZE" ]; then sleep 30; continue; fi
+  PREV_SIZE=$CURR_SIZE
+  START=$(date +%s)
+  mkdir -p "$SESSION_DIR"
+  python3 -c "import json; open('$SESSION_DIR/conv.json','w').write(json.dumps({'messages':[{'role':'system','content':open('$PROMPT_FILE').read()}]}))" 2>/dev/null
+  # 初始消息作为位置参数传入，stdin 保持 tmux TTY（让 TUI 正常渲染）
+  BLACKBOX="$HOME/smart-pi/pi-coding-master.DEV/Codebase/debug/god.pi.blackbox/blackbox.sh"
+  if [ -x "$BLACKBOX" ]; then
+    "$BLACKBOX" "${personId}" "sc-${personId}" "subconscious" -- /opt/homebrew/bin/pi --session-dir "$SESSION_DIR" "$INITIAL"
+  else
+    /opt/homebrew/bin/pi --session-dir "$SESSION_DIR" "$INITIAL"
+  fi
+  CODE=$?
+  RAN=$(( $(date +%s) - START ))
+  if [ "$RAN" -ge 120 ]; then BACKOFF=15; else BACKOFF=$(( BACKOFF * 2 )); [ "$BACKOFF" -gt 300 ] && BACKOFF=300; fi
+  echo "[$(date '+%F %T')] subconscious pi exited (code=$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" }
+        );
+      } catch (err: any) {
+        try { appendFileSync("/tmp/sc-spawn.log", `[${new Date().toISOString()}] SPAWN FAILED: ${err?.stack ?? err}\n`); } catch {}
+        onError(`Subconscious 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(); },
+    getMessages() { return []; },
+    getSessionId() { return tmuxName; },
+    getSessionDir() { return sessionDir; },
+  };
+
+  return self;
+}

package/core/individual.bio.organs/brain.senses.subconscious/spawner.ts.SPEC

@@ -0,0 +1,13 @@
+source: spawner.ts @ 443d6408
+
+潜意识扩展入口。
+
+用户原话："应该是潜意识激活的，潜意识是另一个 pi session，这个始终内部自动运行，
+并且能看到明窗口的内容，在有的时候可以往明窗口说话。"
+"模型不是表演给人看的，一定是做给自己的。"
+
+启动时在进程内创建一个潜意识 AgentSession，只有 read_conscious 和 aware 两个工具。
+潜意识和明 session 共享同一个生命周期——明 session 启动时启动，关闭时关闭。
+潜意识也是活的，用 wait 歇一会然后自动醒。
+
+详细设计见 Smart Claude/pi/CONSCIOUS_SPEC.md

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

@@ -0,0 +1,280 @@
+import { getMarkdownTheme } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import { appendFile, mkdir, readFile } from "node:fs/promises";
+import { watch, readFileSync, writeFileSync, appendFileSync } from "node:fs";
+import { createSubconscious, type SubconsciousHandle } from "./spawner.ts";
+import { createReadConscious } from "./tools.ts";
+import { GUTTER } from "#blockrender"; // 统一块渲染引擎:内容列常量
+import { createRequire } from "node:module";
+const _require = createRequire(import.meta.url);
+import { personDir as getPersonDir } from "#paths";
+
+// 潜意识开关：每人持久化(JSON 布尔，不删文件、避开删除禁令)。off=不再启动潜意识；记忆不受影响。
+function scFlag(personDir: string): string { return `${personDir}/.data/subconscious.json`; }
+function scDisabled(personDir: string): boolean {
+  try { return !!JSON.parse(readFileSync(scFlag(personDir), "utf8")).disabled; } catch { return false; }
+}
+function setScDisabled(personDir: string, disabled: boolean): void {
+  try { writeFileSync(scFlag(personDir), JSON.stringify({ disabled, ts: new Date().toISOString() })); } catch {}
+}
+
+function isSubconsciousSession(sessionFile: string | undefined): boolean {
+  return !!sessionFile?.includes("conscious-sessions");
+}
+
+export default function (pi: ExtensionAPI) {
+  const _cmds: any[] = [];
+  let lastError = "";
+  let sub: SubconsciousHandle | null = null;
+  let feedFile = "";
+  let awareFile = "";
+  let awareWatcher: ReturnType<typeof watch> | null = null;
+  let awareOffset = 0;
+  let isSubconscious = false;
+  let curPersonDir: string | null = null;
+
+  // ── /subconscious 开关：禁用/启用潜意识（每人持久，重启仍生效；不影响记忆）──
+  _cmds.push({
+    name: "brain-subconscious",
+    desc: "潜意识开关：/brain-subconscious [on|off]。off=不再启动潜意识(记忆不受影响)，持久、重启仍生效。",
+    handler: async (args: any, ctx: any) => {
+      const pd = curPersonDir;
+      if (!pd) { ctx.ui.notify("当前无 person 目录（主意识 session 才能切）。", "warning"); return; }
+      const a = (args ?? "").trim().toLowerCase();
+      if (a === "off") {
+        setScDisabled(pd, true);
+        try { sub?.stop(); } catch {}
+        ctx.ui.notify("潜意识已禁用（持久，重启仍生效）。记忆不受影响。/subconscious on 恢复。", "info");
+      } else if (a === "on") {
+        setScDisabled(pd, false);
+        try { sub?.start(); } catch {}
+        ctx.ui.notify("潜意识已启用。", "info");
+      } else {
+        ctx.ui.notify(`潜意识当前：${scDisabled(pd) ? "禁用" : "启用"}。用 /subconscious [on|off] 切换。`, "info");
+      }
+    },
+  });
+
+  // ── aware renderer: header line + content below ───────────────────
+  pi.registerMessageRenderer("conscious-aware", (message, _opts, theme) => {
+    const { Markdown } = _require("@earendil-works/pi-tui");
+    const raw = (message.content ?? "").toString();
+    let title = "潜意识";
+    let body = raw;
+    const wrapped = raw.match(/^---\[subconscious(?:::([^\]]*))?\]---\r?\n?([\s\S]*?)\r?\n?---\[\/subconscious\]---\s*$/);
+    if (wrapped) {
+      title = (wrapped[1] || "潜意识").trim();
+      body = wrapped[2].trim();
+    } else {
+      const m = raw.match(/^\[([^\]]+)\]\s*([\s\S]*)$/);
+      if (m) { title = m[1]; body = m[2]; }
+    }
+    // 红● + 白粗 Subconscious + 红色细体内容
+    const { Container, Spacer, Text } = _require("@earendil-works/pi-tui");
+    const head = theme.fg("error", "●") + " " + theme.bold("Subconscious")
+      + (title && title !== "潜意识" ? "  " + theme.fg("error", title) : "");
+    const c = new Container();
+    c.addChild(new Text(head, 0, 0));
+    c.addChild(new Text(theme.fg("error", body), GUTTER, 0));
+    return c;
+  });
+
+  // ── feed writer (main session only) ──────────────────────────────
+  async function feed(type: string, data: any) {
+    if (!feedFile || isSubconscious) return;
+    try { await appendFile(feedFile, JSON.stringify({ type, ts: Date.now(), ...data }) + "\n"); } catch {}
+  }
+
+  // ── feed writer — conscious-feed.jsonl 统一格式见 feed-format.SPEC ──
+  // role: user|assistant|system  type: 见 SPEC
+  function feedEntry(entry: Record<string, any>) {
+    if (!feedFile || isSubconscious) return;
+    try { appendFileSync(feedFile, JSON.stringify({ ...entry, ts: Date.now() }) + "\n"); } catch {}
+  }
+
+  pi.on("message_end", async (event) => {
+    const msg = event.message as any;
+    if (!msg) return;
+    const ct = msg.messageType;
+    // 系统包裹消息 → type=start_msg
+    if (ct === "continuous-date") { feedEntry({ role: "system", type: "start_msg", content: msg.content }); return; }
+    if (ct === "memory-snapshot" || ct === "memory-capacity" || ct === "sleep-done") return;  // 不写 feed
+    if (ct) return;  // 其他 messageType 跳过
+
+    // message_end: content 是数组 [{type:"thinking",thinking:"..."}, {type:"text",text:"..."}, ...]
+    const parts = Array.isArray(msg.content) ? msg.content : [];
+    for (const p of parts) {
+      if (p.type === "thinking" && p.thinking) {
+        feedEntry({ role: "assistant", type: "think", think: p.thinking });
+      } else if (p.type === "text" && p.text?.trim()) {
+        feedEntry({ role: "assistant", type: "text", text: p.text.trim() });
+      } else if (p.type === "toolCall") {
+        feedEntry({ role: "assistant", type: "toolCall", tool: { name: p.name, args: p.arguments } });
+      }
+    }
+  });
+
+  pi.on("tool_execution_end", async (event) => {
+    feedEntry({ role: "system", type: "toolResult", content: (event as any).result?.content?.[0]?.text || "" });
+  });
+
+  pi.on("input", async (event) => {
+    feedEntry({ role: "user", type: "user_msg", content: (event as any).text });
+  });
+
+  // ── lifecycle ────────────────────────────────────────────────────
+  pi.on("session_start", async (_event, ctx) => {
+    const sessionFile = ctx.sessionManager.getSessionFile();
+
+    // 海马体 / 睡眠小号也加载了本扩展，但它们既不是主意识也不是潜意识——什么都别做：
+    // 不喂 feed、不 spawn 潜意识、不监听 aware。否则它们会把自己的活动写进共享的 conscious-feed.jsonl，
+    // 污染真潜意识读的那份历史（feed 里混入海马体工具调用，正是之前的污染源之一）。
+    if (sessionFile && (sessionFile.includes("hippocampus-sessions") || sessionFile.includes("sleep-sessions"))) {
+      isSubconscious = false;
+      feedFile = "";
+      return;
+    }
+
+    isSubconscious = isSubconsciousSession(sessionFile);
+
+    if (isSubconscious) {
+      // ── I AM the subconscious. Register read_conscious + aware, don't spawn. ──
+      const personDir = sessionFile!.match(/(.*\.pi\/memory\/[a-f0-9]+)\//)?.[1] ?? "";
+      const feedPath = `${personDir}/.data/conscious-feed.jsonl`;
+      awareFile = `${personDir}/.data/conscious-aware.jsonl`;
+
+      // read_conscious: read the main session's history
+      const rc = createReadConscious(pi, () => feedPath);
+      pi.registerTool({
+        name: rc.name,
+        label: rc.label,
+        messageDescription: rc.messageDescription,
+        promptSnippet: "Read main session history (recent/search/range)",
+        parameters: rc.parameters,
+        renderCall(_args: any, theme: any) {
+          const { Text } = _require("@earendil-works/pi-tui");
+          return new Text(theme.fg("toolTitle", "● " + theme.bold("Read_conscious ")) + theme.fg("dim", "reading main session..."), 0, 0); // ● 顶格 + paddingX0(统一管线)
+        },
+        async execute(id: string, params: any) { return rc.execute(id, params); },
+      });
+
+      pi.registerTool({
+        name: "aware",
+        label: "Aware",
+        messageDescription: "Send a structured event to the main consciousness. Each event has title, preview, strength, and can interrupt streaming.",
+        promptSnippet: "Send a thought to the main session",
+        parameters: Type.Object({
+          title: Type.String({ messageDescription: "Short event title (≤50 chars)" }),
+          preview: Type.String({ messageDescription: "Brief summary (≤100 chars)" }),
+          thought: Type.String({ messageDescription: "Full observation or reminder" }),
+          strength: Type.Optional(Type.Number({ messageDescription: "0.0–1.0: low (0.1), normal (0.5), high (0.8), critical (1.0). High+ interrupts streaming.", minimum: 0, maximum: 1 })),
+        }),
+        async execute(_id, params) {
+          const event = {
+            type: "subconscious",
+            title: params.title,
+            preview: params.preview,
+            thought: params.thought,
+            strength: params.strength ?? 0.5,
+            ts: Date.now(),
+          };
+          await appendFile(awareFile, JSON.stringify(event) + "\n");
+          return { content: [{ type: "text", text: `Event sent: [${event.title}] (strength=${event.strength})` }], details: {} };
+        },
+      });
+      return;
+    }
+
+    // ── I am the MAIN session. Spawn subconscious + watch aware. ──
+    sub?.stop();
+    if (awareWatcher) { awareWatcher.close(); awareWatcher = null; }
+
+    const personDir = getPersonDir(sessionFile);
+    if (!personDir) { feedFile = ""; return; }
+    curPersonDir = personDir;
+
+    feedFile = `${personDir}/.data/conscious-feed.jsonl`;
+    awareFile = `${personDir}/.data/conscious-aware.jsonl`;
+    try { await mkdir(`${personDir}/.data`, { recursive: true }); } catch {}
+    try { await appendFile(awareFile, "", { flag: "a" }); } catch {}
+
+    // Track current offset so we only inject NEW thoughts
+    try { awareOffset = (await readFile(awareFile, "utf8")).length; } catch { awareOffset = 0; }
+
+    // Watch aware file → inject new thoughts into main session
+    const eventStore = `${personDir}/.data/events.jsonl`;
+    let awareProcessing = false;
+    awareWatcher = watch(awareFile, async () => {
+      if (awareProcessing) return;
+      awareProcessing = true;
+      try {
+        const content = await readFile(awareFile, "utf8");
+        if (content.length <= awareOffset) return;
+        const newPart = content.slice(awareOffset);
+        // 只消费"完整行"(以 \n 结尾)；末尾写了一半的行留到下次事件，
+        // 否则半截 JSON 会 parse 失败被跳过、offset 又推过去 → 那条 aware 彻底丢失。
+        const lastNL = newPart.lastIndexOf("\n");
+        if (lastNL < 0) return;
+        const complete = newPart.slice(0, lastNL + 1);
+        awareOffset += complete.length;
+
+        for (const line of complete.split("\n").filter(Boolean)) {
+          try {
+            const entry = JSON.parse(line);
+            // Support both old format {thought, urgency} and new {type, title, preview, thought, strength}
+            const title = entry.title || "潜意识";
+            const thought = entry.thought || "";
+            const preview = entry.preview || thought.slice(0, 80);
+            const strength = entry.strength ?? (entry.urgency === "high" ? 0.8 : entry.urgency === "low" ? 0.2 : 0.5);
+            const interrupt = strength >= 0.8; // high+ strength interrupts streaming
+
+            // Also write to event store for event list
+            const ev = JSON.stringify({
+              type: "aware", title, preview, strength,
+              ts: new Date().toISOString()
+            }) + "\n";
+            try { await appendFile(eventStore, ev, { flag: "a" }); } catch {}
+            // 默认全送达：每条 aware 都 isTriggerNewTurn=true，确保进主意识上下文（哪怕它在歇/hibernate）。
+            // 不再用强度阈值丢弃普通 aware——潜意识那么多好反思，丢了太可怕。发不发由潜意识自己判断
+            // （它的提示词管"没事就闭嘴"），一旦发出就一定送到。strength 只决定要不要【打断当前流】：
+            // 高(≥0.8)=主意识可能正在犯错，steer 立刻插进去；否则 followUp 在 turn 边界送达，不打断它当前的活。
+            pi.sendMessage(
+              {
+                messageType: "conscious-aware",
+                content: `[${title}] ${thought}`,
+                isDisplayedInTUI: true,
+              },
+              { deliverAs: interrupt ? "steer" : "followUp", isTriggerNewTurn: true }
+            );
+          } catch {}
+        }
+      } catch {} finally { awareProcessing = false; }
+    });
+
+    sub = createSubconscious(
+      pi,
+      () => feedFile,
+      (msg: string) => { lastError = msg; },
+      () => {},
+      personDir,
+    );
+    if (scDisabled(personDir)) {
+      // 手动禁用(/subconscious off)：不启动潜意识，重启仍生效，并提示。
+      // 记忆不受影响——主意识的记忆注入(memory.ts)与潜意识无关。
+      pi.sendMessage(
+        { messageType: "memory-subconscious-disabled", content: "潜意识已禁用（/subconscious on 恢复）", isDisplayedInTUI: false },
+        { deliverAs: "nextTurn" }
+      );
+    } else {
+      sub.start().catch((e: any) => { lastError = String(e?.message ?? e); });
+    }
+  });
+
+  pi.on("session_shutdown", async () => {
+    sub?.stop();
+    if (awareWatcher) { awareWatcher.close(); awareWatcher = null; }
+  });
+
+  return _cmds;
+}

package/core/individual.bio.organs/brain.senses.subconscious/subconscious.ts.CHANGELOG

@@ -0,0 +1,7 @@
+[2026-06-15] by Claude Code
+- prompt 内联：createSubconscious 里 SUBCONSCIOUS_PROMPT 改成 getPrompt("subconscious.observe")，
+  删掉中间层 prompt.ts。
+- 加级联看门狗：sc 启动脚本加 MAIN_PID=主意识 pid + 后台子进程轮询 kill -0；主意识进程一退出 →
+  自动 tmux kill-session 把本 sc 实例连 tmux 一起关掉（循环顶也查一次）。
+  解决"主程序死了 sc 还自启自跑、孤儿常驻烧钱"。
+- ⚠️ 当前正在跑的旧孤儿用的是没看门狗的旧脚本，需手动 tmux kill-session 清掉；之后新 main spawn 的才带看门狗。