cc-devflow 4.5.9 → 4.5.10

package/lib/skill-runtime/CLAUDE.md

@@ -4,7 +4,7 @@
 职责分组
 入口层: `cli.js` 负责命令分发，`index.js` 提供给测试和内部脚本的稳定聚合入口。
 基础层: `schemas.js`、`store.js`、`paths.js` 管住契约、持久化与路径规则，避免执行层重复造轮子。
-状态层: `artifacts.js`、`lifecycle.js`、`query.js`、`review.js`、`team-state.js` 维护运行时真相源与只读查询。
+状态层: `artifacts.js`、`lifecycle.js`、`query.js`、`workflow-context.js`、`review.js`、`team-state.js` 维护运行时真相源与只读查询。
 规划与交接: `planner.js`、`intent.js`、`delegation.js` 把任务解析、handoff 生成和 team/workspace 委派收口成统一语义。
 阶段操作: `operations/` 是唯一 stage 入口目录；具体阶段边界见 `operations/CLAUDE.md`。
 测试布局: `__tests__/` 紧贴模块放置单元、回归与集成测试；顶层 `test/` 不再承载 `skill-runtime` 私有测试。

package/lib/skill-runtime/__tests__/autopilot.test.js

@@ -9,13 +9,13 @@ const {
   getTaskManifestPath,
   getReportCardPath,
   getReleaseNotePath,
-  getRuntimeStatePath,
-  getCheckpointPath
+  getRuntimeStatePath
 } = require('../store');
 const {
   getIntentResumeIndexPath,
   getIntentPrBriefPath
 } = require('../artifacts');
+const { getChangePaths } = require('../paths');
 
 jest.setTimeout(20000);
 
