@devcxl/opencode-cabbage 1.1.0 → 1.3.0

package/codex-skills/flow-tasks/SKILL.md

@@ -0,0 +1,220 @@
+---
+name: flow-tasks
+description: 将技术方案拆解为可独立实现的 tracer-bullet Task Plan 与 DAG
+---
+
+# flow-tasks
+
+将设计方案拆解为 Task Plan 与 DAG（有向无环图）。每个 Task 都是一条完整但狭窄的行为切片，可以交给一个 fresh-context developer agent 独立实现和验证。
+
+本 skill 只定义任务拆解与 Task Plan 产出。`@agent-architect` 不创建 GitHub Issue、不操作 GitHub lifecycle；调用方负责检查并发布 Task Plan。
+
+## Task 拆解规则
+
+每个 Task 必须：
+
+1. 交付一个可以观察或验证的新行为。
+2. 是垂直切片，而不是 Controller / Service / DAO 等技术分层。
+3. 可以交给一个 fresh-context developer agent 独立理解和实现。
+4. 完成以后仓库处于可工作的状态，而不是为下一个 Task 留空壳。
+5. `Blocked By` 只声明“前者未完成时，本 Task 无法开始”的真实阻塞关系。
+
+每个 Task 应适合一个 fresh-context developer agent：
+
+- 不需要读取整个 Flow 历史才能理解。
+- Task、Design 与 repository context 足够开始工作。
+- 正常情况下不需要再次进行架构设计。
+- 可以在一次独立开发循环中实现、测试、提交。
+
+## 何时拆分
+
+不要为了制造并行度而拆 Task。
+
+如果一个行为高度内聚、修改范围集中、一个 fresh context 可以完成，且没有独立可验证的中间行为，则保持为一个 Task。
+
+如果一个 Task 同时包含三个以上相互独立的“用户可以……”行为，应考虑按这些可独立验证的行为拆分。
+
+拆分前检查：
+
+1. **能否用一个 Task 完成？** — 足够内聚时不强拆。
+2. **拆开后能否独立验证？** — 每个 Task 都必须交付可观察行为。
+3. **是否真的阻塞？** — 只有无法开始的前置关系才进入 DAG。
+4. **拆开后耦合是否更低？** — 大量共享同一数据结构或模块时优先合并。
+
+## Behavior-preserving Pre-refactor
+
+行为 Task 的唯一例外是必要的 behavior-preserving pre-refactor：当现有结构使后续行为无法在一个可测试、可工作的垂直切片中安全实现时，可以先建立一个重构 Task。
+
+Pre-refactor 必须同时满足：
+
+- 不改变现有可观察行为，并用回归验证证明行为保持。
+- 自身完成后仓库保持可工作，不留下迁移一半的状态。
+- 只消除阻碍后续行为的具体结构问题，不搭通用框架、不预留未来扩展点。
+- 后续行为确实无法安全开始时，才将 pre-refactor 声明为 blocking edge。
+
+仅仅“这样更整洁”或“以后可能复用”不构成 pre-refactor。优先直接交付行为切片。
+
+Pre-refactor 的 `Builds` 应说明“保持哪个现有行为不变，并消除哪个阻碍后续行为的具体结构问题”，不能写成文件或类的修改清单。
+
+## 反模式
+
+| 反模式 | 示例 | 正确做法 |
+|--------|------|----------|
+| 技术分层拆分 | `create-session-table` → `implement-session-service` → `implement-session-api` | `create-and-restore-session` |
+| 测试单独成 Task | `add-session-tests` | 测试随行为切片一起交付 |
+| 过度拆分 | 一个内聚 CRUD 拆成多个 Task | 保持为一个可独立验证的 Task |
+| 预留式拆分 | 先搭框架，后续 Task 再填内容 | 每个 Task 完成后仓库都可工作 |
+| 虚假依赖 | 因修改相邻文件而声明依赖 | 仅声明不完成前者就无法开始的依赖 |
+
+## Task 定义
+
+每个 Task 保存为 `docs/dev/tasks/<task-name>.md`，是 developer 使用的 **Agent Implementation Contract**：
+
+`task-name` 使用简短的英文 kebab-case 行为短语，并作为后续 `feat/<task-name>` 分支名的基准。
+
+```markdown
+---
+issue: null
+test_commands:
+  - <targeted test command>
+verify_commands:
+  - <verification command>
+---
+
+# <task-slug>
+
+## Builds
+
+<这个 Task 完成后，哪个端到端行为真正可以工作？>
+
+## Acceptance Criteria
+
+- [ ] <可观察行为>
+- [ ] <边界或异常行为>
+- [ ] <回归要求>
+
+## Blocked By
+
+- <blocking-task-slug>
+- 或 None
+
+## Implementation Notes
+
+<只记录真正限制实现方式的重要设计决策；不要复制具体实现步骤。>
+```
+
+`Builds` 必须直接说明完成后的可工作行为。`Acceptance Criteria` 是 `flow-tdd` 使用的行为规格；`test_commands` 与 `verify_commands` 只放在 Task 文件中。
+
+Task 的行为测试必须沿用 Design `Testing Decisions` 中约定的 Test Seam。Task 不重新设计 Seam；如果既有 Seam 无法验证该行为，应返回 Design Gap，由调用方在当前 stage 完成 amendment。
+
+### Design Gap
+
+存量 Design 缺少 `Testing Decisions` 时，不回退 lifecycle stage，也不生成半成品 Task Plan。返回给调用方：
+
+```markdown
+## Design Gap
+
+- Current Stage: tasks
+- Design File: <docs/dev/specs/...>
+- Missing Behaviors:
+  - <缺少 Test Seam 或 Observable Result 的行为>
+- Existing Context: <已发现的公共 Interface 与测试惯例；没有则写 None>
+- Required Amendment: 为以上行为补充 Testing Decisions
+```
+
+调用方在当前 tasks 阶段完成 Design Amendment 后，重新执行 Task Planning。`@agent-architect` 不在 flow-tasks 内自行修改测试设计。
+
+规划阶段尚无 Issue 编号，`Blocked By` 使用 task slug。发布后由调用方将其更新为真实 `#<issue-number>`；无依赖时写 `None`。
+
+## DAG
+
+DAG 使用 Mermaid 语法，保存为 `docs/dev/tasks/<YYYY-MM-DD-NNN-slug>/DAG.md`。
+
+- 节点对应行为 Task，不对应技术层。
+- 边只表示真实 blocking edge。
+- 发布前必须检查环形依赖。
+- 发布后将 Task 节点与依赖更新为真实 Issue 编号。
+
+## GitHub 发布边界
+
+GitHub Sub Issue 是协作与生命周期记录，正文只提取 Task 中用户可读的内容：
+
+```markdown
+## Builds
+
+...
+
+## Acceptance Criteria
+
+- [ ] ...
+
+## Blocked By
+
+None
+```
+
+不得把 `issue`、`test_commands`、`verify_commands` 或内部实现说明复制到 GitHub Issue。
+
+发布由调用方执行：
+
+- 普通 Flow：`@agent-dev-lifecycle` 检查后自动发布。
+- 高风险 Flow：展示 Task Plan，用户确认后发布。
+- 用户主动 `/tasks`：展示 Task Plan，等待用户确认后发布。
+- `@agent-architect`：产出并返回 Task Plan 后停止，不执行发布。
+
+## Output
+
+- `docs/dev/tasks/*.md` — Agent Implementation Contracts
+- `docs/dev/tasks/<YYYY-MM-DD-NNN-slug>/DAG.md` — Task DAG
+- 返回给调用方的 Task Plan 摘要与拓扑顺序
+
+## 后续
+
+- `@agent-dev-lifecycle` 检查并发布 GitHub Sub Issues
+- **/code** — 按 Task DAG 进入编码阶段
+
+## Contract
+
+### Trigger
+由 `/tasks` 命令或 `@agent-dev-lifecycle` Phase 2 委派 `@agent-architect` 触发。
+
+### Inputs
+- `docs/dev/specs/<title>.md` — 技术方案
+- 相关 PRD 与 ADR
+- Parent Issue 编号
+
+### Preconditions
+- `/design` 已完成，技术方案和 ADR 存在
+
+### Procedure
+1. 读取设计基线与必要的 repository context。
+2. 读取 Design `Testing Decisions`，确认关键行为已有公共 Test Seam；缺失时返回 Design Gap 并停止，不生成或更新 Task 文件。
+3. 识别可独立验证的 tracer-bullet 行为切片；仅在必要时增加 behavior-preserving pre-refactor。
+4. 为每个 Task 定义 `Builds`、`Acceptance Criteria`、`Blocked By` 与必要的 `Implementation Notes`。
+5. 生成 Task 文件与 Mermaid DAG。
+6. 检查技术分层式拆分、空壳 Task、虚假依赖、臆测性 pre-refactor 与环形依赖。
+7. 返回 Task Plan、文件路径与拓扑顺序；不创建 GitHub Issue。
+
+### Outputs
+- Task 定义文件
+- Task DAG
+- 供调用方检查与发布的 Task Plan
+- 或结构化 Design Gap（存量 Design 缺少 Testing Decisions 时）
+
+### Failure
+- 无法从设计中确定可验证行为 → 暂停并指出缺失信息
+- Design Amendment 后仍缺少稳定 Test Seam → 报告未解决的 Design Gap，由调用方暂停当前阶段
+- DAG 存在环形依赖 → 阻止并报告
+- Task 无法由 fresh-context developer 独立理解 → 重新拆分或补足契约
+
+### Idempotency
+- Task 文件已存在 → 读取并更新，不创建重复定义
+- 已有 `issue` 编号 → 保留并交给调用方核验，不重复发布
+
+### Prohibited Actions
+- 不按技术层拆分 Task
+- 不为制造并行度而拆分 Task
+- 不创建完成后不可工作的空壳 Task
+- 不用 pre-refactor 包装搭框架、清理代码或预留扩展点
+- 不把非阻塞关系写入 `Blocked By`
+- `@agent-architect` 不执行 `gh issue create`、`git push`、PR、merge 或 worktree 操作

