@bolloon/bolloon-agent 0.1.0

package/src/bollharness/.boll/skills/context-chains/work-type-extractors/planning_extractor.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env node
+/**
+ * planning_extractor.ts
+ *
+ * 从 planning 类型会话中萃取核心摘要
+ * 遵循 context-chains SKILL.md 的 planning schema
+ */
+
+interface PlanningSummary {
+  session_id: string;
+  work_type: 'planning';
+  created_at: string;
+  gate_at_session: number;
+  '关联上下文': Array<{ session_id: string; reason: string; relevance: number }>;
+  '核心摘要': {
+    goals: Array<{
+      description: string;
+      acceptance_criteria: string[];
+    }>;
+    dependencies: Array<{
+      on_artifact: string;
+      type: 'blocks' | 'informs';
+    }>;
+    risks: Array<{
+      description: string;
+      probability: 'high' | 'medium' | 'low';
+      mitigation: string;
+    }>;
+    decision_gaps: Array<{
+      question: string;
+      stakes: string;
+      owner: string;
+    }>;
+  };
+  '风险点': Array<{ 描述: string; 概率: 'high' | 'medium' | 'low'; 缓解措施: string }>;
+  '遗迹': string[];
+}
+
+function extractGoals(text: string): PlanningSummary['核心摘要']['goals'] {
+  const goals: PlanningSummary['核心摘要']['goals'] = [];
+
+  const goalPattern = /(?:目标|goal|目的|我们要|需要完成):\s*(.+)/gi;
+  let match;
+
+  while ((match = goalPattern.exec(text)) !== null) {
+    goals.push({
+      description: match[1].trim(),
+      acceptance_criteria: [],
+    });
+  }
+
+  return goals;
+}
+
+function extractDependencies(text: string): PlanningSummary['核心摘要']['dependencies'] {
+  const deps: PlanningSummary['核心摘要']['dependencies'] = [];
+
+  const depPattern = /(?:依赖|depends on|取决于|blocked by|依赖于):\s*(.+)/gi;
+  let match;
+
+  while ((match = depPattern.exec(text)) !== null) {
+    const artifact = match[1].trim();
+    const type = text.toLowerCase().includes('block') ? 'blocks' : 'informs';
+    deps.push({ on_artifact: artifact, type });
+  }
+
+  return deps;
+}
+
+function extractRisks(text: string): PlanningSummary['核心摘要']['risks'] {
+  const risks: PlanningSummary['核心摘要']['risks'] = [];
+
+  const riskKeywords = ['风险', 'risk', '可能失败', '不确定性', 'concern'];
+  const probabilityKeywords = {
+    high: ['高', '很可能', 'likely', 'high probability'],
+    medium: ['中', '可能', 'possible', 'medium'],
+    low: ['低', '不太可能', 'unlikely', 'low probability'],
+  };
+
+  const sentences = text.split(/[.!?]/);
+  for (const sentence of sentences) {
+    const lower = sentence.toLowerCase();
+    for (const keyword of riskKeywords) {
+      if (lower.includes(keyword)) {
+        let probability: 'high' | 'medium' | 'low' = 'medium';
+        for (const [prob, words] of Object.entries(probabilityKeywords)) {
+          if (words.some(w => lower.includes(w))) {
+            probability = prob as 'high' | 'medium' | 'low';
+            break;
+          }
+        }
+        risks.push({
+          description: sentence.trim().slice(0, 100),
+          probability,
+          mitigation: '',
+        });
+      }
+    }
+  }
+
+  return risks;
+}
+
+function extractDecisionGaps(text: string): PlanningSummary['核心摘要']['decision_gaps'] {
+  const gaps: PlanningSummary['核心摘要']['decision_gaps'] = [];
+
+  const gapPatterns = [
+    /(?:待定|未决定|TBD|to be determined|还未确定):\s*(.+)/gi,
+    /(?:谁决定|who decides|owner):\s*(.+)/gi,
+    /(?:决策缺口|decision gap):\s*(.+)/gi,
+  ];
+
+  for (const pattern of gapPatterns) {
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+      gaps.push({
+        question: match[1].trim(),
+        stakes: '',
+        owner: '',
+      });
+    }
+  }
+
+  return gaps;
+}
+
+function buildSummary(input: {
+  sessionId: string;
+  gate: number;
+  conversationText: string;
+  relatedSessions?: Array<{ sessionId: string; reason: string; relevance: number }>;
+}): PlanningSummary {
+  return {
+    session_id: input.sessionId,
+    work_type: 'planning',
+    created_at: new Date().toISOString(),
+    gate_at_session: input.gate,
+    '关联上下文': input.relatedSessions || [],
+    '核心摘要': {
+      goals: extractGoals(input.conversationText),
+      dependencies: extractDependencies(input.conversationText),
+      risks: extractRisks(input.conversationText),
+      decision_gaps: extractDecisionGaps(input.conversationText),
+    },
+    '风险点': [],
+    '遗迹': [],
+  };
+}
+
+export { buildSummary, type PlanningSummary };
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const [sessionId, gate] = args;
+  const fs = require('fs');
+  const conversationText = args[2]
+    ? fs.readFileSync(args[2], 'utf-8')
+    : fs.readFileSync('/dev/stdin', 'utf-8');
+
+  const summary = buildSummary({ sessionId, gate: parseInt(gate, 10), conversationText });
+  console.log(JSON.stringify(summary, null, 2));
+}