@@ -41,6 +41,41 @@ function markManifestReviewsPassed(repoRoot, changeId) {
   fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`);
 }
 
+function writeCleanReviewLedger(repoRoot, changeId) {
+  const change = getChangePaths(repoRoot, changeId);
+  const ledgerPath = path.join(change.reviewDir, 'review-ledger.jsonl');
+  fs.mkdirSync(path.dirname(ledgerPath), { recursive: true });
+  fs.writeFileSync(ledgerPath, [
+    JSON.stringify({
+      schema: 'review-ledger.v2',
+      change: change.changeKey,
+      reviewId: 'RVW-20260512-001',
+      createdAt: '2026-05-12T00:00:00.000Z',
+      createdBy: 'cc-devflow-cli',
+      event: 'review-started',
+      mode: 'implementation',
+      scope: 'current-diff',
+      baseSha: 'abc123',
+      headSha: 'def456',
+      selectedNodes: [],
+      skippedNodes: [],
+      riskLanes: []
+    }),
+    JSON.stringify({
+      schema: 'review-ledger.v2',
+      change: change.changeKey,
+      reviewId: 'RVW-20260512-001',
+      createdAt: '2026-05-12T00:01:00.000Z',
+      createdBy: 'cc-devflow-cli',
+      event: 'review-closed',
+      status: 'clean',
+      blockingCount: 0,
+      warningCount: 0,
+      next: 'cc-check'
+    })
+  ].join('\n'));
+}
+
 describe('runAutopilot', () => {
   test('stops at the approval gate after planning without writing approval-phase handoff markdown', async () => {
     const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-autopilot-'));
@@ -81,7 +116,7 @@ describe('runAutopilot', () => {
     expect(fs.existsSync(getIntentResumeIndexPath(repoRoot, 'REQ-123'))).toBe(false);
   });
 
-  test('resumes after approval, executes delegated work, and prepares a PR from checkpoints', async () => {
+  test('resumes after approval, executes delegated work, and prepares a PR from task state', async () => {
     const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-autopilot-workers-'));
 
     writeJson(path.join(repoRoot, 'package.json'), {
@@ -123,17 +158,16 @@ describe('runAutopilot', () => {
     });
 
     const manifest = JSON.parse(fs.readFileSync(getTaskManifestPath(repoRoot, 'REQ-123'), 'utf8'));
-    const delegatedCheckpoint = JSON.parse(fs.readFileSync(getCheckpointPath(repoRoot, 'REQ-123', 'T002'), 'utf8'));
     const report = JSON.parse(fs.readFileSync(getReportCardPath(repoRoot, 'REQ-123'), 'utf8'));
 
     expect(firstRun.executed).toEqual(expect.arrayContaining(['delegate', 'worker-run', 'dispatch', 'verify']));
     expect(firstRun.currentStage).toBe('verify');
     expect(manifest.tasks.find((task) => task.id === 'T002').status).toBe('passed');
-    expect(delegatedCheckpoint.outputExcerpt).toContain('delegate-ok');
     expect(report.review.status).toBe('blocked');
     expect(fs.existsSync(getIntentPrBriefPath(repoRoot, 'REQ-123'))).toBe(false);
 
     markManifestReviewsPassed(repoRoot, 'REQ-123');
+    writeCleanReviewLedger(repoRoot, 'REQ-123');
 
     const secondRun = await runAutopilot({
       repoRoot,
@@ -146,7 +180,8 @@ describe('runAutopilot', () => {
 
     expect(secondRun.executed).toEqual(expect.arrayContaining(['verify', 'prepare-pr']));
     expect(secondRun.currentStage).toBe('prepare-pr');
-    expect(prBrief).toContain('execution/tasks/T002/checkpoint.json');
+    expect(prBrief).toContain('planning/task-manifest.json');
+    expect(prBrief).not.toContain('checkpoint.json');
   });
 
   test('runs release after prepare-pr when requested for an approved plan', async () => {
@@ -195,6 +230,7 @@ describe('runAutopilot', () => {
     expect(fs.existsSync(getReleaseNotePath(repoRoot, 'REQ-123'))).toBe(false);
 
     markManifestReviewsPassed(repoRoot, 'REQ-123');
+    writeCleanReviewLedger(repoRoot, 'REQ-123');
 
     const result = await runAutopilot({
       repoRoot,

package/lib/skill-runtime/__tests__/benchmark-artifacts.test.js

@@ -0,0 +1,165 @@
+/**
+ * [INPUT]: 依赖 scripts/benchmark-artifacts.js 导出的 runBenchmarkArtifacts 和临时 artifact fixture。
+ * [OUTPUT]: 验证 benchmark:artifacts 使用 ceil(len/4) 估算并报告 profile 阈值 savings。
+ * [POS]: REQ-003-minimize-workflow-artifacts T017 的 Red/Green 证据。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const { runBenchmarkArtifacts } = require('../../../scripts/benchmark-artifacts');
+
+const REPO_ROOT = path.resolve(__dirname, '../../..');
+const BENCHMARK_SCRIPT = path.join(REPO_ROOT, 'scripts', 'benchmark-artifacts.js');
+
+function writeText(filePath, text) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, text);
+}
+
+function writeJson(filePath, value) {
+  writeText(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function contractTasks({ changeKey, profile = 'standard', filler = '' }) {
+  return [
+    '# Tasks',
+    '',
+    '## Contract Summary',
+    '',
+    `Change: ${changeKey}`,
+    'Mode: plan',
+    `Profile: ${profile}`,
+    'Approval: approved',
+    '',
+    'Goal:',
+    '- Minimize workflow artifacts.',
+    '',
+    'Do Not Do:',
+    '- Do not change token estimator math.',
+    '',
+    'Approved Direction:',
+    '- Use tasks.md plus generated JSON records.',
+    '',
+    'Acceptance:',
+    '- Benchmark savings stay above threshold.',
+    '',
+    'Verification:',
+    '',
+    '```bash',
+    'npm run benchmark:artifacts',
+    '```',
+    '',
+    'Risk / Escalate If:',
+    '- Savings fall below profile threshold.',
+    '',
+    filler,
+    '## Phase 1',
+    '',
+    '- [ ] T001 benchmark minimized artifact surface',
+    '  Vertical slice: Slice 1',
+    ''
+  ].join('\n');
+}
+
+function seedLegacyBaseline(repoRoot, changeKey, size = 6000) {
+  const changeDir = path.join(repoRoot, 'devflow', 'changes', changeKey);
+  writeText(path.join(changeDir, 'planning', 'design.md'), `# Design\n\n${'d'.repeat(size)}\n`);
+  writeText(path.join(changeDir, 'planning', 'analysis.md'), `# Analysis\n\n${'a'.repeat(size / 2)}\n`);
+  writeText(path.join(changeDir, 'planning', 'tasks.md'), `# Tasks\n\n${'t'.repeat(size / 2)}\n`);
+  writeJson(path.join(changeDir, 'planning', 'task-manifest.json'), { changeId: changeKey, tasks: [] });
+  writeJson(path.join(changeDir, 'change-meta.json'), { changeId: changeKey, goal: ['legacy'] });
+  writeJson(path.join(changeDir, 'review', 'report-card.json'), { overall: 'pass' });
+}
+
+function seedMinimizedChange(repoRoot, changeKey, options = {}) {
+  const changeDir = path.join(repoRoot, 'devflow', 'changes', changeKey);
+  writeText(path.join(changeDir, 'planning', 'tasks.md'), contractTasks({ changeKey, ...options }));
+  writeJson(path.join(changeDir, 'planning', 'task-manifest.json'), {
+    changeId: changeKey,
+    metadata: { source: 'tasks.md', generatedBy: 'cc-devflow task-contract', planVersion: 1 },
+    tasks: []
+  });
+  writeJson(path.join(changeDir, 'change-meta.json'), {
+    changeId: changeKey,
+    _meta: { generatedBy: 'cc-devflow task-contract' }
+  });
+  writeJson(path.join(changeDir, 'review', 'review-ledger.jsonl'), { note: 'counted as text by benchmark' });
+  writeJson(path.join(changeDir, 'review', 'review-findings.json'), { findings: [] });
+  writeJson(path.join(changeDir, 'review', 'report-card.json'), { overall: 'pass' });
+}
+
+describe('benchmark:artifacts', () => {
+  let repoRoot;
+
+  beforeEach(() => {
+    repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-benchmark-artifacts-'));
+    seedLegacyBaseline(repoRoot, 'REQ-001-legacy-baseline');
+    seedLegacyBaseline(repoRoot, 'REQ-002-legacy-baseline');
+  });
+
+  afterEach(() => {
+    fs.rmSync(repoRoot, { recursive: true, force: true });
+  });
+
+  test('reports standard savings >= 30% for REQ-003-example', () => {
+    seedMinimizedChange(repoRoot, 'REQ-003-example', { profile: 'standard' });
+
+    const result = runBenchmarkArtifacts(repoRoot);
+    const row = result.rows.find((item) => item.changeKey === 'REQ-003-example');
+
+    expect(result.code).toBe(0);
+    expect(row).toMatchObject({
+      profile: 'standard',
+      threshold_pct: 30,
+      correctness_pass: true
+    });
+    expect(row.savings_vs_baseline_pct).toBeGreaterThanOrEqual(30);
+  });
+
+  test('reports tiny savings >= 60% for tiny fixture', () => {
+    seedMinimizedChange(repoRoot, 'REQ-004-tiny-example', { profile: 'tiny' });
+
+    const result = runBenchmarkArtifacts(repoRoot);
+    const row = result.rows.find((item) => item.changeKey === 'REQ-004-tiny-example');
+
+    expect(result.code).toBe(0);
+    expect(row).toMatchObject({
+      profile: 'tiny',
+      threshold_pct: 60,
+      correctness_pass: true
+    });
+    expect(row.savings_vs_baseline_pct).toBeGreaterThanOrEqual(60);
+  });
+
+  test('exits 1 when savings are below the profile threshold', () => {
+    seedMinimizedChange(repoRoot, 'REQ-005-bloated-example', {
+      profile: 'standard',
+      filler: 'x'.repeat(20000)
+    });
+
+    const result = runBenchmarkArtifacts(repoRoot);
+
+    expect(result.code).toBe(1);
+    expect(result.rows[0]).toMatchObject({ correctness_pass: false });
+  });
+
+  test('CLI prints stdout JSON array', () => {
+    seedMinimizedChange(repoRoot, 'REQ-003-example', { profile: 'standard' });
+
+    const result = spawnSync(process.execPath, [BENCHMARK_SCRIPT, repoRoot], { encoding: 'utf8' });
+    const rows = JSON.parse(result.stdout);
+
+    expect(result.status).toBe(0);
+    expect(Array.isArray(rows)).toBe(true);
+    expect(rows[0]).toHaveProperty('savings_vs_baseline_pct');
+  });
+
+  test('package.json exposes npm run benchmark:artifacts', () => {
+    const pkg = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8'));
+    expect(pkg.scripts['benchmark:artifacts']).toBe('node scripts/benchmark-artifacts.js');
+  });
+});

