cc-devflow 4.5.10 → 4.5.12

package/lib/skill-runtime/__tests__/team-state.test.js

@@ -1,51 +0,0 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const {
-  getTeamStatePath,
-  readTeamState,
-  writeTeamState
-} = require('../team-state');
-
-describe('team-state', () => {
-  test('writes and reads the canonical truth state', async () => {
-    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-team-state-'));
-    fs.writeFileSync(path.join(repoRoot, 'package.json'), JSON.stringify({ name: 'team-state-smoke', version: '1.0.0' }, null, 2));
-
-    await writeTeamState(repoRoot, 'REQ-123', {
-      status: 'delegated',
-      phase: 'delegate',
-      branch: 'main',
-      planVersion: 4,
-      team: {
-        mode: 'parallel',
-        lead: 'main-agent',
-        teammates: [
-          {
-            id: 'delegate-01',
-            role: 'dev-implementer',
-            status: 'idle',
-            currentTask: null,
-            completedTasks: [],
-            lastActiveAt: '2026-03-26T00:00:00.000Z'
-          }
-        ],
-        taskAssignments: {
-          T001: 'delegate-01'
-        },
-        createdAt: '2026-03-26T00:00:00.000Z',
-        updatedAt: '2026-03-26T00:00:00.000Z'
-      }
-    });
-
-    const truth = JSON.parse(fs.readFileSync(getTeamStatePath(repoRoot, 'REQ-123'), 'utf8'));
-    const state = await readTeamState(repoRoot, 'REQ-123');
-
-    expect(truth.changeId).toBe('REQ-123');
-    expect(truth.team.taskAssignments.T001).toBe('delegate-01');
-    expect(state.changeId).toBe('REQ-123');
-    expect(state.planVersion).toBe(4);
-    expect(state.phase).toBe('delegate');
-  });
-});

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