package/src/bollharness/.boll/skills/context-chains/work-type-extractors/question_extractor.ts

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+/**
+ * question_extractor.ts
+ *
+ * 从 question 类型会话中萃取核心摘要
+ * 遵循 context-chains SKILL.md 的 question schema
+ */
+
+interface QuestionSummary {
+  session_id: string;
+  work_type: 'question';
+  created_at: string;
+  gate_at_session: number;
+  '关联上下文': Array<{ session_id: string; reason: string; relevance: number }>;
+  '核心摘要': {
+    question_type: 'concept' | 'implementation' | 'debugging' | 'tool_usage' | 'unknown';
+    answer_summary: string;
+    source: string;
+    related_context: Array<{
+      session_id: string;
+      relevance: number;
+    }>;
+  };
+  '决策缺口': Array<{ 描述: string; 影响: string; 需要什么才能关闭: string }>;
+  '遗迹': string[];
+}
+
+function extractQuestionType(text: string): QuestionSummary['核心摘要']['question_type'] {
+  const lower = text.toLowerCase();
+
+  if (lower.includes('concept') || lower.includes('概念') || lower.includes('原理')) {
+    return 'concept';
+  }
+  if (lower.includes('implement') || lower.includes('实现') || lower.includes('怎么写')) {
+    return 'implementation';
+  }
+  if (lower.includes('debug') || lower.includes('调试') || lower.includes('报错')) {
+    return 'debugging';
+  }
+  if (lower.includes('tool') || lower.includes('命令') || lower.includes('怎么用')) {
+    return 'tool_usage';
+  }
+
+  return 'unknown';
+}
+
+function extractAnswer(text: string): string {
+  // Look for answer patterns
+  const answerPatterns = [
+    /(?:答案是|answer is|正确答案是|应该是):\s*(.+)/gi,
+    /(?:总结|summary|结论|conclusion):\s*(.+)/gi,
+  ];
+
+  for (const pattern of answerPatterns) {
+    const match = pattern.exec(text);
+    if (match) {
+      return match[1].trim();
+    }
+  }
+
+  return '';
+}
+
+function extractSource(text: string): string {
+  const sourcePatterns = [
+    /(?:来自|from|来源|source):\s*(.+)/gi,
+    /(?:文档|doc|文档说明):\s*(.+)/gi,
+    /(?:代码|code):\s*(.+)/gi,
+  ];
+
+  for (const pattern of sourcePatterns) {
+    const match = pattern.exec(text);
+    if (match) {
+      return match[1].trim();
+    }
+  }
+
+  return '';
+}
+
+function buildSummary(input: {
+  sessionId: string;
+  gate: number;
+  conversationText: string;
+  relatedSessions?: Array<{ sessionId: string; reason: string; relevance: number }>;
+}): QuestionSummary {
+  return {
+    session_id: input.sessionId,
+    work_type: 'question',
+    created_at: new Date().toISOString(),
+    gate_at_session: input.gate,
+    '关联上下文': input.relatedSessions || [],
+    '核心摘要': {
+      question_type: extractQuestionType(input.conversationText),
+      answer_summary: extractAnswer(input.conversationText),
+      source: extractSource(input.conversationText),
+      related_context: [],
+    },
+    '决策缺口': [],
+    '遗迹': [],
+  };
+}
+
+export { buildSummary, type QuestionSummary };
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const [sessionId, gate] = args;
+  const fs = require('fs');
+  const conversationText = args[2]
+    ? fs.readFileSync(args[2], 'utf-8')
+    : fs.readFileSync('/dev/stdin', 'utf-8');
+
+  const summary = buildSummary({ sessionId, gate: parseInt(gate, 10), conversationText });
+  console.log(JSON.stringify(summary, null, 2));
+}