package/codex-skills/flow-tdd/SKILL.md

@@ -0,0 +1,235 @@
+---
+name: flow-tdd
+description: 公共 Test Seam 上的行为 TDD — RED→GREEN 状态机 + self-report 证据
+---
+
+# flow-tdd
+
+TDD（Test-Driven Development）Prompt 协议，为所有编码阶段提供统一的 TDD 流程约束。
+本 skill 是 TDD 协议的唯一来源，其他 skills 和 agents 通过引用本协议获得一致的 TDD 行为。
+
+## 核心原则
+
+测试是行为规格：通过 Design `Testing Decisions` 约定的公共 Test Seam 验证可观察行为，而不是验证内部实现。只要公共行为不变，重构 Module 内部实现不应导致测试失败。
+
+每个 TDD cycle 是一个最窄行为切片：
+
+```text
+确定 Test Seam 与一个行为
+        ↓
+写一个行为测试
+        ↓
+RED
+        ↓
+最小实现
+        ↓
+GREEN
+        ↓
+下一个行为
+```
+
+### 好测试
+
+- 名称描述调用者或用户可以完成什么，而不是调用了哪个内部方法。
+- 只通过约定的公共 Test Seam 触发并观察行为。
+- 期望值来自 Acceptance Criteria、已知正确示例或其他独立来源。
+- 实现重构但行为不变时仍然通过。
+
+### 反模式
+
+- **实现耦合** — 测试私有方法、内部协作对象、调用次数或调用顺序。
+- **侧信道验证** — 绕过公共 Seam 读取数据库或内部状态来证明行为。
+- **循环论证** — 用与实现相同的算法重新计算期望值。
+- **水平批量** — 先写完全部测试再实现；应按一个行为测试 → 一个最小实现逐次推进。
+- **为 mock 造抽象** — 仅允许在真实系统边界按既有 Interface 替换外部依赖，不为测试方便新增生产 Seam。
+
+## Advisory Procedure
+
+Agent 自行遵循 TDD 流程并 self-report 状态。测试质量由仓库 CI 把关，内核不强制证据。
+
+### Cycle 状态机
+
+```
+            ┌─────────────┐
+            │ cycle-start │ ← 开始新的 TDD 循环
+            └──────┬──────┘
+                   │
+                   ▼
+            ┌─────────────┐
+            │    red      │ ← 编写/更新测试，验证测试失败（RED）
+            └──────┬──────┘
+                   │
+                   ▼
+            ┌─────────────┐
+            │   green     │ ← 最小实现使测试通过（GREEN），仅做局部行为保持整理
+            └──────┬──────┘
+                   │
+        ┌──────────┼──────────┐
+        ▼          ▼          ▼
+   ┌─────────┐ ┌─────────┐ ┌──────────────┐
+   │ 下一个   │ │ abandon │ │ 所有 cycle   │
+   │ cycle   │ │ -cycle  │ │ 完成         │
+   └─────────┘ └─────────┘ └──────┬───────┘
+                                  │
+                                  ▼
+                          ┌──────────────────┐
+                          │ final-regression │ ← 运行全部测试，确认无回归
+                          └────────┬─────────┘
+                                   │
+                                   ▼
+                          ┌───────────────────┐
+                          │ final-verification│ ← 对照 Acceptance Criteria 逐条验证
+                          └───────────────────┘
+```
+
+### cycle-start
+
+开始一个新的 RED→GREEN 循环。Agent 在实现前从 Design `Testing Decisions` 读取 Test Seam，并声明本 cycle 的一个可观察行为。
+
+**self-report 格式：**
+```
+## TDD cycle-start
+- cycle: <序号>
+- behavior: <本 cycle 要交付的可观察行为>
+- test_seam: <约定的公共 Test Seam>
+- test: <通过该 Seam 验证行为的测试名称>
+```
+
+### red
+
+编写或更新测试用例，验证测试在当前实现下失败。
+
+**约束：**
+- 测试必须有明确的 fail/pass 边界
+- 测试名称描述行为，且只通过 cycle-start 声明的 Test Seam 触发和观察结果
+- RED 必须因目标行为尚未实现而失败，不能把环境、语法或夹具错误当作证据
+- 测试运行命令必须与 Task 的 `test_commands` 中定义的一致
+- 记录测试失败输出作为 RED evidence
+
+**self-report 格式：**
+```
+## TDD red
+- test: <测试名称>
+- command: <运行命令>
+- result: FAIL（预期）
+```
+
+### green
+
+编写最小实现使 RED 阶段的行为测试通过。可进行局部、行为保持的整理，但不得改变约定的 Test Seam 或扩展范围。
+
+**约束：**
+- 只写使当前测试通过的最少代码
+- 不新增与当前 test 无关的功能
+- 重构仅限于当前 cycle 涉及的代码
+- 不为通过测试而暴露内部状态、增加仅供测试使用的生产接口或改成实现细节断言
+
+**self-report 格式：**
+```
+## TDD green
+- test: <测试名称>
+- command: <运行命令>
+- result: PASS
+- changes: <涉及的文件列表>
+```
+
+### abandon-cycle
+
+当发现当前 cycle 的目标不合理、设计有缺陷或需要回退时，废弃当前 cycle 的所有修改。
+
+**触发条件：**
+- RED 阶段发现测试设计有误
+- GREEN 阶段发现需要根本性重新设计
+- 发现更简单的替代方案
+
+**流程：**
+1. 放弃当前 cycle 的修改（`git checkout -- <files>` 或 `git stash drop`）
+2. 记录 abandon 原因
+3. 重新从 cycle-start 开始
+
+**self-report 格式：**
+```
+## TDD abandon-cycle
+- cycle: <序号>
+- reason: <废弃原因>
+```
+
+### final-regression
+
+所有 cycle 完成后，运行项目全部测试套件，确认无回归。
+
+**约束：**
+- 必须运行 Task `test_commands` 中定义的全部命令
+- 所有测试必须通过
+- 如有失败 → 修复（不要求新 cycle，但需记录修复内容）
+
+**self-report 格式：**
+```
+## TDD final-regression
+- passed: <通过的测试数>
+- failed: <失败的测试数>
+- total: <测试总数>
+```
+
+### final-verification
+
+对照 Task 的 `Acceptance Criteria` 逐条验证，确认每项都由公共 Test Seam 上的行为测试或 `verify_commands` 证明。
+
+**self-report 格式：**
+```
+## TDD final-verification
+- criteria_total: <总数>
+- criteria_met: <已满足>
+- criteria_pending: <未满足>
+```
+
+## Contract
+
+### Trigger
+由编码阶段（`flow-code`）自动触发。Agent 在开始编码任务时加载 `flow-tdd` skill 获取 TDD 流程约束。
+
+### Inputs
+- Task 文件中的 `Builds` 与 `Acceptance Criteria`（来源：`flow-tasks`）
+- Task frontmatter 中的 `test_commands` 与 `verify_commands`
+- Design `Testing Decisions` 中约定的 Test Seam 与 Observable Result
+
+### Preconditions
+- Task 文件存在，包含 `Builds`、`Acceptance Criteria`、`test_commands`
+- Design 已为目标行为定义公共 Test Seam；存量 Design 缺失时先向 primary 返回 Design Gap，由兼容门在当前 stage 补齐
+- 测试运行环境就绪（worktree 内依赖已安装）
+
+### Procedure
+1. 读取 Task 的 `Builds`、`Acceptance Criteria`、`test_commands`、`verify_commands`。
+2. 读取 Design `Testing Decisions`，确认目标行为的 Test Seam 与 Observable Result。
+3. 选择一个尚未满足的行为，执行 `cycle-start` 声明 behavior、test_seam 与 test。
+4. 执行 `red` → 只写该行为测试，验证因行为缺失而失败，记录 self-report。
+5. 执行 `green` → 编写最小实现，验证通过，记录 self-report。
+6. 按一个行为切片一个 cycle 重复，直到所有 Acceptance Criteria 被覆盖。
+7. 执行 `final-regression` → 运行全部测试。
+8. 执行 `final-verification` → 通过 Test Seam 或 `verify_commands` 逐条验证 Acceptance Criteria。
+
+### Outputs
+- 每个 cycle 的 self-report
+- `final-regression` 报告（测试通过/失败统计）
+- `final-verification` 报告（criterion 覆盖情况）
+
+### Failure
+- RED 阶段测试意外通过 → 检查测试是否有意义，可能需要 abandon-cycle
+- RED 因环境、语法或夹具错误失败 → 修复测试基础设施，不能计为 RED evidence
+- 只能通过内部实现观察目标行为 → 停止编码并向 primary 返回 Design Gap，不自行修改 Design、不回退 lifecycle stage
+- GREEN 阶段测试持续失败 → 检查实现逻辑，记录失败原因
+- final-regression 失败 → 修复回归，不要求新 cycle
+- final-verification 未全部满足 → 返回未完成的 criterion，补充 cycle
+
+### Idempotency
+- 同一 cycle 重复执行 → 以最后一次结果为准
+- final-regression 重复执行 → 覆盖上次结果
+
+### Prohibited Actions
+- 不跳过 RED 阶段直接进入 GREEN
+- 不测试私有方法、内部调用次数、内部调用顺序或未约定的侧信道
+- 不一次批量编写多个行为测试后再统一实现
+- 不为了 mock 或测试方便新增生产抽象
+- 不跳过 final-regression 直接 commit
+- 不在 abandon-cycle 后保留修改
+- 不伪造测试结果（实际运行命令后再 self-report）