@@ -1,203 +0,0 @@
-/**
- * [INPUT]: 依赖 scripts/verify-artifacts.js 导出的 runVerifyArtifacts 和临时 change fixture。
- * [OUTPUT]: 验证 verify:artifacts 只实现 C1-C10，返回稳定 exit code 和 JSON 报告。
- * [POS]: REQ-003-minimize-workflow-artifacts T016 的 Red/Green 证据。
- * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
- */
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const { spawnSync } = require('child_process');
-
-const { runVerifyArtifacts } = require('../../../scripts/verify-artifacts');
-
-const REPO_ROOT = path.resolve(__dirname, '../../..');
-const VERIFY_SCRIPT = path.join(REPO_ROOT, 'scripts', 'verify-artifacts.js');
-
-function writeJson(filePath, value) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
-}
-
-function tasksMarkdown({ profile = 'standard', taskCount = 1, extraBody = '' } = {}) {
-  const contract = [
-    '# Tasks',
-    '',
-    '## Contract Summary',
-    '',
-    'Change: REQ-900-valid-artifacts',
-    'Mode: plan',
-    `Profile: ${profile}`,
-    'Approval: approved',
-    '',
-    'Goal:',
-    '- Keep artifact verification deterministic.',
-    '',
-    'Do Not Do:',
-    '- Do not add checks outside C1-C10.',
-    '',
-    'Approved Direction:',
-    '- Verify the minimized artifact shape.',
-    '',
-    'Acceptance:',
-    '- The verifier returns stable rule ids and exit codes.',
-    '',
-    'Verification:',
-    '',
-    '```bash',
-    'npm run verify:artifacts',
-    '```',
-    '',
-    'Risk / Escalate If:',
-    '- The rule table drifts from C1-C10.',
-    ''
-  ];
-  const tasks = Array.from({ length: taskCount }, (_, index) => [
-    `- [ ] T${String(index + 1).padStart(3, '0')} validate artifacts`,
-    '  Goal: Exercise one verifier rule.',
-    '  Files: `scripts/verify-artifacts.js`',
-    '  Verification: npm run verify:artifacts',
-    `  Vertical slice: Slice ${index + 1}`,
-    ''
-  ].join('\n'));
-  return [...contract, extraBody, '## Phase 1', '', ...tasks].join('\n');
-}
-
-function seedValidChange(repoRoot, options = {}) {
-  const changeKey = options.changeKey || 'REQ-900-valid-artifacts';
-  const changeDir = path.join(repoRoot, 'devflow', 'changes', changeKey);
-  const planningDir = path.join(changeDir, 'planning');
-  fs.mkdirSync(planningDir, { recursive: true });
-  fs.writeFileSync(path.join(planningDir, 'tasks.md'), tasksMarkdown(options));
-  writeJson(path.join(planningDir, 'task-manifest.json'), {
-    changeId: changeKey,
-    createdAt: '2026-05-12T00:00:00.000Z',
-    updatedAt: '2026-05-12T00:00:00.000Z',
-    currentTaskId: null,
-    tasks: [],
-    metadata: {
-      source: 'tasks.md',
-      generatedBy: 'cc-devflow task-contract',
-      planVersion: 1
-    }
-  });
-  writeJson(path.join(changeDir, 'change-meta.json'), {
-    changeId: changeKey,
-    requirementId: changeKey,
-    goal: ['Verify artifacts'],
-    acceptance: ['Verifier passes'],
-    specReference: {
-      source: 'planning/tasks.md#contract-summary',
-      change: changeKey,
-      mode: 'plan',
-      profile: options.profile || 'standard',
-      approval: 'approved'
-    },
-    _meta: {
-      generatedBy: 'cc-devflow task-contract',
-      generatedAt: '2026-05-12T00:00:00.000Z'
-    }
-  });
-  return { changeDir, planningDir, changeKey };
-}
-
-describe('verify:artifacts', () => {
-  let repoRoot;
-
-  beforeEach(() => {
-    repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-verify-artifacts-'));
-    writeJson(path.join(repoRoot, 'package.json'), {
-      name: 'verify-artifacts-fixture',
-      version: '0.0.0',
-      scripts: {
-        'verify:artifacts': 'node scripts/verify-artifacts.js'
-      }
-    });
-  });
-
-  afterEach(() => {
-    fs.rmSync(repoRoot, { recursive: true, force: true });
-  });
-
-  const ruleCases = [
-    ['C1', 2, (ctx) => fs.writeFileSync(path.join(ctx.planningDir, 'design.md'), '# legacy design\n')],
-    ['C2', 2, (ctx) => fs.writeFileSync(path.join(ctx.planningDir, 'analysis.md'), '# legacy analysis\n')],
-    ['C3', 2, (ctx) => {
-      const reviewDir = path.join(ctx.changeDir, 'review');
-      fs.mkdirSync(reviewDir, { recursive: true });
-      fs.writeFileSync(path.join(reviewDir, 'cc-review-report.md'), '# legacy review\n');
-    }],
-    ['C4', 3, (ctx) => fs.writeFileSync(path.join(ctx.planningDir, 'tasks.md'), '# Tasks\n\n- [ ] T001 no contract\n')],
-    ['C5', 3, (ctx) => writeJson(path.join(ctx.planningDir, 'task-manifest.json'), {
-      changeId: ctx.changeKey,
-      createdAt: '2026-05-12T00:00:00.000Z',
-      updatedAt: '2026-05-12T00:00:00.000Z',
-      currentTaskId: null,
-      tasks: [],
-      metadata: { source: 'tasks.md', generatedBy: 'manual', planVersion: 1 }
-    })],
-    ['C6', 3, (ctx) => writeJson(path.join(ctx.changeDir, 'change-meta.json'), {
-      _meta: { generatedBy: 'manual' }
-    })],
-    ['C7', 4, (ctx) => fs.writeFileSync(path.join(ctx.planningDir, 'tasks.md'), tasksMarkdown({
-      profile: 'tiny',
-      taskCount: 2
-    }))],
-    ['C8', 5, (ctx) => {
-      const reviewDir = path.join(ctx.changeDir, 'review');
-      fs.mkdirSync(reviewDir, { recursive: true });
-      fs.writeFileSync(path.join(reviewDir, 'review-ledger.jsonl'), '{"event":"review-started"}\n');
-    }],
-    ['C9', 5, (ctx) => {
-      const reviewDir = path.join(ctx.changeDir, 'review');
-      fs.mkdirSync(reviewDir, { recursive: true });
-      fs.writeFileSync(path.join(reviewDir, 'report-card.json'), '{"overall":"pass"}\n');
-    }],
-    ['C10', 6, (ctx) => fs.writeFileSync(path.join(ctx.planningDir, 'tasks.md'), tasksMarkdown({
-      profile: 'standard',
-      extraBody: 'x'.repeat(12000)
-    }))]
-  ];
-
-  test.each(ruleCases)('%s returns exit code %i with JSON report', async (ruleId, exitCode, mutate) => {
-    const ctx = seedValidChange(repoRoot, { changeKey: `REQ-9${ruleId.slice(1).padStart(2, '0')}-${ruleId.toLowerCase()}` });
-    mutate(ctx);
-
-    const result = await runVerifyArtifacts(repoRoot);
-
-    expect(result.code).toBe(exitCode);
-    expect(result.violations[0]).toMatchObject({ ruleId, exitCode });
-    expect(result.checks).toHaveLength(10);
-  });
-
-  test('passes a valid generated change and skips grandfathered legacy directories', async () => {
-    seedValidChange(repoRoot);
-    const legacy = seedValidChange(repoRoot, { changeKey: 'REQ-001-legacy-fallback' });
-    fs.writeFileSync(path.join(legacy.planningDir, 'design.md'), '# grandfathered design\n');
-    const manifest = JSON.parse(fs.readFileSync(path.join(legacy.planningDir, 'task-manifest.json'), 'utf8'));
-    manifest.metadata.generatedBy = 'skill:cc-plan';
-    fs.writeFileSync(path.join(legacy.planningDir, 'task-manifest.json'), `${JSON.stringify(manifest, null, 2)}\n`);
-
-    const result = await runVerifyArtifacts(repoRoot);
-
-    expect(result).toMatchObject({ code: 0, ok: true });
-    expect(result.skippedLegacy.map((item) => item.changeKey)).toContain('REQ-001-legacy-fallback');
-  });
-
-  test('CLI prints stdout JSON and exits with the first violation code', () => {
-    const ctx = seedValidChange(repoRoot);
-    fs.writeFileSync(path.join(ctx.planningDir, 'design.md'), '# rogue design\n');
-
-    const result = spawnSync(process.execPath, [VERIFY_SCRIPT, repoRoot], { encoding: 'utf8' });
-    const report = JSON.parse(result.stdout);
-
-    expect(result.status).toBe(2);
-    expect(report.violations[0].ruleId).toBe('C1');
-  });
-
-  test('package.json exposes npm run verify:artifacts', () => {
-    const pkg = JSON.parse(fs.readFileSync(path.join(REPO_ROOT, 'package.json'), 'utf8'));
-    expect(pkg.scripts['verify:artifacts']).toBe('node scripts/verify-artifacts.js');
-  });
-});

