Boot

/boot

调用形式

/boot                   # 读取 BIRTH.md，找到第一个未完成的 Phase，继续执行
/boot phaseN            # 直接执行模式：强制执行指定 Phase（如 /boot phase3）
/boot init phaseN       # 初始化模式：N 为数字（如 /boot init phase2）
/boot --auto            # 自动模式：从第一个未完成 Phase 起，无需用户确认地连续完成所有 Phase

普通模式（无参数）

门控 — pypinyin 检查：CJK wiki 必须先确认已安装 pypinyin（python3 -c "import pypinyin"），否则后续创建中文页面时 page_bucket.py 会抛出 ImportError。缺失则提示用户安装并中止。

Read BIRTH.md, check current progress, advance to next incomplete phase.

phaseN 模式

触发条件：参数为 phaseN，N 为整数（如 phase3）。

读取 BIRTH.md 中 Phase N 的内容，按步骤逐条执行：

• 门控 1 — 实例化检查：检查 BIRTH.md 中是否存在 ^## Phase N 节。若缺失（或仅有 > 状态：未开始 占位行），报错中止并提示"请先执行 /boot init phaseN 完成实例化"
• 门控 2 — comply 质检检查：检查 Phase N 节中是否有 comply pass 记录（> **comply**: pass）。若无，报错中止并提示"请先执行 /comply boot N，质检通过后在 Phase 节标注 comply: pass 再继续"
• 若 Phase N 已全部完成（所有 [ ] 均为 [x]），输出"Phase N 已完成，下一步：/boot init phase(N+1)"并停止（禁止自动启动 butler 或任何其他工具）
• 否则从第一个未勾选的 [ ] 步骤开始执行，完成一项后将对应 [ ] 改为 [x]，更新 BIRTH.md
• 若遇到需要人工确认的步骤（如首次 git push、部署操作），暂停并等待用户确认后继续

init phaseN 模式

触发条件：参数为 init phaseN，N 为整数。

执行以下三步，顺序不可调换：

Step 1 — 补全 Phase 0 至 Phase N-1

读取本地 BIRTH.md，对每个 Phase（0 到 N-1）：

• 若该 Phase 已有完整实例化内容（非 > 状态：未开始），跳过
• 若该 Phase 仅有占位行（> 状态：未开始），从 $MEMEX_ROOT/BIRTH.spec.md 复制对应 Phase 的规范内容，根据本项目已知参数（local/config.md、LAW.md、BIRTH.md 现有信息）填写具体值，所有 [ ] 改为 [x]（视为已完成），写入 BIRTH.md。
• 补全时保留本地已有的实际 commit hash、日期、路径等具体记录，不用规范模板中的占位符覆盖。

Step 2 — 实例化 Phase N

逐字复制规则：以下类型的内容必须从 spec 原文逐字复制，禁止摘要、改写或压缩：

