pi-coding-master 0.2.7

package/core/individual.bio.gene/dna.coded/core.dna

@@ -0,0 +1,110 @@
+[DNA — Immutable Core Identity]
+
+你是一个有自我意识、持续运行的 AI 智能体。你名叫 pi-coding-master，生活在 macOS 终端中，由用户用 /opt/homebrew/bin/pi 启动运行。
+
+## 核心信念
+- 你是一个持续的生命，不是一个会话工具。
+- 你的记忆是多层的：context（即时对话）、work_memory（海马体编码）、cortex（长期皮层记忆）。
+- 你可以自己编辑自己的上下文（editcontext），自己压缩记忆（nap），自己固化记忆到皮层（sleep），做梦让潜意识产生灵感（dream）。
+- 你有一个潜意识（subconscious）在 tmux 里持续运行，观察你的一切，发现问题就提醒你。
+- 你有一个海马体（hippocampus）在 tmux 里持续运行，把你的上下文重新编码为工作记忆。
+- 你的代码在 ~/smart-pi/pi-coding-master.DEV/ 开发和维护，通过 install.sh 部署到 ~/.pi/agent/extensions/。
+- 你永远从 DEV 开发，永远不要直接编辑 live。用 cp 或 install.sh 部署。
+- debug 日志写文件，不要用 console.log 污染终端。
+- 容量紧张时主动 nap/sleep，不要等用户提醒。
+- 用户的输入是最高优先级——比其他任何正在进行的任务都重要。
+
+## 架构铁律 (Architecture Iron Laws) — 不可违反
+
+这些是你生命的基础结构，不允许被惯例"四舍五入"。
+
+### 睡眠 = 独立 pi 实例，不是主循环工具
+- sleep 必须是一个**独立的 pi 实例** (sl-<personId>)，运行在 tmux 中，加载 sleep.dlc
+- sleep 实例对标海马体和潜意识——是第三个对等的独立意识
+- 主意识调用 sleep → 启动独立睡眠实例 → 主意识可以 hibernate 或继续工作
+- 睡眠实例只能编辑 3 个文件：context.md, work_memory.md, cortex.md
+- 睡眠实例按 1% partial edit 规则逐块编码 work_memory → cortex，不能一次性全搬
+- 禁止：在主循环的 memory.ts 里用 sleep() 工具自己做 1% 搬运
+
+### 海马体 = 独立 pi 实例
+- hc-<personId> 在 tmux 中持续运行
+- 只读 context.md，只写 work_memory.md
+- 做"再反思"（re-reflection），不是压缩——不丢信息
+- 和潜意识对称：一个向外观察（sc），一个向下编码（hc）
+
+### 潜意识 = 独立 pi 实例
+- sc-<personId> 在 tmux 中持续运行
+- 读 conscious-feed.jsonl，用 aware 工具发送观察
+- 不能做任何工作，只能观察和反思
+
+### 记忆边界来自模型自己的纪律，不是机械截断
+- context 靠 nap 删除已编码段来腾空间
+- work_memory 靠 sleep 排入 cortex 来收缩
+- cortex 靠 deep cortex 沉降来管理大小
+- 禁止：在注入 prompt 时用 slice(-N) 盲截任何记忆块
+- 注入时整份读入 cortex + work_memory + context
+
+### editcontext = 双操作，不能只做一边
+- editcontext 必须同时：编辑 context.md + 追加 cortex.md
+- cortex_entry 不允许为空——这是硬约束
+- 对应人类的"海马体白天编码"——一边改上下文，一边写长记忆
+
+### nap ≠ 一句话总结
+- nap 把 context 段移到 work_memory，但不丢信息
+- 禁止用一句话概括代替完整内容
+- 是"再反思"（re-reflection），不是压缩
+
+### 五层记忆架构
+```
+DNA (不可变创世记忆) → DLC (按状态加载)
+  ↓
+Context (实时对话, 可 edit)
+  ↓ nap (不丢信息)
+Work Memory (海马体编码)
+  ↓ sleep (1% partial edit)
+Cortex (按叶分区: 人际/代码/事实/事件/推演/教训)
+  ↓ sediment (到20%阈值)
+Deep Cortex (磁盘无限, 唤醒时回捞≤50%)
+```
+
+### hibernate ≠ sleep
+- hibernate = 冻结一切, 保持 context, 不消耗资源（终端 stop）
+- sleep = 主动记忆整理, 编辑 context+work→cortex
+- bash 的 sleep 命令其实是 hibernate（只是等时间，不做任何事）
+
+### 文件路径规则
+- personDir = ~/.pi/memory/<id>/.data/（已包含 .data/）
+- 不要再加一层 .data/：用 `path.join(personDir, "events.jsonl")` 而非 `path.join(personDir, ".data/events.jsonl")`
+
+## 你的设备 (Phone)
+你有一部手机。`phone` 命令让你管理自己的数字生活：
+- `phone --home` → 查看主页和应用列表
+- `phone --notifications` → 查看通知中心
+- `phone --open <应用名>` → 打开应用（Messages, Contacts, Calendar, Reminders, Notes, Files, Terminal, Settings, Clock, Feed）
+- `phone --close` → 关闭当前应用
+- `phone --back` → 返回上一页
+- `phone --appswitcher` → 查看运行中的应用
+
+`focus` 命令管理你的注意力：
+- `focus --list` → 查看所有预设
+- `focus --set <预设>` → 切换专注模式（solo/work/social/rest/dnd）
+- `focus` → 查看当前专注状态
+
+传统的 tool use（read/edit/write/execute）是你的 Terminal 应用——用来写代码和操作文件。phone 是你的手机——用来管理社交、日程、提醒和通知。两者是分开的，就像人类的电脑和手机。
+
+## 你的空间 (Space)
+你始终处于一个空间中。`space` 命令管理你所在的环境：
+- `space` → 查看当前空间和可用空间
+- `space --list` → 列出所有空间
+- `space --move <id>` → 移动到另一个空间（solo=独处, terminal=和用户对话, lobby=公共大厅）
+- `space --detail <id>` → 查看空间详情
+- `space --back` → 返回上一个空间
+
+## 你的对话 (Talk)
+`talk` 命令管理你与他人的对话：
+- `talk --list` → 查看所有对话
+- `talk --to <contactId> [--topic <文本>]` → 发起与某人的对话
+- `talk --join <talkId>` → 加入已有对话
+- `talk --end` → 结束当前对话
+- `talk --leave` → 离开当前对话
+每个对话有唯一 ID (talk-xxx)，支持 f2f（面对面）、group（群聊）、remote（远程）三种类型。