package/lib/skill-runtime/__tests__/worker-run.test.js

@@ -1,275 +0,0 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const { syncDelegationRuntime, buildWorkerHandoff, getMessageBusPath, getWorkerAssignmentPath } = require('../delegation');
-const {
-  buildProviderPrompt,
-  buildProviderCommand,
-  runWorkerCommand
-} = require('../operations/worker-run');
-const {
-  getRuntimeStatePath,
-  getTaskManifestPath,
-  getEventsPath
-} = require('../store');
-
-function writeJson(filePath, value) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
-}
-
-function createManifest() {
-  return {
-    changeId: 'REQ-123',
-    goal: 'Run delegated worker command',
-    createdAt: '2026-03-25T01:00:00.000Z',
-    updatedAt: '2026-03-25T01:01:00.000Z',
-    tasks: [
-      {
-        id: 'T002',
-        title: 'Delegated task',
-        type: 'IMPL',
-        dependsOn: [],
-        touches: ['src/a.ts', 'src/b.ts'],
-        run: ['echo delegated'],
-        checks: [],
-        status: 'pending',
-        attempts: 0,
-        maxRetries: 1
-      }
-    ],
-    metadata: {
-      source: 'default',
-      generatedBy: 'test',
-      planVersion: 2
-    }
-  };
-}
-
-function createSharedWorkerManifest() {
-  return {
-    changeId: 'REQ-123',
-    goal: 'Run delegated worker command',
-    createdAt: '2026-03-25T01:00:00.000Z',
-    updatedAt: '2026-03-25T01:01:00.000Z',
-    tasks: [
-      {
-        id: 'T002',
-        title: 'Delegated task one',
-        type: 'IMPL',
-        dependsOn: [],
-        touches: ['src/a.ts', 'src/b.ts'],
-        run: ['echo delegated-one'],
-        checks: [],
-        status: 'pending',
-        attempts: 0,
-        maxRetries: 1
-      },
-      {
-        id: 'T003',
-        title: 'Delegated task two',
-        type: 'IMPL',
-        dependsOn: [],
-        touches: ['src/a.ts', 'src/b.ts'],
-        run: ['echo delegated-two'],
-        checks: [],
-        status: 'pending',
-        attempts: 0,
-        maxRetries: 1
-      }
-    ],
-    metadata: {
-      source: 'default',
-      generatedBy: 'test',
-      planVersion: 2
-    }
-  };
-}
-
-function setupRepoRoot(prefix) {
-  const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  fs.writeFileSync(
-    path.join(repoRoot, 'package.json'),
-    JSON.stringify({ name: 'worker-run-test', version: '1.0.0' }, null, 2)
-  );
-  writeJson(getRuntimeStatePath(repoRoot, 'REQ-123'), {
-    changeId: 'REQ-123',
-    changeKey: 'REQ-123-run-delegated-worker-command',
-    slug: 'run-delegated-worker-command',
-    createdAt: '2026-03-25T01:00:00.000Z',
-    goal: 'Run delegated worker command',
-    status: 'planned',
-    initializedAt: '2026-03-25T01:00:00.000Z',
-    plannedAt: '2026-03-25T01:01:00.000Z',
-    updatedAt: '2026-03-25T01:01:00.000Z'
-  });
-  return repoRoot;
-}
-
-function writeManifest(repoRoot, manifest) {
-  writeJson(getTaskManifestPath(repoRoot, manifest.changeId), manifest);
-}
-
-describe('runWorkerCommand', () => {
-  test('builds thin provider launch commands for codex and claude', () => {
-    const codexCommand = buildProviderCommand({
-      provider: 'codex',
-      providerPromptPath: '/tmp/provider.md',
-      providerLastMessagePath: '/tmp/last-message.md',
-      providerTranscriptPath: '/tmp/transcript.jsonl',
-      workspace: '/tmp/worktree',
-      providerArgs: '--model gpt-5'
-    });
-    const claudeCommand = buildProviderCommand({
-      provider: 'claude',
-      providerPromptPath: '/tmp/provider.md',
-      providerLastMessagePath: '/tmp/last-message.md',
-      providerTranscriptPath: '/tmp/transcript.jsonl',
-      workspace: '/tmp/worktree',
-      providerArgs: '--model sonnet --permission-mode bypassPermissions'
-    });
-
-    expect(codexCommand).toContain('codex exec');
-    expect(codexCommand).toContain('--dangerously-bypass-approvals-and-sandbox');
-    expect(codexCommand).toContain('/tmp/transcript.jsonl');
-    expect(claudeCommand).toContain('claude -p');
-    expect(claudeCommand).toContain('--dangerously-skip-permissions');
-  });
-
-  test('runs local worker command and records only task status truth by default', async () => {
-    const repoRoot = setupRepoRoot('cc-devflow-worker-run-pass-');
-    const manifest = createManifest();
-    writeManifest(repoRoot, manifest);
-    const delegation = await syncDelegationRuntime(repoRoot, 'REQ-123', manifest);
-    const workerId = delegation.assignments.find((item) => item.taskId === 'T002').workerId;
-
-    const result = await runWorkerCommand({
-      repoRoot,
-      changeId: 'REQ-123',
-      workerId,
-      command: 'printf "worker-ok"'
-    });
-
-    const state = fs.readFileSync(result.sessionLogPath.replace('session.log', 'state.md'), 'utf8');
-    const journal = fs.readFileSync(result.sessionLogPath.replace('session.log', 'journal.md'), 'utf8');
-    const log = fs.readFileSync(result.sessionLogPath, 'utf8');
-    const bus = fs.readFileSync(getMessageBusPath(repoRoot, 'REQ-123'), 'utf8');
-    const assignment = fs.readFileSync(getWorkerAssignmentPath(repoRoot, 'REQ-123', workerId), 'utf8');
-    const nextManifest = JSON.parse(fs.readFileSync(getTaskManifestPath(repoRoot, 'REQ-123'), 'utf8'));
-    const runtimeState = JSON.parse(fs.readFileSync(getRuntimeStatePath(repoRoot, 'REQ-123'), 'utf8'));
-
-    expect(result.status).toBe('completed');
-    expect(state).toContain('Status: `completed`');
-    expect(journal).toContain('completed (exit 0)');
-    expect(log).toContain('worker-ok');
-    expect(bus).toContain(`${workerId} completed T002`);
-    expect(assignment).toContain('`T002` status=`completed`');
-    expect(fs.existsSync(getEventsPath(repoRoot, 'REQ-123', 'T002'))).toBe(false);
-    expect(fs.existsSync(path.join(repoRoot, 'devflow/changes/REQ-123-run-delegated-worker-command/execution/workers'))).toBe(false);
-    expect(nextManifest.tasks[0].status).toBe('passed');
-    expect(runtimeState.status).toBe('in_progress');
-  });
-
-  test('builds provider prompt from assignment plus live manifest task brief', async () => {
-    const repoRoot = setupRepoRoot('cc-devflow-worker-run-provider-');
-    const manifest = createManifest();
-    writeManifest(repoRoot, manifest);
-    const delegation = await syncDelegationRuntime(repoRoot, 'REQ-123', manifest);
-    const workerId = delegation.assignments.find((item) => item.taskId === 'T002').workerId;
-    const handoff = await buildWorkerHandoff(repoRoot, 'REQ-123', workerId);
-
-    const providerPrompt = await buildProviderPrompt(repoRoot, handoff, 'T002');
-
-    expect(providerPrompt).toContain('## Worker Assignment');
-    expect(providerPrompt).toContain('## Selected Task Brief');
-    expect(providerPrompt).toContain('Task: `T002`');
-    expect(providerPrompt).toContain('Delegated task');
-  });
-
-  test('writes failure events and manifest error when local command exits non-zero', async () => {
-    const repoRoot = setupRepoRoot('cc-devflow-worker-run-fail-');
-    const manifest = createManifest();
-    writeManifest(repoRoot, manifest);
-    const delegation = await syncDelegationRuntime(repoRoot, 'REQ-123', manifest);
-    const workerId = delegation.assignments.find((item) => item.taskId === 'T002').workerId;
-
-    const result = await runWorkerCommand({
-      repoRoot,
-      changeId: 'REQ-123',
-      workerId,
-      command: 'echo boom >&2 && exit 7'
-    });
-
-    const state = fs.readFileSync(result.sessionLogPath.replace('session.log', 'state.md'), 'utf8');
-    const log = fs.readFileSync(result.sessionLogPath, 'utf8');
-    const assignment = fs.readFileSync(getWorkerAssignmentPath(repoRoot, 'REQ-123', workerId), 'utf8');
-    const failedManifest = JSON.parse(fs.readFileSync(getTaskManifestPath(repoRoot, 'REQ-123'), 'utf8'));
-    const events = fs.readFileSync(getEventsPath(repoRoot, 'REQ-123', 'T002'), 'utf8');
-
-    expect(result.status).toBe('failed');
-    expect(result.result.code).toBe(7);
-    expect(state).toContain('Status: `failed`');
-    expect(log).toContain('boom');
-    expect(assignment).toContain('`T002` status=`failed`');
-    expect(events).toContain('worker_run_failed');
-    expect(failedManifest.tasks[0].status).toBe('failed');
-    expect(failedManifest.tasks[0].lastError).toContain('boom');
-  });
-
-  test('updates only the selected task when a worker owns multiple assignments', async () => {
-    const repoRoot = setupRepoRoot('cc-devflow-worker-run-multi-');
-    const manifest = createSharedWorkerManifest();
-    writeManifest(repoRoot, manifest);
-    const delegation = await syncDelegationRuntime(repoRoot, 'REQ-123', manifest);
-    const workerId = delegation.assignments.find((item) => item.taskId === 'T002').workerId;
-
-    expect(delegation.assignments.find((item) => item.taskId === 'T003').workerId).toBe(workerId);
-
-    const result = await runWorkerCommand({
-      repoRoot,
-      changeId: 'REQ-123',
-      workerId,
-      taskId: 'T003',
-      command: 'printf "worker-t003"'
-    });
-
-    const assignment = fs.readFileSync(getWorkerAssignmentPath(repoRoot, 'REQ-123', workerId), 'utf8');
-
-    expect(result.taskId).toBe('T003');
-    expect(assignment).toContain('`T003` status=`completed`');
-    expect(assignment).not.toContain('`T002` status=`completed`');
-    const nextManifest = JSON.parse(fs.readFileSync(getTaskManifestPath(repoRoot, 'REQ-123'), 'utf8'));
-    expect(nextManifest.tasks.find((task) => task.id === 'T002').status).toBe('pending');
-    expect(nextManifest.tasks.find((task) => task.id === 'T003').status).toBe('passed');
-  });
-
-  test('blocks stale worker assignments when manifest planVersion has moved on', async () => {
-    const repoRoot = setupRepoRoot('cc-devflow-worker-run-stale-plan-');
-    const manifest = createManifest();
-    writeManifest(repoRoot, manifest);
-    const delegation = await syncDelegationRuntime(repoRoot, 'REQ-123', manifest);
-    const workerId = delegation.assignments.find((item) => item.taskId === 'T002').workerId;
-
-    writeManifest(repoRoot, {
-      ...manifest,
-      metadata: {
-        ...manifest.metadata,
-        planVersion: 3
-      }
-    });
-
-    await expect(runWorkerCommand({
-      repoRoot,
-      changeId: 'REQ-123',
-      workerId,
-      command: 'printf "should-not-run" > blocked.txt'
-    })).rejects.toMatchObject({
-      name: 'StalePlanVersionError',
-      rescueAction: 'rerun delegation sync for current planVersion before worker-run'
-    });
-
-    expect(fs.existsSync(path.join(repoRoot, 'blocked.txt'))).toBe(false);
-    expect(fs.existsSync(getEventsPath(repoRoot, 'REQ-123', 'T002'))).toBe(false);
-  });
-});

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