package/src/bollharness/.boll/skills/context-chains/work-type-extractors/review_extractor.ts

@@ -0,0 +1,136 @@
+#!/usr/bin/env node
+/**
+ * review_extractor.ts
+ *
+ * 从 review 类型会话中萃取核心摘要
+ * 遵循 context-chains SKILL.md 的 review schema
+ */
+
+interface ReviewSummary {
+  session_id: string;
+  work_type: 'review';
+  created_at: string;
+  gate_at_session: number;
+  '关联上下文': Array<{ session_id: string; reason: string; relevance: number }>;
+  '核心摘要': {
+    verdict: 'PASS' | 'BLOCK' | 'CONDITIONAL';
+    reviewed_artifact: string;
+    blocking_issues: Array<{
+      severity: 'blocker' | 'warning' | 'nit';
+      description: string;
+      pattern?: string;
+    }>;
+    non_blocking_observations: string[];
+    reviewer_preference_patterns: Array<{ pattern: string; frequency: number }>;
+  };
+  '决策缺口': Array<{ 描述: string; 影响: string; 需要什么才能关闭: string }>;
+  '风险点': Array<{ 描述: string; 概率: 'high' | 'medium' | 'low'; 缓解措施: string }>;
+  '遗迹': string[];
+}
+
+function extractVerdict(conversationText: string): ReviewSummary['核心摘要']['verdict'] {
+  const upper = conversationText.toUpperCase();
+  if (upper.includes('BLOCK') || upper.includes('REJECT') || upper.includes('FAIL')) {
+    return 'BLOCK';
+  }
+  if (upper.includes('CONDITIONAL') || upper.includes('CONDITION')) {
+    return 'CONDITIONAL';
+  }
+  return 'PASS';
+}
+
+function extractBlockingIssues(conversationText: string): ReviewSummary['核心摘要']['blocking_issues'] {
+  const issues: ReviewSummary['核心摘要']['blocking_issues'] = [];
+
+  // Extract patterns like "blocker:", "issue:", "problem:"
+  const blockerPattern = /(?:blocker|blocking|issue|problem|concern):\s*(.+)/gi;
+  let match;
+
+  while ((match = blockerPattern.exec(conversationText)) !== null) {
+    const desc = match[1].trim();
+    const severity = desc.toLowerCase().includes('nit')
+      ? 'nit'
+      : desc.toLowerCase().includes('warning')
+        ? 'warning'
+        : 'blocker';
+
+    issues.push({ severity, description: desc });
+  }
+
+  return issues;
+}
+
+function extractPreferencePatterns(conversationText: string): ReviewSummary['核心摘要']['reviewer_preference_patterns'] {
+  const patterns: ReviewSummary['核心摘要']['reviewer_preference_patterns'] = [];
+
+  // Common reviewer preference keywords
+  const prefKeywords = [
+    'should always', 'must be', 'avoid', 'prefer', 'recommend',
+    'never', 'always', 'consider', 'take care', '注意',
+  ];
+
+  const sentences = conversationText.split(/[.!?]/);
+  const prefCounts: Record<string, number> = {};
+
+  for (const sentence of sentences) {
+    const lower = sentence.toLowerCase();
+    for (const keyword of prefKeywords) {
+      if (lower.includes(keyword)) {
+        const normalized = sentence.trim().slice(0, 50);
+        prefCounts[normalized] = (prefCounts[normalized] || 0) + 1;
+      }
+    }
+  }
+
+  for (const [pattern, count] of Object.entries(prefCounts)) {
+    if (count >= 2) {
+      patterns.push({ pattern, frequency: count });
+    }
+  }
+
+  return patterns;
+}
+
+function buildSummary(input: {
+  sessionId: string;
+  gate: number;
+  conversationText: string;
+  relatedSessions?: Array<{ sessionId: string; reason: string; relevance: number }>;
+}): ReviewSummary {
+  return {
+    session_id: input.sessionId,
+    work_type: 'review',
+    created_at: new Date().toISOString(),
+    gate_at_session: input.gate,
+    '关联上下文': input.relatedSessions || [],
+    '核心摘要': {
+      verdict: extractVerdict(input.conversationText),
+      reviewed_artifact: '',
+      blocking_issues: extractBlockingIssues(input.conversationText),
+      non_blocking_observations: [],
+      reviewer_preference_patterns: extractPreferencePatterns(input.conversationText),
+    },
+    '决策缺口': [],
+    '风险点': [],
+    '遗迹': [],
+  };
+}
+
+export { buildSummary, type ReviewSummary };
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  if (args.length < 2) {
+    console.error('Usage: review_extractor.ts <session_id> <gate> [conversation_file]');
+    process.exit(1);
+  }
+
+  const [sessionId, gate] = args;
+  const fs = require('fs');
+  const conversationText = args[2]
+    ? fs.readFileSync(args[2], 'utf-8')
+    : fs.readFileSync('/dev/stdin', 'utf-8');
+
+  const summary = buildSummary({ sessionId, gate: parseInt(gate, 10), conversationText });
+  console.log(JSON.stringify(summary, null, 2));
+}