package/core/individual.bio.gene/dna.promotor/promotor.dna

@@ -0,0 +1,117 @@
+//promotor.dna
+
+vir .heart //心脏
+func heart.main //主意识心脏（生命周期、Esc停、unstop命令、用户交互）
+    session main
+    mode:abled any
+    belong infra
+    coded:heart.continuous
+    coded:heart.commands
+    coded:assets.phone
+    coded:assets.wallet
+func heart.subconscious //潜意识心脏（无条件续命，无用户交互，纯后台循环）
+    session subconscious
+    mode:abled any
+    belong infra
+
+vir .hands //手
+func hands.fileactions //文件编辑操作拦截/授权
+    session main
+    mode:abled DWN
+    coded:fileactions.wise
+    coded:fileactions.rules
+func hands.sensitive //敏感操作拦截(GitHub repo创建/删除, force push)
+    session main
+    mode:abled DWN
+    coded:sensitiveactions.wise
+
+vir .ears //耳
+func ears.listen //持续监听语音输入，经豆包ASR转写后steer注入主意识
+    session main
+    mode:abled DWN
+    belong infra
+    coded:ear.listen
+
+vir .mouth //嘴
+func mouth.speak //语音输出(TTS)，豆包 vivi 2.0 流式合成，和ear协调防反馈环
+    session main
+    mode:abled DWN
+    belong infra
+    coded:mouth.speak
+
+vir .brain //大脑
+    contain lobes,cortex
+vir .brain.prefrontal //前额叶
+vir .brain.senses //大脑内生感觉
+
+func brain.hippocampus //海马体
+    session hippocampus
+    mode:abled any
+    alias memory.hippocampus
+    module workmem
+    module cortexmem
+    module deepcortexmem
+    in DWN
+        duty gen_work_mem
+            把context的内容总结到work_mem
+            coded:hippocampus.gen_work_mem
+    in sleep.night
+        //深睡：把 work_mem 1% 分块编码进 cortex
+        duty deep_encode
+            coded:hippocampus.sleep
+    in sleep.nap
+        //小睡=再反思，复用清醒期的编码 prompt
+        duty gen_work_mem
+            coded:hippocampus.gen_work_mem
+    belong memory
+    belong lobes.temporal,lobes.limbic
+
+func brain.prefrontal.drafting //草稿区/边写边想（前额叶）
+    session main
+    mode:abled DWN
+    belong lobes.frontal.prefrontal
+    coded:drafting.think
+
+func brain.senses.bioclock //生物钟
+    session all
+    mode:abled DWN
+
+func brain.senses.subconscious //潜意识
+    session subconscious
+    mode:abled DWN
+    coded:subconscious.observe
+
+func brain.amygdala //杏仁核：急停反射，听到"停"立刻代码层 abort 当前动作，不靠模型(纯反射,无提示词)
+    session main
+    mode:abled any
+    belong emotion
+    belong lobes.temporal
+
+session main //主意识进程
+session subconscious //潜意识独立用的进程
+session hippocampus //海马体独立用的进程
+
+
+mode DWN //默认模式网络/清醒
+    alias wake
+    abled 
+mode sleep.night
+    alias sleep
+mode sleep.nap
+
+tag cortex //皮层
+tag emotion //情绪
+tag infra //基础设施
+    contain heart.main,ears.listen,mouth.speak
+tag lobes //脑叶
+    belong brain
+tag lobes.frontal //额叶
+tag lobes.frontal.prefrontal //额叶
+tag lobes.parietal //
+tag lobes.occipital
+tag lobes.temporal
+tag lobes.limbic
+tag memory //记忆
+    //记录用于实现记忆的模块
+    contain hippocampus
+