package/lib/skill-runtime/__tests__/cli-bootstrap.integration.test.js

@@ -217,9 +217,9 @@ describe('cc-devflow cli distribution bootstrap', () => {
     expect(codexDoSkill.data.writes).toEqual(
       expect.arrayContaining([
         expect.objectContaining({
-          path: 'devflow/changes/<change-key>/execution/tasks/<task-id>/checkpoint.json',
+          path: 'devflow/changes/<change-key>/execution/tasks/<task-id>/events.jsonl',
           durability: 'durable',
-          required: true
+          required: false
         })
       ])
     );

package/lib/skill-runtime/__tests__/dispatch.test.js

@@ -7,7 +7,6 @@ const { runResume } = require('../operations/resume');
 const {
   getRuntimeStatePath,
   getTaskManifestPath,
-  getCheckpointPath,
   getEventsPath
 } = require('../store');
 
@@ -76,7 +75,7 @@ describe('runDispatch', () => {
     expect(nextManifest.tasks[0].status).toBe('pending');
   });
 
-  test('rejects stale results when planVersion changes during task execution and records it in checkpoint', async () => {
+  test('rejects stale results when planVersion changes during task execution and records it in manifest and events', async () => {
     const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-dispatch-'));
     const manifestPath = getTaskManifestPath(repoRoot, 'REQ-123');
 
@@ -133,28 +132,25 @@ describe('runDispatch', () => {
     });
 
     const nextManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-    const checkpoint = JSON.parse(fs.readFileSync(getCheckpointPath(repoRoot, 'REQ-123', 'T001'), 'utf8'));
     const events = fs.readFileSync(getEventsPath(repoRoot, 'REQ-123', 'T001'), 'utf8');
 
     expect(result.success).toBe(false);
     expect(nextManifest.tasks[0].status).toBe('failed');
     expect(nextManifest.tasks[0].lastError).toContain('Stale result rejected');
-    expect(checkpoint.planVersion).toBe(1);
-    expect(checkpoint.error).toContain('Stale result rejected');
     expect(events).toContain('task_stale_rejected');
   });
 
-  test('restores unresolved work from the latest stable checkpoint on resume without creating handoff markdown', async () => {
+  test('restores unresolved work from the latest stable manifest state on resume without creating handoff markdown', async () => {
     const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-resume-stable-'));
     const changeId = 'REQ-123';
     const manifestPath = getTaskManifestPath(repoRoot, changeId);
 
     writeJson(getRuntimeStatePath(repoRoot, changeId), {
       changeId,
-      changeKey: 'REQ-123-recover-from-stable-checkpoint',
-      slug: 'recover-from-stable-checkpoint',
+      changeKey: 'REQ-123-recover-from-stable-state',
+      slug: 'recover-from-stable-state',
       createdAt: '2026-04-09T01:00:00.000Z',
-      goal: 'Recover from stable checkpoint',
+      goal: 'Recover from stable state',
       status: 'in_progress',
       initializedAt: '2026-04-09T01:00:00.000Z',
       plannedAt: '2026-04-09T01:01:00.000Z',
@@ -169,13 +165,13 @@ describe('runDispatch', () => {
 
     writeJson(manifestPath, {
       changeId,
-      goal: 'Recover from stable checkpoint',
+      goal: 'Recover from stable state',
       createdAt: '2026-04-09T01:00:00.000Z',
       updatedAt: '2026-04-09T01:02:00.000Z',
       tasks: [
         {
           id: 'T001',
-          title: 'Stable checkpoint task',
+          title: 'Stable completed task',
           type: 'TEST',
           dependsOn: [],
           touches: ['src/a.ts'],
@@ -219,32 +215,6 @@ describe('runDispatch', () => {
       }
     });
 
-    writeJson(getCheckpointPath(repoRoot, changeId, 'T001'), {
-      changeId,
-      taskId: 'T001',
-      sessionId: 'stable-session',
-      planVersion: 1,
-      status: 'passed',
-      summary: 'Task passed after 1 attempt(s)',
-      error: '',
-      outputExcerpt: '',
-      timestamp: '2026-04-09T01:05:00.000Z',
-      attempt: 1
-    });
-
-    writeJson(getCheckpointPath(repoRoot, changeId, 'T002'), {
-      changeId,
-      taskId: 'T002',
-      sessionId: 'failed-session',
-      planVersion: 1,
-      status: 'failed',
-      summary: 'Task failed: Command failed',
-      error: 'Command failed',
-      outputExcerpt: 'Command failed',
-      timestamp: '2026-04-09T01:06:00.000Z',
-      attempt: 2
-    });
-
     const result = await runResume({
       repoRoot,
       changeId,
@@ -255,7 +225,7 @@ describe('runDispatch', () => {
     const nextManifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
 
     expect(result.success).toBe(true);
-    expect(result.restoredCheckpoint).toMatchObject({
+    expect(result.restoredState).toMatchObject({
       taskId: 'T001',
       status: 'passed'
     });

package/lib/skill-runtime/__tests__/intent.test.js

@@ -15,8 +15,7 @@ const {
 const {
   getRuntimeStatePath,
   getTaskManifestPath,
-  getReportCardPath,
-  getCheckpointPath
+  getReportCardPath
 } = require('../store');
 
 function writeJson(filePath, value) {
@@ -86,21 +85,6 @@ describe('intent handoff bridge', () => {
       }
     );
 
-    writeJson(
-      getCheckpointPath(repoRoot, 'REQ-123', 'T001'),
-      {
-        changeId: 'REQ-123',
-        taskId: 'T001',
-        sessionId: 'T001-session',
-        planVersion: 1,
-        status: 'passed',
-        summary: 'Task passed after 1 attempt',
-        error: '',
-        outputExcerpt: 'worker-ok',
-        timestamp: '2026-03-25T01:11:00.000Z',
-        attempt: 1
-      }
-    );
   });
 
   test('syncIntentMemory removes legacy projection files instead of writing them', async () => {
@@ -152,7 +136,7 @@ describe('intent handoff bridge', () => {
     }
   });
 
-  test('writes pr brief from manifest, checkpoints, and report-card only', async () => {
+  test('writes pr brief from manifest task state and report-card only', async () => {
     const prBriefPath = getIntentPrBriefPath(repoRoot, 'REQ-123');
     const manifestPath = getTaskManifestPath(repoRoot, 'REQ-123');
     const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
@@ -208,8 +192,8 @@ describe('intent handoff bridge', () => {
 
     expect(prBrief).toContain('PR Brief: REQ-123');
     expect(prBrief).toContain('Suggested Title: feat(req-123): Deliver autopilot memory bridge');
-    expect(prBrief).toContain('execution/tasks/T001/checkpoint.json');
-    expect(prBrief).toContain('execution/tasks/T002/checkpoint.json');
+    expect(prBrief).toContain('planning/tasks.md');
+    expect(prBrief).toContain('planning/task-manifest.json');
     expect(prBrief).toContain('存在 1 个 skipped 任务，需要确认是否可接受：T002');
     expect(prBrief).not.toContain('result.md');
     for (const filePath of getIntentHandoffArtifactPaths(repoRoot, 'REQ-123')) {

package/lib/skill-runtime/__tests__/lifecycle.test.js

@@ -104,7 +104,7 @@ describe('lifecycle helpers', () => {
     };
 
     expect(deriveLifecycleNextAction({ state: approvedState, manifest, report: null })).toBe(
-      '优先修复失败任务 T002，然后从最近稳定 checkpoint 恢复。'
+      '优先修复失败任务 T002，然后从 task-manifest 的最近稳定状态恢复。'
     );
     expect(
       deriveLifecycleNextAction({

package/lib/skill-runtime/__tests__/paths.test.js

@@ -4,6 +4,7 @@ const path = require('path');
 
 const {
   buildChangeKey,
+  getChangeKeyPrefix,
   getChangePaths,
   getChangeSlug,
   nextChangeKey
@@ -17,11 +18,16 @@ describe('change directory naming', () => {
       .toBe('FIX-123-修复-目录-命名');
   });
 
+  test('derives the numeric prefix from full change keys', () => {
+    expect(getChangeKeyPrefix('REQ-123-plan-folder-contract')).toBe('REQ-123');
+    expect(getChangeKeyPrefix('FIX-456-crash-on-start')).toBe('FIX-456');
+  });
+
   test('rejects change ids and explicit keys outside the canonical prefix contract', () => {
     const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-paths-'));
 
     expect(() => buildChangeKey('BUG-123', { goal: 'legacy bug id' }))
-      .toThrow(/REQ-<number> or FIX-<number>/);
+      .toThrow(/REQ-<number>\[-description\] or FIX-<number>\[-description\]/);
     expect(() => getChangePaths(repoRoot, 'REQ-123', { changeKey: 'req-123-lowercase' }))
       .toThrow(/Expected REQ-123-<description>/);
 

package/lib/skill-runtime/__tests__/planner.tdd.test.js

@@ -107,6 +107,67 @@ describe('TDD Order Validation', () => {
   });
 
   describe('Manifest execution state', () => {
+    test('createTaskManifest reads tasks.md when legacy design.md is absent', async () => {
+      const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-planner-new-contract-'));
+      const changeId = 'REQ-322';
+      const changeKey = 'REQ-322-new-contract';
+      const tasksPath = path.join(repoRoot, 'devflow', 'changes', changeKey, 'planning', 'tasks.md');
+      fs.mkdirSync(path.dirname(tasksPath), { recursive: true });
+      fs.writeFileSync(
+        tasksPath,
+        [
+          '## Phase 1: Build',
+          '',
+          '- [ ] T001 [TEST] Counter behavior `src/counter.test.ts`',
+          '- [ ] T002 [IMPL] Counter behavior (dependsOn:T001) `src/counter.ts`'
+        ].join('\n')
+      );
+
+      const manifest = await createTaskManifest({
+        repoRoot,
+        changeId,
+        changeKey,
+        goal: 'Exercise new contract readFiles',
+        overwrite: true
+      });
+
+      expect(manifest.tasks[0].context.readFiles).toEqual(['tasks.md', 'src/counter.test.ts']);
+      expect(manifest.tasks[1].context.readFiles).toEqual(['tasks.md']);
+
+      fs.rmSync(repoRoot, { recursive: true, force: true });
+    });
+
+    test('createTaskManifest keeps design.md when legacy design.md exists', async () => {
+      const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-planner-legacy-contract-'));
+      const changeId = 'REQ-323';
+      const changeKey = 'REQ-323-legacy-contract';
+      const planningDir = path.join(repoRoot, 'devflow', 'changes', changeKey, 'planning');
+      fs.mkdirSync(planningDir, { recursive: true });
+      fs.writeFileSync(path.join(planningDir, 'design.md'), '# DESIGN\n');
+      fs.writeFileSync(
+        path.join(planningDir, 'tasks.md'),
+        [
+          '## Phase 1: Build',
+          '',
+          '- [ ] T001 [TEST] Counter behavior `src/counter.test.ts`',
+          '- [ ] T002 [IMPL] Counter behavior (dependsOn:T001) `src/counter.ts`'
+        ].join('\n')
+      );
+
+      const manifest = await createTaskManifest({
+        repoRoot,
+        changeId,
+        changeKey,
+        goal: 'Exercise legacy contract readFiles',
+        overwrite: true
+      });
+
+      expect(manifest.tasks[0].context.readFiles).toEqual(['design.md', 'tasks.md', 'src/counter.test.ts']);
+      expect(manifest.tasks[1].context.readFiles).toEqual(['design.md']);
+
+      fs.rmSync(repoRoot, { recursive: true, force: true });
+    });
+
     test('should derive active phase and current task from ready tasks', () => {
       const state = deriveManifestExecutionState([
         { id: 'T001', phase: 1, status: 'passed', dependsOn: [] },

package/lib/skill-runtime/__tests__/prepare-pr.test.js

@@ -6,8 +6,7 @@ const { runPreparePr } = require('../operations/prepare-pr');
 const {
   getRuntimeStatePath,
   getTaskManifestPath,
-  getReportCardPath,
-  getCheckpointPath
+  getReportCardPath
 } = require('../store');
 const {
   getIntentPrBriefPath,
@@ -94,19 +93,6 @@ describe('runPreparePr', () => {
       timestamp: '2026-03-25T01:11:00.000Z'
     });
 
-    writeJson(getCheckpointPath(repoRoot, 'REQ-123', 'T001'), {
-      changeId: 'REQ-123',
-      taskId: 'T001',
-      sessionId: 'task-session',
-      planVersion: 1,
-      status: 'passed',
-      summary: 'Task passed after 1 attempt',
-      error: '',
-      outputExcerpt: 'ok',
-      timestamp: '2026-03-25T01:09:00.000Z',
-      attempt: 1
-    });
-
     writeJson(getRuntimeStatePath(repoRoot, 'REQ-123'), {
       ...JSON.parse(fs.readFileSync(getRuntimeStatePath(repoRoot, 'REQ-123'), 'utf8')),
       approval: {
@@ -130,7 +116,8 @@ describe('runPreparePr', () => {
     expect(result.status).toBe('prepared');
     expect(result.suggestedTitle).toBe('feat(req-123): Prepare a PR-ready brief');
     expect(prBrief).toContain('PR Brief: REQ-123');
-    expect(prBrief).toContain('execution/tasks/T001/checkpoint.json');
+    expect(prBrief).toContain('planning/task-manifest.json');
+    expect(prBrief).not.toContain('execution/tasks/T001/checkpoint.json');
     expect(prBrief).not.toContain('result.md');
     for (const filePath of getIntentHandoffArtifactPaths(repoRoot, 'REQ-123')) {
       expect(fs.existsSync(filePath)).toBe(filePath === prBriefPath);