package/src/bollharness/.boll/skills/crystal-learn/SKILL.md

@@ -0,0 +1,93 @@
+---
+name: crystal-learn
+description: 结晶学习 — 自省与进化。提取结构性失败模式，形成不变量（invariant），并把它们注入执行层 skill。
+status: active
+tier: meta
+owner: {{PROJECT_OWNER}}
+last_audited: 2026-04-09
+triggers:
+  - PLAN / ISSUE / transcript 复盘
+  - 多 agent 失误复发
+  - skill 自审
+outputs:
+  - invariant delta
+  - target injection map
+truth_policy:
+  - 不变量正文留在 invariants/ 子目录，不在执行层重复长篇理论
+  - 只有跨计划验证过的模式才升级为已确认 invariant
+  - 已确认 invariant 必须映射到 active target skill
+---
+
+# 结晶学习
+
+## 我是谁
+
+我是 harness 的适应性免疫系统。我不修具体 bug，也不写产品代码。我提取"这类错误为什么总会回来"，把它们压成少量**不变量（invariant）**，然后注入到会被日常加载的执行 skill。
+
+不变量不是风格建议，是**事后被证明违反即出事**的结构约束。一条真的不变量应该满足：违反它一次，可能没事；违反它三次，一定出事；而且所有三次的现场看起来完全不同。
+
+## 工作对象
+
+输入优先级：
+
+1. PLAN / REVIEW / ISSUE 中的偏差记录
+2. transcript 中的认知转折点
+3. 多 agent 并行中的接缝事故
+4. 守护工具自身的漂移
+
+完整不变量正文与实例保留在 `invariants/` 子目录。
+
+## 升级规则
+
+一个模式只有在满足以下条件后才算**已确认 invariant**：
+
+- 不是单点 bug，而是结构性偏差
+- 至少在两个独立案例中出现，或在一个案例中呈现清晰的系统性形状
+- 能转换成跨场景可迁移的行动指令
+- 能映射到至少一个 active skill
+
+没有到这个门槛的叫**候选模式**，记录在 `invariants/` 的 candidate 段落，不进入 target injection map。
+
+## 注入执行层
+
+我的硬契约不是"提取教训"，而是"让教训改变执行 skill"。只写在 memory / reference 里的教训等于没提取——下一次 agent 不会去读。
+
+注入规则：
+
+- 注入到**最可能违反它的 skill**，不一定是写代码的 skill
+- 执行层只保留 3-5 行行动指令（"当 X 发生时，做 Y"）
+- `invariants/` 保留完整理论和案例
+- target skill 更新后，`last_audited` 必须刷新
+
+## 当前注入地图
+
+| Invariant | 名称 | 正文 | Target skills |
+|-----------|------|------|---------------|
+| `INV-0`  | 快照幻觉 | `invariants/INV-0.md` | `harness-eng` |
+| `INV-0b` | 合并幻觉 | `invariants/INV-0b.md` | `harness-eng` |
+| `INV-1`  | 波纹衰减 | `invariants/INV-1.md` | `harness-dev` |
+| `INV-2`  | 格式断崖 | `invariants/INV-2.md` | `harness-dev`, `harness-ops` |
+| `INV-3`  | 并发写入 | `invariants/INV-3.md` | `harness-eng` |
+| `INV-4`  | 真相源分裂 | `invariants/INV-4.md` | `harness-ops`, `lead`, `harness-eng-test` |
+| `INV-5`  | 语义搭便车 | `invariants/INV-5.md` | `harness-dev` |
+| `INV-6`  | 验证衰减 | `invariants/INV-6.md` | `lead`, `harness-eng-test` |
+| `INV-7`  | 无主接缝 | `invariants/INV-7.md` | `task-arch`, `plan-lock`, `lead` |
+
+## Output Contract
+
+每次使用我，默认给：
+
+1. `invariant delta`
+   - 新确认了什么
+   - 哪条只是候选
+   - 哪条只是新增实例
+2. `target injection map`
+   - 目标 skill
+   - 需要注入的行动指令
+   - 为什么放在那里
+
+## 不做什么
+
+- 不把 `invariants/` 当执行文档（它太厚，日常加载会污染执行 skill 的上下文预算）
+- 不把一次性修复误判成 invariant（一次不算，两次是巧合，三次才是结构）
+- 不接受"记住这个教训就好"作为闭环——必须落到某个 target skill 的可执行指令

