cc-devflow 4.5.4 → 4.5.6

package/lib/compiler/__tests__/skills-registry.test.js

@@ -195,7 +195,7 @@ describe('Skills Registry Generator', () => {
       );
     });
 
-    test('should publish roadmap outputs under devflow', async () => {
+    test('should publish unified roadmap state outputs under devflow', async () => {
       const { generateSkillsRegistryV2 } = require('../skills-registry');
 
       const result = await generateSkillsRegistryV2('.claude/skills');
@@ -204,14 +204,28 @@ describe('Skills Registry Generator', () => {
       expect(roadmap).toBeDefined();
       expect(roadmap.writes).toEqual(
         expect.arrayContaining([
-          expect.objectContaining({ path: 'devflow/ROADMAP.md' }),
-          expect.objectContaining({ path: 'devflow/BACKLOG.md' })
+          expect.objectContaining({
+            path: 'devflow/roadmap.json',
+            durability: 'durable',
+            required: true
+          }),
+          expect.objectContaining({
+            path: 'devflow/ROADMAP.md',
+            durability: 'durable',
+            required: true
+          }),
+          expect.objectContaining({
+            path: 'devflow/BACKLOG.md',
+            durability: 'durable',
+            required: false
+          })
         ])
       );
       expect(roadmap.writes).not.toEqual(
         expect.arrayContaining([
           expect.objectContaining({ path: 'ROADMAP.md' }),
           expect.objectContaining({ path: 'BACKLOG.md' }),
+          expect.objectContaining({ path: 'devflow/roadmap-tracking.json', required: true }),
           expect.objectContaining({ path: 'devflow/roadmap/roadmap.md' }),
           expect.objectContaining({ path: 'devflow/roadmap/backlog.md' })
         ])

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

@@ -55,9 +55,10 @@ describe('runAutopilot', () => {
       }
     });
 
-    fs.mkdirSync(path.dirname(getTasksMarkdownPath(repoRoot, 'REQ-123')), { recursive: true });
+    const goal = 'Ship thin autopilot loop';
+    fs.mkdirSync(path.dirname(getTasksMarkdownPath(repoRoot, 'REQ-123', { goal })), { recursive: true });
     fs.writeFileSync(
-      getTasksMarkdownPath(repoRoot, 'REQ-123'),
+      getTasksMarkdownPath(repoRoot, 'REQ-123', { goal }),
       [
         '- [ ] T001 启动 autopilot 闭环 (src/a.ts)',
         '- [ ] T002 多文件委派任务 [P] (src/a.ts,src/b.ts)'
@@ -67,14 +68,14 @@ describe('runAutopilot', () => {
     const result = await runAutopilot({
       repoRoot,
       changeId: 'REQ-123',
-      goal: 'Ship thin autopilot loop'
+      goal
     });
 
     const runtimeState = JSON.parse(fs.readFileSync(getRuntimeStatePath(repoRoot, 'REQ-123'), 'utf8'));
 
     expect(result.executed).toEqual(['init', 'snapshot', 'plan']);
     expect(result.currentStage).toBe('approve');
-    expect(runtimeState.changeKey).toBe('REQ-123-change');
+    expect(runtimeState.changeKey).toBe('REQ-123-ship-thin-autopilot-loop');
     expect(fs.existsSync(getReportCardPath(repoRoot, 'REQ-123'))).toBe(false);
     expect(fs.existsSync(getIntentPrBriefPath(repoRoot, 'REQ-123'))).toBe(false);
     expect(fs.existsSync(getIntentResumeIndexPath(repoRoot, 'REQ-123'))).toBe(false);
@@ -93,9 +94,10 @@ describe('runAutopilot', () => {
       }
     });
 
-    fs.mkdirSync(path.dirname(getTasksMarkdownPath(repoRoot, 'REQ-123')), { recursive: true });
+    const goal = 'Ship thin autopilot loop with delegated workers';
+    fs.mkdirSync(path.dirname(getTasksMarkdownPath(repoRoot, 'REQ-123', { goal })), { recursive: true });
     fs.writeFileSync(
-      getTasksMarkdownPath(repoRoot, 'REQ-123'),
+      getTasksMarkdownPath(repoRoot, 'REQ-123', { goal }),
       [
         '- [ ] T001 直接执行任务 (src/a.ts)',
         '- [ ] T002 委派实现任务 [P] (src/a.ts,src/b.ts)'
@@ -105,7 +107,7 @@ describe('runAutopilot', () => {
     await runAutopilot({
       repoRoot,
       changeId: 'REQ-123',
-      goal: 'Ship thin autopilot loop with delegated workers'
+      goal
     });
 
     await runApprove({
@@ -160,16 +162,17 @@ describe('runAutopilot', () => {
       }
     });
 
-    fs.mkdirSync(path.dirname(getTasksMarkdownPath(repoRoot, 'REQ-123')), { recursive: true });
+    const goal = 'Ship thin autopilot loop and release';
+    fs.mkdirSync(path.dirname(getTasksMarkdownPath(repoRoot, 'REQ-123', { goal })), { recursive: true });
     fs.writeFileSync(
-      getTasksMarkdownPath(repoRoot, 'REQ-123'),
+      getTasksMarkdownPath(repoRoot, 'REQ-123', { goal }),
       '- [ ] T001 发布前收尾 (src/a.ts)'
     );
 
     await runAutopilot({
       repoRoot,
       changeId: 'REQ-123',
-      goal: 'Ship thin autopilot loop and release'
+      goal
     });
 
     await runApprove({

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

@@ -229,6 +229,11 @@ describe('cc-devflow cli distribution bootstrap', () => {
     );
     expect(codexRoadmapSkill.data.writes).toEqual(
       expect.arrayContaining([
+        expect.objectContaining({
+          path: 'devflow/roadmap.json',
+          durability: 'durable',
+          required: true
+        }),
         expect.objectContaining({
           path: 'devflow/ROADMAP.md',
           durability: 'durable',
@@ -237,10 +242,13 @@ describe('cc-devflow cli distribution bootstrap', () => {
         expect.objectContaining({
           path: 'devflow/BACKLOG.md',
           durability: 'durable',
-          required: true
+          required: false
         })
       ])
     );
+    expect(codexRoadmapSkill.data.writes).not.toEqual(
+      expect.arrayContaining([expect.objectContaining({ path: 'devflow/roadmap-tracking.json', required: true })])
+    );
   });
 
   test('adapt mirrors Codex skills without baking project YAML output policy', () => {

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

@@ -39,4 +39,29 @@ describe('change directory naming', () => {
 
     fs.rmSync(repoRoot, { recursive: true, force: true });
   });
+
+  test('allows duplicate numbers when descriptions differ', () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-paths-'));
+    fs.mkdirSync(path.join(repoRoot, 'devflow', 'changes', 'REQ-123-existing-plan'), { recursive: true });
+
+    const paths = getChangePaths(repoRoot, 'REQ-123', { goal: 'Another plan' });
+
+    expect(paths.changeKey).toBe('REQ-123-another-plan');
+    expect(paths.changeDir).toBe(path.join(repoRoot, 'devflow', 'changes', 'REQ-123-another-plan'));
+
+    fs.rmSync(repoRoot, { recursive: true, force: true });
+  });
+
+  test('requires explicit change keys when duplicate numbers already exist', () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-paths-'));
+    fs.mkdirSync(path.join(repoRoot, 'devflow', 'changes', 'REQ-123-first-plan'), { recursive: true });
+    fs.mkdirSync(path.join(repoRoot, 'devflow', 'changes', 'REQ-123-second-plan'), { recursive: true });
+
+    expect(() => getChangePaths(repoRoot, 'REQ-123'))
+      .toThrow(/Ambiguous changeId "REQ-123"/);
+    expect(getChangePaths(repoRoot, 'REQ-123', { changeKey: 'REQ-123-second-plan' }).changeKey)
+      .toBe('REQ-123-second-plan');
+
+    fs.rmSync(repoRoot, { recursive: true, force: true });
+  });
 });

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

@@ -324,6 +324,55 @@ describe('query helpers', () => {
     expect(listQueryIds()).toEqual(expect.arrayContaining(['full-state', 'next-task', 'progress']));
   });
 
+  test('requires a full change key when duplicate local numbers exist', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-duplicate-key-'));
+    const firstKey = 'REQ-132-first-plan';
+    const secondKey = 'REQ-132-second-plan';
+
+    fs.mkdirSync(path.join(repoRoot, 'devflow', 'changes', firstKey), { recursive: true });
+    writeJson(getTaskManifestPath(repoRoot, 'REQ-132', { changeKey: secondKey }), {
+      changeId: 'REQ-132',
+      goal: 'Resolve duplicate local numbers',
+      createdAt: '2026-05-08T01:00:00.000Z',
+      updatedAt: '2026-05-08T01:05:00.000Z',
+      tasks: [
+        { id: 'T001', status: 'passed' },
+        { id: 'T002', status: 'pending' }
+      ],
+      metadata: {
+        source: 'test',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    await expect(runQuery('progress', { repoRoot, changeId: 'REQ-132' })).resolves.toMatchObject({
+      ok: false,
+      queryId: 'progress',
+      error: {
+        message: expect.stringContaining('Ambiguous changeId "REQ-132"')
+      },
+      trace: {
+        event: 'query.progress.failed',
+        nextAction: 'inspect-runtime-artifacts'
+      }
+    });
+
+    await expect(runQuery('progress', {
+      repoRoot,
+      changeId: 'REQ-132',
+      changeKey: secondKey
+    })).resolves.toMatchObject({
+      ok: true,
+      queryId: 'progress',
+      data: {
+        totalTasks: 2,
+        completedTasks: 1,
+        pendingTasks: 1
+      }
+    });
+  });
+
   test('returns a named error for unknown query ids', async () => {
     const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-unknown-'));
 

package/lib/skill-runtime/artifacts.js

@@ -68,8 +68,8 @@ function getLegacyIntentProjectionPaths(repoRoot, goalId, taskIds = [], options
   ];
 }
 
-async function ensureIntentScaffold(repoRoot, goalId) {
-  const change = getChangePaths(repoRoot, goalId);
+async function ensureIntentScaffold(repoRoot, goalId, options = {}) {
+  const change = getChangePaths(repoRoot, goalId, options);
 
   await ensureDir(change.changeDir);
   await ensureDir(change.metaDir);

package/lib/skill-runtime/intent.js

@@ -68,11 +68,11 @@ function summarizeGateSection(gates = []) {
   });
 }
 
-async function readLatestCheckpoints(repoRoot, changeId, tasks = []) {
+async function readLatestCheckpoints(repoRoot, changeId, tasks = [], options = {}) {
   const checkpoints = [];
 
   for (const task of tasks) {
-    const checkpoint = await readJson(getCheckpointPath(repoRoot, changeId, task.id), null);
+    const checkpoint = await readJson(getCheckpointPath(repoRoot, changeId, task.id, options), null);
     if (!checkpoint) {
       continue;
     }
@@ -90,28 +90,28 @@ async function readLatestCheckpoints(repoRoot, changeId, tasks = []) {
   return checkpoints;
 }
 
-async function cleanupLegacyArtifacts(repoRoot, changeId, manifest) {
+async function cleanupLegacyArtifacts(repoRoot, changeId, manifest, options = {}) {
   const taskIds = (manifest?.tasks || []).map((task) => task.id);
-  const change = getChangePaths(repoRoot, changeId);
+  const change = getChangePaths(repoRoot, changeId, options);
 
   await Promise.all(
-    getLegacyIntentProjectionPaths(repoRoot, changeId, taskIds).map((target) => removePath(target))
+    getLegacyIntentProjectionPaths(repoRoot, changeId, taskIds, options).map((target) => removePath(target))
   );
   await removePath(change.workersDir);
 }
 
-async function clearHandoffArtifacts(repoRoot, changeId, keep = null) {
+async function clearHandoffArtifacts(repoRoot, changeId, keep = null, options = {}) {
   await Promise.all(
-    getIntentHandoffArtifactPaths(repoRoot, changeId)
+    getIntentHandoffArtifactPaths(repoRoot, changeId, options)
       .filter((target) => target !== keep)
       .map((target) => removePath(target))
   );
 }
 
-async function writeResumeIndex(repoRoot, changeId, state, manifest, report) {
-  await ensureIntentScaffold(repoRoot, changeId);
+async function writeResumeIndex(repoRoot, changeId, state, manifest, report, options = {}) {
+  await ensureIntentScaffold(repoRoot, changeId, options);
 
-  const checkpoints = await readLatestCheckpoints(repoRoot, changeId, manifest?.tasks || []);
+  const checkpoints = await readLatestCheckpoints(repoRoot, changeId, manifest?.tasks || [], options);
   const lastGoodCheckpoint = checkpoints.find((checkpoint) => checkpoint.status === 'passed') || checkpoints[0] || null;
   const blockers = [
     ...(manifest?.tasks || [])
@@ -119,8 +119,8 @@ async function writeResumeIndex(repoRoot, changeId, state, manifest, report) {
       .map((task) => `${task.id}: ${task.lastError || 'Task failed'}`),
     ...(report?.blockingFindings || [])
   ];
-  const hasPrBrief = await exists(getIntentPrBriefPath(repoRoot, changeId));
-  const hasReleaseNote = await exists(getReleaseNotePath(repoRoot, changeId));
+  const hasPrBrief = await exists(getIntentPrBriefPath(repoRoot, changeId, options));
+  const hasReleaseNote = await exists(getReleaseNotePath(repoRoot, changeId, options));
   const stage = deriveLifecycleStage({ state, manifest, report, hasPrBrief });
   const approval = getApprovalState(state, manifest);
   const goal = manifest?.goal || state?.goal || changeId;
@@ -131,7 +131,7 @@ async function writeResumeIndex(repoRoot, changeId, state, manifest, report) {
     hasPrBrief,
     hasReleaseNote
   });
-  const resumePath = getIntentResumeIndexPath(repoRoot, changeId);
+  const resumePath = getIntentResumeIndexPath(repoRoot, changeId, options);
 
   const content = [
     `# Resume Index: ${changeId}`,
@@ -167,7 +167,7 @@ async function writeResumeIndex(repoRoot, changeId, state, manifest, report) {
     ])
   ].join('\n');
 
-  await clearHandoffArtifacts(repoRoot, changeId, resumePath);
+  await clearHandoffArtifacts(repoRoot, changeId, resumePath, options);
   await writeText(resumePath, `${content}\n`);
 
   return {

package/lib/skill-runtime/operations/autopilot-shared.js

@@ -28,11 +28,11 @@ function hasUnresolvedTasks(manifest) {
   );
 }
 
-async function loadState(repoRoot, changeId) {
+async function loadState(repoRoot, changeId, options = {}) {
   const [state, manifest, report] = await Promise.all([
-    readJson(getRuntimeStatePath(repoRoot, changeId), null),
-    readJson(getTaskManifestPath(repoRoot, changeId), null),
-    readJson(getReportCardPath(repoRoot, changeId), null)
+    readJson(getRuntimeStatePath(repoRoot, changeId, options), null),
+    readJson(getTaskManifestPath(repoRoot, changeId, options), null),
+    readJson(getReportCardPath(repoRoot, changeId, options), null)
   ]);
 
   return { state, manifest, report };

package/lib/skill-runtime/paths.js

@@ -1,7 +1,7 @@
 /**
  * [INPUT]: 依赖 fs/path，接收 repoRoot/changeId/taskId/workerId 等定位参数。
  * [OUTPUT]: 对外提供 devflow canonical layout 的唯一路径解析能力。
- * [POS]: skill runtime 的路径真相源，强制新 change 目录使用 REQ/FIX 前缀。
+ * [POS]: skill runtime 的路径真相源，完整 change key 才是目录身份。
  * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
  */
 
@@ -85,17 +85,27 @@ function listChangeKeys(repoRoot) {
     .sort();
 }
 
-function findExistingChangeKey(repoRoot, changeId) {
+function findExistingChangeKeys(repoRoot, changeId) {
   const canonicalPrefix = `${getChangeKeyPrefix(changeId)}-`;
   const legacyKey = slugifySegment(changeId, 'change');
   const legacyPrefix = `${legacyKey}-`;
 
-  return listChangeKeys(repoRoot).find((name) => (
+  return listChangeKeys(repoRoot).filter((name) => (
     name === changeId
     || name === legacyKey
     || name.startsWith(canonicalPrefix)
     || name.startsWith(legacyPrefix)
-  )) || null;
+  ));
+}
+
+function findExactChangeKey(repoRoot, changeId, changeKey) {
+  const slug = getChangeSlug(changeId, changeKey);
+  const aliases = new Set([
+    changeKey,
+    `${slugifySegment(changeId, 'change')}-${slug}`
+  ]);
+
+  return listChangeKeys(repoRoot).find((name) => aliases.has(name)) || null;
 }
 
 function assertChangeKey(changeId, changeKey) {
@@ -132,9 +142,20 @@ function resolveChangeKey(repoRoot, changeId, options = {}) {
     return assertChangeKey(changeId, options.changeKey);
   }
 
-  const existing = findExistingChangeKey(repoRoot, changeId);
-  if (existing) {
-    return existing;
+  const requestedSlug = options.slug || stripChangeIdPrefix(changeId, options.goal);
+  if (requestedSlug) {
+    const requestedKey = buildChangeKey(changeId, { slug: requestedSlug });
+    return findExactChangeKey(repoRoot, changeId, requestedKey) || requestedKey;
+  }
+
+  const existing = findExistingChangeKeys(repoRoot, changeId);
+  if (existing.length === 1) {
+    return existing[0];
+  }
+  if (existing.length > 1) {
+    throw new Error(
+      `Ambiguous changeId "${changeId}": found ${existing.join(', ')}. Pass an explicit changeKey.`
+    );
   }
 
   return buildChangeKey(changeId, options);

package/lib/skill-runtime/query-registry.js

@@ -48,10 +48,10 @@ function createQueryRegistry(entries) {
       };
     }
 
-    const artifactRefs = resolveArtifactRefs(entry, context, 'artifactRefs');
-    const requiredArtifactRefs = resolveArtifactRefs(entry, context, 'requiredArtifactRefs');
-
+    let artifactRefs = [];
     try {
+      artifactRefs = resolveArtifactRefs(entry, context, 'artifactRefs');
+      const requiredArtifactRefs = resolveArtifactRefs(entry, context, 'requiredArtifactRefs');
       const missingRefs = requiredArtifactRefs.filter((ref) => !fs.existsSync(ref));
       if (missingRefs.length > 0) {
         throw namedError(

package/lib/skill-runtime/query.js

@@ -1,5 +1,5 @@
 /**
- * [INPUT]: 依赖 store/artifacts/lifecycle 读取 requirement 工件，接收 repoRoot 和 changeId。
+ * [INPUT]: 依赖 store/artifacts/lifecycle 读取 requirement 工件，接收 repoRoot、changeId 和可选 changeKey。
  * [OUTPUT]: 对外提供 typed query registry 与兼容查询函数，附 named error 和 trace shape。
  * [POS]: skill runtime 的薄查询兼容层，只读 artifact 与共享 lifecycle 语义，不再自带流程推导副本。
  * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
@@ -65,8 +65,8 @@ async function readQueryArtifact(filePath, { required = true } = {}) {
  * @param {string} changeId - 需求 ID
  * @returns {Promise<Object>} 进度统计对象
  */
-async function getProgress(repoRoot, changeId) {
-  const manifestPath = getTaskManifestPath(repoRoot, changeId);
+async function getProgress(repoRoot, changeId, options = {}) {
+  const manifestPath = getTaskManifestPath(repoRoot, changeId, options);
   const manifest = await readQueryArtifact(manifestPath);
   return deriveTaskProgress(manifest.tasks || []);
 }
@@ -77,8 +77,8 @@ async function getProgress(repoRoot, changeId) {
  * @param {string} changeId - 需求 ID
  * @returns {Promise<Object|null>} 下一个任务对象或 null
  */
-async function getNextTask(repoRoot, changeId) {
-  const manifestPath = getTaskManifestPath(repoRoot, changeId);
+async function getNextTask(repoRoot, changeId, options = {}) {
+  const manifestPath = getTaskManifestPath(repoRoot, changeId, options);
   const manifest = await readQueryArtifact(manifestPath);
   const executionState = deriveManifestExecutionState(manifest.tasks || []);
   const activePhase = manifest.activePhase ?? executionState.activePhase;
@@ -117,18 +117,18 @@ async function getNextTask(repoRoot, changeId) {
  * @param {string} changeId - 需求 ID
  * @returns {Promise<Object>} 完整状态对象
  */
-async function getFullState(repoRoot, changeId) {
-  const statePath = getRuntimeStatePath(repoRoot, changeId);
-  const reportPath = getReportCardPath(repoRoot, changeId);
-  const prBriefPath = getIntentPrBriefPath(repoRoot, changeId);
+async function getFullState(repoRoot, changeId, options = {}) {
+  const statePath = getRuntimeStatePath(repoRoot, changeId, options);
+  const reportPath = getReportCardPath(repoRoot, changeId, options);
+  const prBriefPath = getIntentPrBriefPath(repoRoot, changeId, options);
 
   const [state, manifest, hasPrBrief] = await Promise.all([
     readQueryArtifact(statePath),
-    readQueryArtifact(getTaskManifestPath(repoRoot, changeId)),
+    readQueryArtifact(getTaskManifestPath(repoRoot, changeId, options)),
     exists(prBriefPath)
   ]);
-  const progress = await getProgress(repoRoot, changeId);
-  const nextTask = await getNextTask(repoRoot, changeId);
+  const progress = await getProgress(repoRoot, changeId, options);
+  const nextTask = await getNextTask(repoRoot, changeId, options);
   const report = await readQueryArtifact(reportPath, { required: false });
 
   return {
@@ -160,8 +160,8 @@ async function getFullState(repoRoot, changeId) {
   };
 }
 
-async function getShipReadiness(repoRoot, changeId) {
-  const reportPath = getReportCardPath(repoRoot, changeId);
+async function getShipReadiness(repoRoot, changeId, options = {}) {
+  const reportPath = getReportCardPath(repoRoot, changeId, options);
   const report = await readJson(reportPath, null);
 
   if (!report) {
@@ -178,12 +178,12 @@ async function getShipReadiness(repoRoot, changeId) {
   return deriveShipReadiness(report, { reportPath });
 }
 
-function queryArtifactRefs(repoRoot, changeId, names) {
+function queryArtifactRefs(repoRoot, changeId, names, options = {}) {
   const refs = {
-    manifest: getTaskManifestPath(repoRoot, changeId),
-    state: getRuntimeStatePath(repoRoot, changeId),
-    report: getReportCardPath(repoRoot, changeId),
-    prBrief: getIntentPrBriefPath(repoRoot, changeId)
+    manifest: getTaskManifestPath(repoRoot, changeId, options),
+    state: getRuntimeStatePath(repoRoot, changeId, options),
+    report: getReportCardPath(repoRoot, changeId, options),
+    prBrief: getIntentPrBriefPath(repoRoot, changeId, options)
   };
 
   return names.map((name) => refs[name]).filter(Boolean);
@@ -192,26 +192,26 @@ function queryArtifactRefs(repoRoot, changeId, names) {
 const registry = createQueryRegistry([
   {
     id: 'progress',
-    artifactRefs: ({ repoRoot, changeId }) => queryArtifactRefs(repoRoot, changeId, ['manifest']),
-    requiredArtifactRefs: ({ repoRoot, changeId }) => queryArtifactRefs(repoRoot, changeId, ['manifest']),
-    handler: ({ repoRoot, changeId }) => getProgress(repoRoot, changeId)
+    artifactRefs: ({ repoRoot, changeId, changeKey }) => queryArtifactRefs(repoRoot, changeId, ['manifest'], { changeKey }),
+    requiredArtifactRefs: ({ repoRoot, changeId, changeKey }) => queryArtifactRefs(repoRoot, changeId, ['manifest'], { changeKey }),
+    handler: ({ repoRoot, changeId, changeKey }) => getProgress(repoRoot, changeId, { changeKey })
   },
   {
     id: 'next-task',
-    artifactRefs: ({ repoRoot, changeId }) => queryArtifactRefs(repoRoot, changeId, ['manifest']),
-    requiredArtifactRefs: ({ repoRoot, changeId }) => queryArtifactRefs(repoRoot, changeId, ['manifest']),
-    handler: ({ repoRoot, changeId }) => getNextTask(repoRoot, changeId)
+    artifactRefs: ({ repoRoot, changeId, changeKey }) => queryArtifactRefs(repoRoot, changeId, ['manifest'], { changeKey }),
+    requiredArtifactRefs: ({ repoRoot, changeId, changeKey }) => queryArtifactRefs(repoRoot, changeId, ['manifest'], { changeKey }),
+    handler: ({ repoRoot, changeId, changeKey }) => getNextTask(repoRoot, changeId, { changeKey })
   },
   {
     id: 'full-state',
-    artifactRefs: ({ repoRoot, changeId }) => queryArtifactRefs(repoRoot, changeId, ['state', 'manifest', 'report', 'prBrief']),
-    requiredArtifactRefs: ({ repoRoot, changeId }) => queryArtifactRefs(repoRoot, changeId, ['state', 'manifest']),
-    handler: ({ repoRoot, changeId }) => getFullState(repoRoot, changeId)
+    artifactRefs: ({ repoRoot, changeId, changeKey }) => queryArtifactRefs(repoRoot, changeId, ['state', 'manifest', 'report', 'prBrief'], { changeKey }),
+    requiredArtifactRefs: ({ repoRoot, changeId, changeKey }) => queryArtifactRefs(repoRoot, changeId, ['state', 'manifest'], { changeKey }),
+    handler: ({ repoRoot, changeId, changeKey }) => getFullState(repoRoot, changeId, { changeKey })
   },
   {
     id: 'ship-readiness',
-    artifactRefs: ({ repoRoot, changeId }) => queryArtifactRefs(repoRoot, changeId, ['report']),
-    handler: ({ repoRoot, changeId }) => getShipReadiness(repoRoot, changeId)
+    artifactRefs: ({ repoRoot, changeId, changeKey }) => queryArtifactRefs(repoRoot, changeId, ['report'], { changeKey }),
+    handler: ({ repoRoot, changeId, changeKey }) => getShipReadiness(repoRoot, changeId, { changeKey })
   }
 ]);
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "cc-devflow",
-    "version": "4.5.4",
+    "version": "4.5.6",
     "description": "Multi-platform CLI and skill pack for agent coding",
     "main": "bin/cc-devflow.js",
     "bin": {