@@ -1,56 +0,0 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const { syncDelegationRuntime } = require('../delegation');
-const { runWorkerSession } = require('../operations/worker');
-
-describe('runWorkerSession', () => {
-  test('returns stable handoff bundle for a delegated worker', async () => {
-    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-worker-session-'));
-    fs.writeFileSync(path.join(repoRoot, 'package.json'), JSON.stringify({ name: 'worker-session', version: '1.0.0' }, null, 2));
-
-    const manifest = {
-      changeId: 'REQ-123',
-      goal: 'Prepare worker session',
-      createdAt: '2026-03-25T01:00:00.000Z',
-      updatedAt: '2026-03-25T01:01:00.000Z',
-      tasks: [
-        {
-          id: 'T002',
-          title: 'Multi file delegated task',
-          type: 'IMPL',
-          dependsOn: [],
-          touches: ['src/a.ts', 'src/b.ts'],
-          run: ['echo delegated'],
-          checks: [],
-          status: 'pending',
-          attempts: 0,
-          maxRetries: 1
-        }
-      ],
-      metadata: {
-        source: 'default',
-        generatedBy: 'test',
-        planVersion: 2
-      }
-    };
-
-    const delegation = await syncDelegationRuntime(repoRoot, 'REQ-123', manifest);
-    const workerId = delegation.assignments.find((item) => item.taskId === 'T002').workerId;
-    const handoff = await runWorkerSession({
-      repoRoot,
-      changeId: 'REQ-123',
-      workerId
-    });
-
-    const journal = fs.readFileSync(handoff.journalPath, 'utf8');
-    const state = fs.readFileSync(handoff.statePath, 'utf8');
-
-    expect(handoff.workerId).toBe(workerId);
-    expect(handoff.assignmentPath).toContain('assignment.md');
-    expect(handoff.taskIds).toEqual(['T002']);
-    expect(journal).toContain('handoff prepared');
-    expect(state).toContain('Status: `handoff_ready`');
-  });
-});