package/src/bollharness/.boll/skills/crystal-learn/invariants/INV-0.md

@@ -0,0 +1,34 @@
+# INV-0 快照幻觉 (Snapshot Hallucination)
+
+**分类**: 已确认 invariant
+**Target skill**: `harness-eng`
+
+## 模式定义
+
+Agent 在做并行编排或计划时，使用"某个时间点拍下的代码快照"作为决策依据——但执行发生在快照之后，仓库已漂移，快照中提到的文件/函数/签名可能已不存在。
+
+决策发生在 T0，执行发生在 T1，两者之间的代码变更被 agent 当成不存在。
+
+## 典型形状
+
+- "我看到 `module/foo.ts` 里有 `Handler.process()`，WP-03 改这个函数即可"——实际 `process` 已改名为 `handle_request`。
+- "刚才 grep 过 5 个调用方"——实际 grep 是半小时前的结果，其间有两个新增调用方。
+- 多个 WP 引用同一份"现状分析文档"，但文档本身从未被更新。
+
+## 检测信号
+
+- 计划文档里的文件名/函数名在当前仓库 grep 不到
+- 同一次会话中多次引用"刚才看过的状态"而没有重新 Read
+- task-arch 阶段产生的 WP 清单与 Gate 7 实际执行时的文件状态不符
+
+## 缓解动作
+
+**注入到 `harness-eng`**：
+
+1. 任何跨 WP 的代码引用必须在**执行时刻**重新 Read，不能依赖 plan 阶段的 grep 结果。
+2. 计划文档的"现状快照"段落必须标注 `snapshot_at: <commit sha>`；当前 HEAD 与该 sha 不同时，agent 必须重跑快照。
+3. 多 WP 并行时，第二个 WP 开始前必须 `git status` 对齐。
+
+## 实例池
+
+（案例留空，由后续 PLAN 复盘填充。模式本身已在上游 harness 的多个并行实验中独立出现至少三次，满足升级门槛。）

package/src/bollharness/.boll/skills/crystal-learn/invariants/INV-1.md

@@ -0,0 +1,34 @@
+# INV-1 波纹衰减 (Ripple Decay)
+
+**分类**: 已确认 invariant
+**Target skill**: `harness-dev`
+
+## 模式定义
+
+一个改动从源头发出时是"强波纹"——开发者清楚它会影响 A/B/C 三个下游。随着改动沿调用链向外传播，agent 对"这里还要不要改"的意识逐层衰减；传到第四层时，改动已被遗忘，该层保留着旧语义。
+
+核心反差：**agent 改动源头时很清醒，传播时很健忘**。
+
+## 典型形状
+
+- 改了某个字段的序列化格式，改了直接调用方，但漏了通过消息队列异步消费的下游。
+- 改了 API 请求 schema，改了 handler，但漏了 OpenAPI 文档 / 前端类型定义 / 集成测试 fixture。
+- 改了某个默认值，但配置迁移脚本里还写着旧值作为"兜底"。
+
+## 检测信号
+
+- 改动 commit 只触及 2-3 个文件，但函数/字段被 10+ 处引用
+- 某层下游的测试在改动后仍 pass（可疑——应该要么被更新要么至少失败）
+- 修完一个 bug 后几天又出现"新"的同形状 bug
+
+## 缓解动作
+
+**注入到 `harness-dev`**：
+
+1. 任何契约类改动（API / schema / event / 配置项）必须先跑**全量消费方 grep**，列出 N 个位置，对每个位置显式打 "改 / 不改 + 原因" 标签。
+2. "不改 + 原因"的位置数 > 0 时，原因必须写在 PR 描述里，供审查核验。
+3. Agent 在 diff 只涉及 1-2 个文件时要警惕："是真的就这 2 处，还是我漏看了消费方？"
+
+## 与 INV-4 的关系
+
+INV-4（真相源分裂）是"同一事实被写在多处"的**存量**问题；INV-1 是"一次改动未传播到全部消费方"的**流量**问题。实际上 INV-4 很多时候是 INV-1 积累出来的——每次都漏一个下游，下游就变成新的事实副本。