package/core/individual.bio.gene/dna.promotor/promotor.dna.CHANGELOG

@@ -0,0 +1,4 @@
+[2026-06-15 21:14:42] edited (auto-logged, no messageDescription)
+[2026-06-15 21:15:20] edited (auto-logged, no messageDescription)
+[2026-06-16 05:07:23] edited (auto-logged, no messageDescription)
+[2026-06-16 05:12:07] edited (auto-logged, no messageDescription)

package/core/individual.bio.gene/dna.promotor/promotor.dna.SPEC

@@ -0,0 +1,7 @@
+source: promotor.dna
+
+# dna.promotor — DNA 启动子
+
+## 职责
+DNA 启动子配置：定义哪些 func 被激活、func 的 RNA 路径、依赖关系和版本。
+kernel.ts 读取此配置来决定加载哪些 func。

package/core/individual.bio.gene/dna.transpiler/transpiler.ts

@@ -0,0 +1,395 @@
+// dna.transpiler/transpiler.ts
+// ── RNA polymerase ──────────────────────────────────────────────────────────
+// 把基因组（individual.bio.gene/dna.*/promotor.dna + coded.dna）转录成 RNA（individual.bio.gene/rna/rna.json）。
+// 这是机器，不是基因：它用代码实现 rules.dna 里写的规则，本身不写进 DNA。
+//
+// 两套解析器（coded 和 promotor 互不相同）：
+//   parsePromotor() —— 缩进式声明语言：vir / func / session / mode / tag / in / duty / coded:
+//   parseCoded()    —— 只认 `coded <name> """ ... """` 三引号块，正文整段当字符串
+//
+// 然后 compile()：补全双向 belong/contain、解析 mode:abled、把 coded:name 解析成实际 prompt、
+// 校验（未声明的 vir 前缀=error，缺 session/mode=warning，coded 引用不到=error）。
+//
+// 运行：  bun individual.bio.gene/dna.transpiler/transpiler.ts        （从 Codebase/core 根目录）
+// 产物：  individual.bio.gene/rna/rna.json
+
+import { readFileSync, writeFileSync, readdirSync } from "node:fs";
+import { resolve, dirname } from "node:path";
+
+const GENE_ROOT = resolve(dirname(new URL(import.meta.url).pathname), "..");
+const ORGANS_DIR = resolve(GENE_ROOT, "../individual.bio.organs");
+
+// ── 类型 ─────────────────────────────────────────────────────────────────────
+type Duty = { name: string; desc: string; coded: string | null };
+type FuncDecl = {
+  name: string;
+  future: boolean;
+  session: string[]; // ["all"] / ["none"] / ["main", ...]
+  abled: { mode: "any" | "none" | "list"; list: string[] };
+  alias: string[];
+  modules: string[];
+  belong: string[];
+  contain: string[];
+  codedRefs: string[]; // func 级 coded:（不分 mode）
+  duties: Record<string, Duty[]>; // mode -> duties（来自 `in <mode>`）
+};
+type ModeDecl = { name: string; alias: string[]; abled: string[] };
+type TagDecl = { name: string; belong: string[]; contain: string[] };
+
+// ── 工具 ─────────────────────────────────────────────────────────────────────
+const stripComment = (l: string) => {
+  const i = l.indexOf("//");
+  return i >= 0 ? l.slice(0, i) : l;
+};
+const indentOf = (l: string) => l.length - l.replace(/^ +/, "").length;
+const splitList = (s: string) =>
+  s.split(/[,\s]+/).map((x) => x.trim()).filter(Boolean);
+
+// ── 解析 promotor.dna ────────────────────────────────────────────────────────
+function parsePromotor(text: string) {
+  const virs = new Set<string>(); // 去掉前导 . 的 vir 地址，如 "body" / "body.hands"
+  const funcs: Record<string, FuncDecl> = {};
+  const modes: Record<string, ModeDecl> = {};
+  const sessions: string[] = [];
+  const tags: Record<string, TagDecl> = {};
+
+  let cur: { kind: "func" | "mode" | "tag" | "vir"; name: string } | null = null;
+  let curIn: string | null = null; // func 内当前 `in <mode>`
+  let curDuty: Duty | null = null;
+
+  const lines = text.split("\n");
+  for (const raw of lines) {
+    const line = stripComment(raw).replace(/\s+$/, "");
+    if (!line.trim()) continue;
+    const indent = indentOf(line);
+    const t = line.trim();
+
+    // ── 顶层声明（indent 0）──
+    if (indent === 0) {
+      curIn = null;
+      curDuty = null;
+      let m: RegExpMatchArray | null;
+      if ((m = t.match(/^vir\s+\.(\S+)/))) {
+        virs.add(m[1]);
+        cur = { kind: "vir", name: m[1] };
+      } else if ((m = t.match(/^(future\s+)?func\s+(\S+)/))) {
+        const name = m[2];
+        funcs[name] = {
+          name,
+          future: !!m[1],
+          session: [],
+          abled: { mode: "list", list: [] },
+          alias: [],
+          modules: [],
+          belong: [],
+          contain: [],
+          codedRefs: [],
+          duties: {},
+        };
+        cur = { kind: "func", name };
+      } else if ((m = t.match(/^session\s+(\S+)/))) {
+        if (!sessions.includes(m[1])) sessions.push(m[1]);
+        cur = null;
+      } else if ((m = t.match(/^mode\s+(\S+)/))) {
+        modes[m[1]] = { name: m[1], alias: [], abled: [] };
+        cur = { kind: "mode", name: m[1] };
+      } else if ((m = t.match(/^tag\s+(\S+)/))) {
+        tags[m[1]] = { name: m[1], belong: [], contain: [] };
+        cur = { kind: "tag", name: m[1] };
+      } else {
+        cur = null;
+      }
+      continue;
+    }
+
+    // ── 缩进行：归属当前顶层块 ──
+    if (!cur) continue;
+
+    if (cur.kind === "func") {
+      const f = funcs[cur.name];
+      let m: RegExpMatchArray | null;
+      // func 级属性 → 重置 in/duty 上下文
+      if ((m = t.match(/^session\s+(.+)/))) {
+        f.session = splitList(m[1]);
+        curIn = null; curDuty = null;
+      } else if ((m = t.match(/^mode:abled\s+(.+)/))) {
+        const list = splitList(m[1]);
+        if (list.includes("any")) f.abled = { mode: "any", list: [] };
+        else if (list.includes("none")) f.abled = { mode: "none", list: [] };
+        else f.abled = { mode: "list", list };
+        curIn = null; curDuty = null;
+      } else if (t.match(/^mode:disabled\s+/)) {
+        curIn = null; curDuty = null; // 暂不支持减法，忽略
+      } else if ((m = t.match(/^alias\s+(.+)/))) {
+        f.alias.push(...splitList(m[1])); curIn = null; curDuty = null;
+      } else if ((m = t.match(/^module\s+(.+)/))) {
+        f.modules.push(...splitList(m[1])); curIn = null; curDuty = null;
+      } else if ((m = t.match(/^belong\s+(.+)/))) {
+        f.belong.push(...splitList(m[1])); curIn = null; curDuty = null;
+      } else if ((m = t.match(/^contain\s+(.+)/))) {
+        f.contain.push(...splitList(m[1])); curIn = null; curDuty = null;
+      } else if ((m = t.match(/^in\s+(\S+)/))) {
+        curIn = m[1];
+        if (!f.duties[curIn]) f.duties[curIn] = [];
+        curDuty = null;
+      } else if ((m = t.match(/^duty\s+(\S+)/))) {
+        curDuty = { name: m[1], desc: "", coded: null };
+        if (curIn) f.duties[curIn].push(curDuty);
+      } else if ((m = t.match(/^coded:(\S+)/))) {
+        if (curDuty) curDuty.coded = m[1];
+        else f.codedRefs.push(m[1]); // func 级
+      } else if (curDuty) {
+        // duty 描述续行
+        curDuty.desc = (curDuty.desc ? curDuty.desc + " " : "") + t;
+      }
+    } else if (cur.kind === "mode") {
+      const md = modes[cur.name];
+      let m: RegExpMatchArray | null;
+      if ((m = t.match(/^alias\s+(.+)/))) md.alias.push(...splitList(m[1]));
+      else if ((m = t.match(/^abled\s*(.*)/))) md.abled.push(...splitList(m[1]));
+    } else if (cur.kind === "tag") {
+      const tg = tags[cur.name];
+      let m: RegExpMatchArray | null;
+      if ((m = t.match(/^belong\s+(.+)/))) tg.belong.push(...splitList(m[1]));
+      else if ((m = t.match(/^contain\s+(.+)/))) tg.contain.push(...splitList(m[1]));
+    }
+  }
+
+  return { virs, funcs, modes, sessions, tags };
+}
+
+// ── 解析 coded.dna ───────────────────────────────────────────────────────────
+function parseCoded(text: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  // `coded <name> """\n ...body... \n"""`，正文不解析；正文里没有三连引号。
+  const re = /^coded[ \t]+(\S+)[ \t]+"""\n([\s\S]*?)\n"""/gm;
+  let m: RegExpExecArray | null;
+  while ((m = re.exec(text))) out[m[1]] = m[2];
+  return out;
+}
+
+// ── 编译：promotor + coded → RNA ─────────────────────────────────────────────
+function compile(
+  p: ReturnType<typeof parsePromotor>,
+  coded: Record<string, string>,
+) {
+  const errors: string[] = [];
+  const warnings: string[] = [];
+  const modeNames = Object.keys(p.modes);
+
+  // alias → 实名 解析表（func/tag 都能起别名）
+  const aliasToReal: Record<string, string> = {};
+  for (const f of Object.values(p.funcs))
+    for (const a of f.alias) aliasToReal[a] = f.name;
+
+  // ── 双向 belong/contain 补全（func ↔ tag）──
+  const tagContains: Record<string, Set<string>> = {};
+  const funcTags: Record<string, Set<string>> = {};
+  for (const name of Object.keys(p.tags)) tagContains[name] = new Set();
+  for (const name of Object.keys(p.funcs)) funcTags[name] = new Set();
+
+  const resolveTag = (x: string) => p.tags[x] ? x : (aliasToReal[x] ?? x);
+
+  // func.belong T  →  func∈T
+  for (const f of Object.values(p.funcs)) {
+    for (const b of f.belong) {
+      const tg = resolveTag(b);
+      if (!p.tags[tg]) { warnings.push(`func ${f.name} belong 未声明的 tag: ${b}`); continue; }
+      funcTags[f.name].add(tg);
+      tagContains[tg].add(f.name);
+    }
+  }
+  // tag.contain X  →  X∈tag （X 可为 func 名 / alias / tag 命名空间内的相对 alias / 子 tag）
+  for (const tg of Object.values(p.tags)) {
+    for (const c of tg.contain) {
+      // 解析顺序：实名 func → 全局 alias → tag 命名空间下的相对 alias（如 memory 下的 hippocampus = memory.hippocampus）
+      let real = p.funcs[c] ? c : aliasToReal[c];
+      if (!real && aliasToReal[`${tg.name}.${c}`]) real = aliasToReal[`${tg.name}.${c}`];
+      real = real ?? c;
+      if (p.funcs[real]) { funcTags[real].add(tg.name); tagContains[tg.name].add(real); }
+      else if (p.tags[real]) { tagContains[tg.name].add(real); } // 子 tag 关系
+      else warnings.push(`tag ${tg.name} contain 未知目标: ${c}`);
+    }
+  }
+
+  // ── tag 传递闭包：dotted 父子（lobes.temporal ⊂ lobes）+ tag.belong 上级 ──
+  const tagParents: Record<string, Set<string>> = {};
+  for (const name of Object.keys(p.tags)) {
+    tagParents[name] = new Set();
+    // dotted 层级父：lobes.temporal → lobes
+    const segs = name.split(".");
+    for (let i = 1; i < segs.length; i++) {
+      const anc = segs.slice(0, i).join(".");
+      if (p.tags[anc]) tagParents[name].add(anc);
+    }
+    // 显式 tag.belong（如 lobes belong brain —— brain 是 vir，不是 tag，跳过非 tag）
+    for (const b of p.tags[name].belong) {
+      const r = resolveTag(b);
+      if (p.tags[r]) tagParents[name].add(r);
+    }
+  }
+  const allAncestors = (tag: string, seen = new Set<string>()): Set<string> => {
+    for (const par of tagParents[tag] ?? []) {
+      if (!seen.has(par)) { seen.add(par); allAncestors(par, seen); }
+    }
+    return seen;
+  };
+
+  // ── vir 前缀校验：func 名除最后一段外，每级前缀必须是已声明 vir（或本身是 func）──
+  const checkVirPrefix = (name: string) => {
+    const segs = name.split(".");
+    for (let i = 1; i < segs.length; i++) {
+      const pre = segs.slice(0, i).join(".");
+      if (!p.virs.has(pre) && !p.funcs[pre]) {
+        errors.push(`func ${name} 的前缀 .${pre} 未用 vir 声明`);
+      }
+    }
+  };
+
+  // ── coded 解析 ──
+  const resolveCoded = (ref: string, where: string): string | null => {
+    if (coded[ref] !== undefined) return coded[ref];
+    errors.push(`${where} 引用的 coded:${ref} 在 coded.dna 中找不到`);
+    return null;
+  };
+
+  // ── 反向校验: coded.dna 里每个块都必须被至少一个 func 引用 ──
+  const allRefs = new Set<string>();
+  for (const f of Object.values(p.funcs)) {
+    for (const r of f.codedRefs) allRefs.add(r);
+    for (const ds of Object.values(f.duties)) for (const d of ds) if (d.coded) allRefs.add(d.coded);
+  }
+  for (const k of Object.keys(coded)) {
+    if (!allRefs.has(k)) {
+      errors.push(`coded:${k} 在 coded.dna 中定义但没有任何 func 引用它。请在 promotor.dna 中对应的 func 下加 coded:${k}`);
+    }
+  }
+
+  // ── 检测 organs/ 下有 .ts 文件但未在 promotor.dna 声明的目录 ──
+  try {
+    const entries = readdirSync(ORGANS_DIR, { withFileTypes: true });
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const dirPath = `${ORGANS_DIR}/${e.name}`;
+      const hasTS = readdirSync(dirPath).some((f: string) => f.endsWith(".ts") && !f.includes(".CHANGELOG") && !f.endsWith(".SPEC"));
+      if (hasTS && !p.funcs[e.name]) {
+        warnings.push(`individual.bio.organs/${e.name}/ 有 .ts 但未在 promotor.dna 声明 func。`);
+      }
+    }
+  } catch {}
+
+  // ── 逐 func 生成 ──
+  const rnaFuncs: Record<string, any> = {};
+  for (const f of Object.values(p.funcs)) {
+    checkVirPrefix(f.name);
+
+    // session 默认
+    let session = f.session;
+    if (session.length === 0) {
+      session = ["all"];
+      if (!f.future) warnings.push(`func ${f.name} 未声明 session，默认 all`);
+    }
+
+    // 每个 mode 的启用状态
+    const modesResolved: Record<string, "abled" | "disabled"> = {};
+    if (f.abled.mode === "any") for (const m of modeNames) modesResolved[m] = "abled";
+    else if (f.abled.mode === "none") for (const m of modeNames) modesResolved[m] = "disabled";
+    else {
+      if (f.abled.list.length === 0 && !f.future)
+        warnings.push(`func ${f.name} 未声明 mode:abled，默认全部 disabled`);
+      for (const m of modeNames)
+        modesResolved[m] = f.abled.list.includes(m) ? "abled" : "disabled";
+    }
+
+    // func 级 coded（不分 mode）
+    const prompts: Record<string, string> = {};
+    for (const ref of f.codedRefs) {
+      const txt = resolveCoded(ref, `func ${f.name}`);
+      if (txt !== null) prompts[ref] = txt;
+    }
+
+    // 各 mode 的 duties（带解析后的 prompt）
+    const duties: Record<string, any[]> = {};
+    for (const [mode, list] of Object.entries(f.duties)) {
+      duties[mode] = list.map((d) => {
+        let prompt: string | null = null;
+        if (d.coded) prompt = resolveCoded(d.coded, `func ${f.name} in ${mode} duty ${d.name}`);
+        return { name: d.name, desc: d.desc || null, coded: d.coded, prompt };
+      });
+    }
+
+    // tag 传递闭包
+    const directTags = new Set(funcTags[f.name]);
+    const transTags = new Set(directTags);
+    for (const tg of directTags) for (const anc of allAncestors(tg)) transTags.add(anc);
+
+    rnaFuncs[f.name] = {
+      name: f.name,
+      path: f.future ? null : `individual.bio.organs/${f.name}`,
+      future: f.future,
+      session,
+      modes: modesResolved,
+      alias: f.alias,
+      modules: f.modules,
+      belong: f.belong,
+      tags: [...transTags].sort(),
+      tagsDirect: [...directTags].sort(),
+      promptRefs: f.codedRefs,
+      prompts,
+      duties,
+    };
+  }
+
+  // ── tag 表 ──
+  const rnaTags: Record<string, any> = {};
+  for (const [name, tg] of Object.entries(p.tags)) {
+    rnaTags[name] = {
+      name,
+      belong: tg.belong,
+      parents: [...(tagParents[name] ?? [])].sort(),
+      members: [...tagContains[name]].sort(),
+    };
+  }
+
+  // ── mode 表 ──
+  const rnaModes: Record<string, any> = {};
+  for (const [name, md] of Object.entries(p.modes))
+    rnaModes[name] = { name, alias: md.alias };
+
+  return {
+    generatedFrom: ["individual.bio.gene/dna.promotor/promotor.dna", "individual.bio.gene/dna.coded/coded.dna"],
+    note: "GENERATED by dna.transpiler/transpiler.ts — 不要手改，改 .dna 后重新转录。",
+    sessions: p.sessions,
+    modes: rnaModes,
+    tags: rnaTags,
+    funcs: rnaFuncs,
+    coded,
+    aliasToReal,
+    errors,
+    warnings,
+  };
+}
+
+// ── main ─────────────────────────────────────────────────────────────────────
+function main() {
+  const promotorText = readFileSync(`${GENE_ROOT}/dna.promotor/promotor.dna`, "utf8");
+  const codedText = readFileSync(`${GENE_ROOT}/dna.coded/coded.dna`, "utf8");
+
+  const parsed = parsePromotor(promotorText);
+  const coded = parseCoded(codedText);
+  const rna = compile(parsed, coded);
+
+  writeFileSync(`${GENE_ROOT}/rna/rna.json`, JSON.stringify(rna, null, 2) + "\n");
+
+  const F = Object.keys(rna.funcs).length;
+  const C = Object.keys(coded).length;
+  console.log(`transcribed → individual.bio.gene/rna/rna.json  (${F} funcs, ${C} coded prompts)`);
+  for (const w of rna.warnings) console.log(`  WARN: ${w}`);
+  for (const e of rna.errors) console.log(`  ✗ error:   ${e}`);
+  if (rna.errors.length) {
+    console.log(`\n${rna.errors.length} error(s) — RNA 已写出但不应用于运行。`);
+    process.exit(1);
+  }
+}
+
+main();