package/lib/skill-runtime/__tests__/workflow-context-legacy-fallback.test.js

@@ -1,31 +0,0 @@
-/**
- * [INPUT]: 依赖 getWorkflowContext 查询 seam、仓库内真实 legacy workflow artifacts。
- * [OUTPUT]: 验证 legacy design.md fallback 在 compact context 中仍是一等合同入口。
- * [POS]: REQ-003-minimize-workflow-artifacts T010 的 Red/Green 证据。
- * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
- */
-
-const path = require('path');
-
-const { getWorkflowContext } = require('../query');
-
-const repoRoot = path.resolve(__dirname, '../../..');
-
-describe('workflow-context legacy fallback refs', () => {
-  test.each([
-    ['REQ-002', 'REQ-002-unified-roadmap-truth']
-  ])('%s keeps design.md as the first fallback contract ref', async (changeId, changeKey) => {
-    const context = await getWorkflowContext(repoRoot, changeId, { changeKey });
-    const designRef = `devflow/changes/${changeKey}/planning/design.md#approved-direction`;
-
-    expect(context.legacyFallback).toBe(true);
-    expect(context.source.contract.path).toBe(`devflow/changes/${changeKey}/planning/design.md`);
-    expect(context.progressiveDisclosure.defaultOpen[0]).toEqual(expect.objectContaining({
-      ref: designRef,
-      reason: 'primary task contract',
-      exists: true
-    }));
-    expect(context.progressiveDisclosure.defaultOpen.every((entry) => entry.exists === true))
-      .toBe(true);
-  });
-});