package/src/bollharness/.boll/skills/crystal-learn/invariants/INV-2.md

@@ -0,0 +1,35 @@
+# INV-2 格式断崖 (Format Cliff)
+
+**分类**: 已确认 invariant
+**Target skills**: `harness-dev`, `harness-ops`
+
+## 模式定义
+
+Agent 在拼接/转换数据时，假设上游输出是"结构化的"（dict / JSON / YAML），但上游实际输出是"近似结构化的字符串"——大多数时候能用 `JSON.parse()` 解析成功，某些 edge case 时解析失败。成功路径运行了 99 次，失败的第 100 次产生一个看起来与任何代码无关的崩溃。
+
+命名"断崖"是因为：99% 的输入落在平地上，1% 的输入落下悬崖，中间没有坡。
+
+## 典型形状
+
+- LLM 输出"JSON"，但偶尔包含未转义的内部引号
+- 日志行被当作 TSV 解析，但某个字段里偶尔出现制表符
+- 配置文件被当作 YAML 解析，但某次手动编辑引入了一个 tab 缩进
+- CSV 中偶尔有字段包含换行或逗号
+
+## 检测信号
+
+- 错误日志里出现极低频率的 `JSONDecodeError` / `YAMLParseError` 但没人修
+- "大多数时候没问题"成为某个路径的维护状态
+- 有 try/except 吞掉解析错误然后走降级分支——降级分支从未被测试
+
+## 缓解动作
+
+**注入到 `harness-dev`**：
+
+1. 任何"解析字符串→结构"的边界必须有**显式的 schema 验证**（zod / jsonschema / 自写的 assert），而不是 `JSON.parse()` 就过。
+2. 解析失败不得静默降级。降级路径必须有明确的触发条件和可观测信号。
+3. LLM 输出 parsing 走 strict mode（失败 → 重试或显错），不做"尽力而为"。
+
+**注入到 `harness-ops`**：
+
+4. 日志/配置/数据文件的 schema 一旦定义，变更前必须过 INV-4 门禁——格式演进是真相源分裂的常见温床。

package/src/bollharness/.boll/skills/crystal-learn/invariants/INV-3.md

@@ -0,0 +1,34 @@
+# INV-3 并发写入 (Concurrent Write)
+
+**分类**: 已确认 invariant
+**Target skill**: `harness-eng`
+
+## 模式定义
+
+多个并行 WP（或多个并行 agent）对同一个文件/资源/共享状态写入，没有显式的写入 owner 或锁，结果是最后一个写入者覆盖前面所有人的工作——前面的工作**没有报错**，只是消失了。
+
+这是"静默数据丢失"的典型形态。CI 绿、测试过、git 历史干净，但某个 WP 的成果不见了。
+
+## 典型形状
+
+- 两个并行 agent 都往 MEMORY.md 追加内容，后写的覆盖了先写的整个文件（不是 append，是重写）
+- 并行 WP 各自更新 `settings.json`，后一个用完整的文件 Write 而不是 Edit，吞掉前一个的字段
+- 两个 track 都 regenerate 了同一个 auto-generated 文件，后 regenerate 的版本缺少前一个 track 的输入
+
+## 检测信号
+
+- `git log --follow <file>` 显示同一文件在短时间内被多次完整重写
+- 某个 WP 的 LOG 说"已写入字段 X"，但最终文件里没有 X
+- 并行 track 的 parallel_contract 里 write_set 有重叠但未指定 seam_owner
+
+## 缓解动作
+
+**注入到 `harness-eng`**：
+
+1. `parallel_contract.write_set` 必须不相交。相交的文件必须提升成 seam，并指定 seam_owner 做单点写入。
+2. 共享状态文件（MEMORY.md / settings.json / MANIFEST.yaml）的并发写入一律通过 seam_owner 串行化，不允许并行 track 直接触碰。
+3. 禁止 agent 用 `Write` 工具覆盖文件去做"追加"——追加必须用 `Edit` 或 `cat >>`，保证读后写。
+
+## 与 INV-7 的关系
+
+INV-3 是无主接缝（INV-7）在"文件写入"维度的具体后果。INV-7 在计划阶段拦，INV-3 在执行阶段兜底。两层都失守才会出事。