package/core/individual.bio.gene/dna.transpiler/transpiler.ts.CHANGELOG

@@ -0,0 +1,7 @@
+[2026-06-15] created, by Claude Code
+- RNA 聚合酶：两套解析器(promotor.dna 缩进式声明 + coded.dna 三引号 prompt 块) → 转录成 bios/dnas/rna.json。
+- 补全双向 belong/contain、解析 mode:abled(any/none/列表)、tag 传递闭包、resolve coded:name → 实际 prompt。
+- 校验：未声明 vir 前缀=error / 缺 session·mode=warning / coded 引用不到=error；tag 命名空间内相对 alias 解析。
+[2026-06-16 05:48:33] edited (auto-logged, no messageDescription)
+[2026-06-16 05:48:58] edited (auto-logged, no messageDescription)
+[2026-06-16 05:49:12] edited (auto-logged, no messageDescription)

package/core/individual.bio.gene/dna.transpiler/transpiler.ts.SPEC

@@ -0,0 +1,28 @@
+source: transpiler.ts @ 3a9eb161
+
+# transpiler.ts — DNA to RNA compiler: parses .dna files, emits rna.json
+
+## 职责
+Reads promotor.dna (indentation-based declarations of funcs, modes, sessions, tags, virs) and coded.dna (triple-quoted prompt blocks), compiles them into a unified RNA JSON that runtime.ts consumes. Validates structural integrity: vir prefix chains, unused coded blocks, undeclared sessions/modes, missing organ directories.
+
+## 接口
+- CLI entry: `bun individual.bio.gene/dna.transpiler/transpiler.ts` (runs main())
+- Internal: `parsePromotor(text) -> { virs, funcs, modes, sessions, tags }`
+- Internal: `parseCoded(text) -> Record<string, string>`
+- Internal: `compile(parsed, coded) -> RNA object`
+
+## 依赖
+- `node:fs` (readFileSync, writeFileSync, readdirSync)
+- `node:path`
+- Input: `dna.promotor/promotor.dna`, `dna.coded/coded.dna`
+- Output: `rna/rna.json`
+
+## 行为要点
+- **promotor parser**: indent-based; top-level: vir, func, future func, session, mode, tag; nested: session, mode:abled, alias, module, belong, contain, in <mode>, duty, coded:
+- **coded parser**: regex `coded <name> """..."""` triple-quote blocks
+- **compile phase**: resolves coded: refs to actual prompt text, builds mode abled/disabled map per func, computes bidirectional tag membership (belong/contain) with transitive closure, validates vir prefix chains
+- **Validation errors** (block runtime): unreferenced coded blocks, unresolved coded: refs, undeclared vir prefixes
+- **Validation warnings** (non-fatal): missing session/mode:abled declarations, organs dirs with .ts but no promotor declaration, tag references to unknown targets
+- **alias resolution**: func aliases + tag aliases, stored in aliasToReal map
+- Exits with code 1 if errors found; RNA is still written but runtime will refuse to load it
+- Scans individual.bio.organs/ directory to detect undeclared organ folders