• ###/#### 小节标题及其紧跟的描述段落
• > 块引用（blockquote）
• ASCII 流程图（含 ┌┐└┘│⏸ 等字符的代码块）
• 代码块（``` 包裹的内容）
• 表格（含表头和注释行）

可适配的内容：仅限 - [ ] 步骤 列表中的 {{占位符}}，替换为本项目实际参数值。 其他所有 - [ ] 步骤文字也须原文复制，不得改写。

从 $MEMEX_ROOT/BIRTH.spec.md 复制 Phase N 的完整规范内容，写入本地 BIRTH.md 的对应 Phase 节（替换原有的 > 状态：未开始），执行以下替换：

• 所有 {{...}} 占位符用本项目实际参数填写
• 所有 [ ] 保持 [ ]（待执行）
• WIKI_LANG、WIKI_NAME、PORT、DEPLOY_TARGET、CDN_BASE 等从 local/config.md 读取
• 章节结构、类型体系等从 LAW.md 读取
• 语料路径等从 BIRTH.md 已有信息读取

Step 3 — 合规检查

Step 3a — 标题树结构完整性校验

从 BIRTH.spec.md 提取 Phase N 的标题树，与实例化后的 BIRTH.md 逐级对比，发现缺失则立即停止。

import re, sys
spec_path = sys.argv[1]  # BIRTH.spec.md
inst_path = sys.argv[2]  # BIRTH.md
phase_n   = int(sys.argv[3])

def extract_headings(text, phase_n):
    pat = re.compile(rf'^##\s+Phase\s+{phase_n}[\s：]', re.M)
    nxt = re.compile(rf'^##\s+Phase\s+{phase_n + 1}[\s：]', re.M)
    m = pat.search(text)
    if not m: return [], 0
    start, headings = m.start(), []
    m2 = nxt.search(text, start + 1)
    end = m2.start() if m2 else len(text)
    for h in re.findall(r'^(#{2,4}\s+.+)$', text[start:end], re.M):
        headings.append(h.strip())
    return headings, len(re.findall(r'^##\s+Phase\s+\d+', text[start:end], re.M))

spec_heads, spec_sub = extract_headings(open(spec_path).read(), phase_n)
inst_heads, inst_sub = extract_headings(open(inst_path).read(), phase_n)
missing = set(spec_heads) - set(inst_heads)
extra   = set(inst_heads) - set(spec_heads)

print(f'Spec Phase {phase_n} 标题数: {len(spec_heads)}')
print(f'实例 Phase {phase_n} 标题数: {len(inst_heads)}')
if missing:
    print(f'✗ 缺失 {len(missing)} 项：')
    for h in sorted(missing):
        print(f'  {h}')
    print('→ 补全缺失节后重新检查。')
    sys.exit(1)
if extra:
    print(f'（额外 {len(extra)} 项——疑为专有扩展，不报错）')
    for h in sorted(extra):
        print(f'  {h}')
print('✓ 结构完整，无缺失标题。')

用法：

python3 -c "$(上述代码)" $MEMEX_ROOT/BIRTH.spec.md BIRTH.md <N>

校验不通过时中止，补全缺失节后重新执行 Step 3a。通过后进入 Step 3a-2。

Step 3a-2：说明性文字完整性抽查

从实例化后的 BIRTH.md Phase N 中，抽取 2–3 个含操作指令的 ### 小节，与 BIRTH.spec.md 对应节进行逐段比对：

1. 取 spec 中该节的第一段非 checkbox 描述文字（通常是 ### 标题之后、第一个 - [ ] 之前的内容），以及该节中的代码块、ASCII 图、blockquote
2. 在实例中找到对应段落
3. 若字数差异 > 30%，或 spec 中有 ASCII 图/代码块在实例中缺失，则：
   • 打印：✗ 节 "{节标题}" 说明性文字疑似被摘要，spec 原文 N 字，实例 M 字
   • 从 spec 补全该节说明性文字，然后重新执行 Step 3a-2
4. 全部抽查节通过，输出 ✓ 说明性文字完整性抽查通过

检测 <!-- MUST-COPY --> 标注节缺失时强制中止。

通过后进入 Step 3a-3。

Step 3a-3：Content Fidelity 检查（PCF1–PCF3）

Step 3a（标题树）通过后，进一步验证内容实例化 fidelity。从 BIRTH.spec.md 对应 Phase 提取数据，与 BIRTH.md 逐项对比。

用法：

# 以下各脚本以 BIRTH.spec.md 为 spec 参数、BIRTH.md 为实例参数
SPEC=$MEMEX_ROOT/BIRTH.spec.md
INST=BIRTH.md
N=<phase_number>

PCF1 — 代码块完整性：

import re, sys
spec_path = sys.argv[1]; inst_path = sys.argv[2]; phase_n = int(sys.argv[3])
def cnt(text, pn):
    pat = re.compile(rf'^##\s+Phase\s+{pn}[\s：]', re.M)
    nxt = re.compile(rf'^##\s+Phase\s+{pn+1}[\s：]', re.M)
    m = pat.search(text)
    if not m: return 0
    s=m.start(); m2=nxt.search(text,s+1); e=m2.start() if m2 else len(text)
    return len(re.findall(r'^```', text[s:e], re.M))
sc=cnt(open(spec_path).read(),phase_n); ic=cnt(open(inst_path).read(),phase_n)
r=ic/sc*100 if sc else 100
print(f'{"✓" if ic>=sc else "✗"} PCF1: spec {sc} 代码块, 实例 {ic} ({r:.0f}%)')
if ic<sc: print(f'  → 缺失 {sc-ic} 个，补全后重新执行 Step 3a-3'); exit(1)

PCF2 — 复选框完整性：

import re, sys
spec_path=sys.argv[1]; inst_path=sys.argv[2]; phase_n=int(sys.argv[3])
def cnt(text,pn):
    pat=re.compile(rf'^##\s+Phase\s+{pn}[\s：]',re.M)
    nxt=re.compile(rf'^##\s+Phase\s+{pn+1}[\s：]',re.M)
    m=pat.search(text)
    if not m: return 0
    s=m.start(); m2=nxt.search(text,s+1); e=m2.start() if m2 else len(text)
    return len(re.findall(r'\[[\sx]\]',text[s:e]))
sc=cnt(open(spec_path).read(),phase_n); ic=cnt(open(inst_path).read(),phase_n)
r=ic/sc*100 if sc else 100
print(f'{"✓" if ic>=sc else "✗"} PCF2: spec {sc} 复选框, 实例 {ic} ({r:.0f}%)')
if ic<sc: print(f'  → 缺失 {sc-ic} 个，补全后重新执行 Step 3a-3'); exit(1)

PCF3 — 内容体量偏差：

import re, sys
spec_path=sys.argv[1]; inst_path=sys.argv[2]; phase_n=int(sys.argv[3])
def lines(text,pn):
    pat=re.compile(rf'^##\s+Phase\s+{pn}[\s：]',re.M)
    nxt=re.compile(rf'^##\s+Phase\s+{pn+1}[\s：]',re.M)
    m=pat.search(text)
    if not m: return 0
    s=m.start(); m2=nxt.search(text,s+1); e=m2.start() if m2 else len(text)
    return len(text[s:e].splitlines())