package/dist/hooks/session-start.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/session-start.js

@@ -0,0 +1,72 @@
+/**
+ * Cabbage Session Start Hook — loads plugin overview and project context.
+ * Runs on Codex SessionStart lifecycle event (matcher: startup|resume).
+ * Compiled to dist/hooks/session-start.js by tsc.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+// PLUGIN_ROOT is set by Codex hooks runtime
+const PROJECT_DIR = process.cwd();
+const MAX_OUTPUT_LENGTH = 12000;
+function getHeader() {
+    return `## Cabbage Development Plugin
+
+This plugin provides a full development lifecycle orchestration system.
+Load skills by name: @agent-dev-lifecycle, @agent-architect, @agent-developer, @agent-reviewer, @agent-goal-verify, @agent-researcher
+
+### Available Flow Skills
+- \`@flow-setup\` — 初始化项目开发环境
+- \`@flow-requirements\` — 需求分析产出 PRD
+- \`@flow-design\` — 技术方案与 ADR
+- \`@flow-tasks\` — DAG 任务拆解
+- \`@flow-research\` — 调研/事实核查
+- \`@flow-code\` — 编码实现（TDD）
+- \`@flow-tdd\` — TDD 协议参考
+- \`@flow-review\` — 代码审查
+- \`@flow-release\` — 发布流程
+
+### Available Agent Skills
+- \`@agent-dev-lifecycle\` — 全流程编排器（主 agent，场景分诊）
+- \`@agent-architect\` — 架构设计
+- \`@agent-developer\` — 编码实现
+- \`@agent-reviewer\` — 代码审查
+- \`@agent-goal-verify\` — 目标验证
+- \`@agent-researcher\` — 独立调研
+`;
+}
+function readProjectProfile() {
+    // Try root AGENTS.md from project directory
+    const agentsMd = join(PROJECT_DIR, "AGENTS.md");
+    if (!existsSync(agentsMd))
+        return "";
+    let content;
+    try {
+        content = readFileSync(agentsMd, "utf8");
+    }
+    catch {
+        return "";
+    }
+    // Match only the exact "## Project Profile" heading line (not "## Project Profile Notes"),
+    // and stop at the next "## " heading or end of file.
+    const lines = content.split("\n");
+    const start = lines.findIndex((line) => line.trim() === "## Project Profile");
+    if (start === -1)
+        return "";
+    const end = lines.findIndex((line, i) => i > start && /^##\s/.test(line.trim()));
+    const slice = end === -1 ? lines.slice(start) : lines.slice(start, end);
+    return slice.join("\n").trim();
+}
+function main() {
+    const header = getHeader();
+    const profile = readProjectProfile();
+    const parts = [header];
+    if (profile)
+        parts.push(`## Project Context\n\n${profile}`);
+    let output = parts.join("\n\n");
+    if (output.length > MAX_OUTPUT_LENGTH) {
+        output = `${output.slice(0, MAX_OUTPUT_LENGTH)}\n\n[context truncated — output exceeds ${MAX_OUTPUT_LENGTH} chars]`;
+    }
+    console.log(output);
+}
+main();
+//# sourceMappingURL=session-start.js.map

package/dist/hooks/session-start.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-start.js","sourceRoot":"","sources":["../../src/hooks/session-start.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAClD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAEhC,4CAA4C;AAC5C,MAAM,WAAW,GAAG,OAAO,CAAC,GAAG,EAAE,CAAA;AACjC,MAAM,iBAAiB,GAAG,KAAK,CAAA;AAE/B,SAAS,SAAS;IAChB,OAAO;;;;;;;;;;;;;;;;;;;;;;;CAuBR,CAAA;AACD,CAAC;AAED,SAAS,kBAAkB;IACzB,4CAA4C;IAC5C,MAAM,QAAQ,GAAG,IAAI,CAAC,WAAW,EAAE,WAAW,CAAC,CAAA;IAC/C,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC;QAAE,OAAO,EAAE,CAAA;IAEpC,IAAI,OAAe,CAAA;IACnB,IAAI,CAAC;QACH,OAAO,GAAG,YAAY,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAA;IAC1C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAA;IACX,CAAC;IAED,2FAA2F;IAC3F,qDAAqD;IACrD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;IACjC,MAAM,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,oBAAoB,CAAC,CAAA;IAC7E,IAAI,KAAK,KAAK,CAAC,CAAC;QAAE,OAAO,EAAE,CAAA;IAE3B,MAAM,GAAG,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAA;IAChF,MAAM,KAAK,GAAG,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;IACvE,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAA;AAChC,CAAC;AAED,SAAS,IAAI;IACX,MAAM,MAAM,GAAG,SAAS,EAAE,CAAA;IAC1B,MAAM,OAAO,GAAG,kBAAkB,EAAE,CAAA;IAEpC,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,CAAA;IACtB,IAAI,OAAO;QAAE,KAAK,CAAC,IAAI,CAAC,yBAAyB,OAAO,EAAE,CAAC,CAAA;IAE3D,IAAI,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAA;IAC/B,IAAI,MAAM,CAAC,MAAM,GAAG,iBAAiB,EAAE,CAAC;QACtC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,iBAAiB,CAAC,2CAA2C,iBAAiB,SAAS,CAAA;IACrH,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAA;AACrB,CAAC;AAED,IAAI,EAAE,CAAA"}

package/dist/kernel/session-index.d.ts

@@ -5,6 +5,8 @@ export interface FlowSessionEntry {
     continuationCount: number;
     /** goal-verify 已完成验证（goal complete）——flow 级持久化，不依赖会话一致性 */
     goalComplete?: boolean;
+    /** 最近一次实际发送续接的时刻（autoResume 重启双发防护用；区别于 updatedAt 心跳） */
+    lastContinuedAt?: number;
     updatedAt: number;
 }
 export interface SessionIndex {
@@ -15,31 +17,12 @@ export declare function sessionIndexPath(projectDir: string): string;
 export declare function readIndex(projectDir: string): Promise<SessionIndex>;
 /** 原子写：先写临时文件（PID 后缀防跨进程 tmp 冲突）再 rename。 */
 export declare function writeIndex(projectDir: string, index: SessionIndex): Promise<void>;
-export declare function getFlowSession(index: SessionIndex, parentIssueNumber: number): FlowSessionEntry | null;
-export type BindSessionResult = {
-    ok: true;
-    entry: FlowSessionEntry;
-} | {
-    ok: false;
-    code: "FLOW_SESSION_CONFLICT";
-    message: string;
-} | {
-    ok: false;
-    code: "TAKEOVER_NOT_CONFIRMED";
-    message: string;
-};
 /**
- * 绑定 parentIssueNumber → sessionID。
- * 双 session 检测（§10.3）：该 flow 已被另一 active session 绑定时拒绝。
+ * 绑定 parentIssueNumber → sessionID（goal create 时建立，供插件重启后的 autoResume 恢复）。
+ * 已绑定其它 session 时更新绑定（覆盖式，无双 session 强制）。
  */
-export declare function bindSession(projectDir: string, parentIssueNumber: number, sessionID: string): Promise<BindSessionResult>;
-/**
- * 接管绑定：旧 session 置 paused，新 session 绑定 active（R7）。
- * 旧 session 为另一 active session 时要求 userConfirmed（§10.3）；
- * 调用方还需将旧 session 的 goal status 置 paused（goalClient 层）。
- */
-export declare function takeoverSession(projectDir: string, parentIssueNumber: number, newSessionID: string, userConfirmed: boolean): Promise<BindSessionResult>;
+export declare function bindSession(projectDir: string, parentIssueNumber: number, sessionID: string): Promise<void>;
 /** 更新已绑定 flow 的状态/计数/goal 完成标记；flow 未绑定时返回 null 且不创建 entry。 */
-export declare function updateFlowSession(projectDir: string, parentIssueNumber: number, patch: Partial<Pick<FlowSessionEntry, "status" | "continuationCount" | "goalComplete">>): Promise<FlowSessionEntry | null>;
-/** 解绑：仅当 sessionID 与当前绑定匹配时删除 entry。 */
-export declare function unbindSession(projectDir: string, parentIssueNumber: number, sessionID: string): Promise<boolean>;
+export declare function updateFlowSession(projectDir: string, parentIssueNumber: number, patch: Partial<Pick<FlowSessionEntry, "status" | "continuationCount" | "goalComplete" | "lastContinuedAt">>): Promise<FlowSessionEntry | null>;
+/** 删除 flow 的索引 entry（goal cancel 时调用，避免重启 autoResume 恢复已取消 goal）。 */
+export declare function removeFlowSession(projectDir: string, parentIssueNumber: number): Promise<boolean>;

package/dist/kernel/session-index.js

@@ -35,25 +35,15 @@ export async function writeIndex(projectDir, index) {
     await writeFile(tmp, JSON.stringify(index, null, 2), "utf8");
     await rename(tmp, target);
 }
-export function getFlowSession(index, parentIssueNumber) {
-    return index.flows[String(parentIssueNumber)] ?? null;
-}
 /**
- * 绑定 parentIssueNumber → sessionID。
- * 双 session 检测（§10.3）：该 flow 已被另一 active session 绑定时拒绝。
+ * 绑定 parentIssueNumber → sessionID（goal create 时建立，供插件重启后的 autoResume 恢复）。
+ * 已绑定其它 session 时更新绑定（覆盖式，无双 session 强制）。
  */
 export async function bindSession(projectDir, parentIssueNumber, sessionID) {
     return indexMutex.runExclusive(projectDir, async () => {
         const index = await readIndex(projectDir);
         const key = String(parentIssueNumber);
         const existing = index.flows[key];
-        if (existing && existing.sessionID !== sessionID && existing.status === "active") {
-            return {
-                ok: false,
-                code: "FLOW_SESSION_CONFLICT",
-                message: `Flow #${parentIssueNumber} is already bound to active session "${existing.sessionID}". Use flow_control takeover with user confirmation to take over.`,
-            };
-        }
         const entry = {
             sessionID,
             status: "active",
@@ -62,45 +52,6 @@ export async function bindSession(projectDir, parentIssueNumber, sessionID) {
         };
         index.flows[key] = entry;
         await writeIndex(projectDir, index);
-        return { ok: true, entry };
-    });
-}
-/**
- * 接管绑定：旧 session 置 paused，新 session 绑定 active（R7）。
- * 旧 session 为另一 active session 时要求 userConfirmed（§10.3）；
- * 调用方还需将旧 session 的 goal status 置 paused（goalClient 层）。
- */
-export async function takeoverSession(projectDir, parentIssueNumber, newSessionID, userConfirmed) {
-    return indexMutex.runExclusive(projectDir, async () => {
-        const index = await readIndex(projectDir);
-        const key = String(parentIssueNumber);
-        const existing = index.flows[key];
-        if (existing && existing.sessionID !== newSessionID && existing.status === "active" && !userConfirmed) {
-            return {
-                ok: false,
-                code: "TAKEOVER_NOT_CONFIRMED",
-                message: `Flow #${parentIssueNumber} is bound to active session "${existing.sessionID}". Takeover requires user confirmation (user_confirmed: true).`,
-            };
-        }
-        if (existing) {
-            if (existing.sessionID === newSessionID) {
-                const entry = { ...existing, status: "active", updatedAt: Date.now() };
-                index.flows[key] = entry;
-                await writeIndex(projectDir, index);
-                return { ok: true, entry };
-            }
-            existing.status = "paused";
-            existing.updatedAt = Date.now();
-        }
-        const entry = {
-            sessionID: newSessionID,
-            status: "active",
-            continuationCount: 0,
-            updatedAt: Date.now(),
-        };
-        index.flows[key] = entry;
-        await writeIndex(projectDir, index);
-        return { ok: true, entry };
     });
 }
 /** 更新已绑定 flow 的状态/计数/goal 完成标记；flow 未绑定时返回 null 且不创建 entry。 */
@@ -120,13 +71,12 @@ export async function updateFlowSession(projectDir, parentIssueNumber, patch) {
         return entry;
     });
 }
-/** 解绑：仅当 sessionID 与当前绑定匹配时删除 entry。 */
-export async function unbindSession(projectDir, parentIssueNumber, sessionID) {
+/** 删除 flow 的索引 entry（goal cancel 时调用，避免重启 autoResume 恢复已取消 goal）。 */
+export async function removeFlowSession(projectDir, parentIssueNumber) {
     return indexMutex.runExclusive(projectDir, async () => {
         const index = await readIndex(projectDir);
         const key = String(parentIssueNumber);
-        const existing = index.flows[key];
-        if (!existing || existing.sessionID !== sessionID)
+        if (!index.flows[key])
             return false;
         delete index.flows[key];
         await writeIndex(projectDir, index);