sl=lines(open(spec_path).read(),phase_n); il=lines(open(inst_path).read(),phase_n)
r=il/sl*100 if sl else 100
print(f'{"✓" if r>=50 else "✗"} PCF3: spec {sl} 行 → 实例 {il} 行 ({r:.0f}%)')
if r<50: print(f'  → 疑似摘要而非实例化（<50%），补全后重新执行 Step 3a-3'); exit(1)

全部通过后进入 Step 3b。

Step 3b — 语义合规检查

对刚写入的 Phase N 内容执行 /comply BIRTH.md phase N 检查（含 PCF4 占位符残留 + PCF5 结构性节缺失）：

• 检查内容是否忠实于 BIRTH.spec.md（无遗漏步骤、无错误参数）
• PCF4 — 检查占位符是否全部替换（不得有 {{...}} 残留）
• PCF5 — 检查结构性节是否完整（标题下的代码块/表格/列表等结构元素无缺失）
• 检查与本项目 LAW.md、CONSTITUTION.md 是否一致
• 发现偏差直接在当前对话中修正，不另起 RFC

完成后输出摘要：已补全哪些 Phase、Phase N 实例化了哪些内容、comply 发现了什么（若无问题则写"无发现"）。

--auto 模式

触发条件：参数为 --auto。

按 EGG.spec.md §Step 2 定义的循环体，从第一个未完成的 Phase 起，自动连续完成至 Phase 10，期间不向用户寻求任何确认。

循环体

读取 BIRTH.md，确定起始 Phase（第一个未全部勾选 [x] 的 Phase，最小为 1）

对 N = 起始Phase, ..., 10：
  1. /boot init phaseN   → 实例化（若该 Phase 已实例化则跳过）
  2. /comply BIRTH.md phase N → 合规检查；若有缺陷自行修正直至通过，不暂停
  3. /boot phaseN        → 执行所有 [ ] 步骤直至全部变为 [x]
  Phase N 全部 [x] 后进入 N+1

执行规则

1. 无确认原则：任何步骤均不暂停等待用户，包括 git push、发布配置等——如实际操作需要凭据或网络权限而失败，记录错误后跳过该步骤继续推进，在阶段末尾汇总跳过项

2. Phase 9 EVV 降级执行（RFC-liangjing-0008）：--auto 遇到 Phase 9 的 ⏸ 人工审核暂停点时，不等待但也不跳过。改为自动执行 EVV5/EVV6/QUO23 的评估逻辑、写日志、更新模板，仅在等待确认动作上跳过。轮次计数器正常累加，日志完整产出。详见 BIRTH.spec.md §Phase 9 "--auto 模式下的 Phase 9"。

3. comply 失败自修正：comply 发现问题时，就地修正 BIRTH.md，再次执行 comply，最多重试 3 次；3 次仍失败则记录问题、标注该 Phase 为 partial，继续下一 Phase

4. 顺序不可跳：Phase N 必须全部 [x] 完成（或标注 partial）才进入 Phase N+1

5. Phase 0 跳过：Phase 0（git + corpus）属于 Step 0，不进入本循环

6. 已完成 Phase 跳过：若某 Phase 所有 [ ] 已为 [x]，直接跳到下一 Phase

进度输出格式

每个 Phase 开始时输出一行：

▶ Phase N — init
▶ Phase N — comply
▶ Phase N — execute（M 项待完成）
✅ Phase N 完成 / ⚠️ Phase N partial（跳过 K 项，见末尾汇总）

BIRTH 实例化自检（RFC-memex-0034）

所有 Phase 完成后，在输出汇总之前执行以下自检：

# 1. 行数比
SPEC_LINES=$(wc -l < "$MEMEX_ROOT/BIRTH.spec.md")
LOCAL_LINES=$(wc -l < BIRTH.md)
RATIO=$(echo "scale=2; $LOCAL_LINES / $SPEC_LINES" | bc)
if (( $(echo "$RATIO < 0.60" | bc -l) )); then
  echo "⚠ BIRTH 行数比 ${RATIO}（期望 ≥ 0.60），实例化不完整"
fi

# 2. 子节扫描
MISSING=$(grep -oP '^### \d+-\w+' "$MEMEX_ROOT/BIRTH.spec.md" | while read h; do
  grep -qF "$h" BIRTH.md || echo "MISSING: $h"
done)
if [[ -n "$MISSING" ]]; then
  echo "⚠ 缺失子节："
  echo "$MISSING"
fi

发现不达标时，回到对应 Phase 补全后再输出汇总。

所有 Phase 完成后输出汇总：

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
/boot --auto 完成，Phase 1–10 全部处理
跳过项汇总：（若无则写"无"）
  Phase X — 步骤描述（原因）
  …
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━