cc-devflow 4.5.9 → 4.5.11

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);

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

@@ -6,6 +6,7 @@ const {
   getFullState,
   getNextTask,
   getProgress,
+  getWorkflowContext,
   listQueryIds,
   runQuery
 } = require('../query');
@@ -288,6 +289,386 @@ describe('query helpers', () => {
     expect(next.id).toBe('T002');
   });
 
+  test('returns compact workflow context for the current ready task', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-workflow-context-'));
+    const manifestPath = getTaskManifestPath(repoRoot, 'REQ-126');
+    const planningDir = path.dirname(manifestPath);
+    const changeDir = path.dirname(planningDir);
+
+    fs.mkdirSync(planningDir, { recursive: true });
+    fs.writeFileSync(path.join(planningDir, 'design.md'), '# Design\n');
+    fs.writeFileSync(path.join(planningDir, 'tasks.md'), '# Tasks\n');
+    writeJson(path.join(changeDir, 'change-meta.json'), {
+      spec: {
+        primaryCapability: 'cap-compact-context',
+        syncStatus: 'planned'
+      }
+    });
+    writeJson(manifestPath, {
+      changeId: 'REQ-126',
+      goal: 'Expose compact workflow context',
+      createdAt: '2026-05-12T01:00:00.000Z',
+      updatedAt: '2026-05-12T01:05:00.000Z',
+      currentTaskId: 'T002',
+      planningMeta: {
+        reqPlanSkillVersion: '3.8.8'
+      },
+      tasks: [
+        {
+          id: 'T001',
+          title: 'Completed test task',
+          type: 'TEST',
+          phase: 1,
+          dependsOn: [],
+          touches: ['src/feature.test.ts'],
+          files: ['src/feature.test.ts'],
+          run: ['npm test -- src/feature.test.ts'],
+          checks: [],
+          acceptance: [],
+          verification: ['npm test -- src/feature.test.ts'],
+          evidence: ['red output'],
+          context: { readFiles: ['planning/design.md'], commands: ['npm test -- src/feature.test.ts'], notes: [] },
+          status: 'passed',
+          attempts: 1,
+          maxRetries: 1
+        },
+        {
+          id: 'T002',
+          title: 'Implement compact context',
+          type: 'IMPL',
+          phase: 1,
+          dependsOn: ['T001'],
+          touches: ['lib/skill-runtime/query.js'],
+          files: ['lib/skill-runtime/query.js'],
+          run: ['npm test -- lib/skill-runtime/__tests__/query.test.js'],
+          checks: [],
+          acceptance: [],
+          verification: ['npm test -- lib/skill-runtime/__tests__/query.test.js'],
+          evidence: ['green output'],
+          context: {
+            readFiles: ['design.md', 'tasks.md', 'change-meta.json', 'lib/skill-runtime/query.js'],
+            commands: ['npm test -- lib/skill-runtime/__tests__/query.test.js'],
+            notes: ['Read the context index before opening deep docs']
+          },
+          status: 'pending',
+          attempts: 0,
+          maxRetries: 1
+        }
+      ],
+      metadata: {
+        source: 'test',
+        generatedBy: 'test',
+        planVersion: 2
+      }
+    });
+
+    const context = await getWorkflowContext(repoRoot, 'REQ-126');
+
+    expect(context.nextAction).toMatchObject({
+      skill: 'cc-do',
+      action: 'execute-current-task',
+      taskId: 'T002'
+    });
+    expect(context.currentTask).toMatchObject({
+      id: 'T002',
+      context: {
+        readFiles: expect.arrayContaining(['design.md', 'tasks.md', 'change-meta.json', 'lib/skill-runtime/query.js'])
+      }
+    });
+    expect(context.progressiveDisclosure).toMatchObject({
+      mode: 'compact-first',
+      rule: expect.stringContaining('context index'),
+      packetOnly: {
+        contractDigest: expect.any(String),
+        manifestDigest: expect.any(String),
+        currentTaskDigest: expect.any(String),
+        evidenceDigest: expect.any(String),
+        mustNotForgetDigest: expect.any(String)
+      }
+    });
+    expect(context.source.manifest).toMatchObject({
+      path: expect.stringContaining('planning/task-manifest.json'),
+      hash: expect.stringMatching(/^sha256:/)
+    });
+    expect(context.progressiveDisclosure.sourceHashes).toEqual(expect.objectContaining({
+      [context.source.manifest.path]: expect.stringMatching(/^sha256:/)
+    }));
+    expect(context.progressiveDisclosure.mustNotForget).toMatchObject({
+      goal: {
+        value: 'Expose compact workflow context',
+        source: {
+          ref: expect.stringContaining('planning/task-manifest.json#/goal'),
+          hash: expect.stringMatching(/^sha256:/)
+        }
+      },
+      nonNegotiables: expect.arrayContaining([
+        expect.objectContaining({
+          value: expect.stringContaining('read-only'),
+          source: expect.objectContaining({ ref: expect.any(String) })
+        })
+      ]),
+      acceptanceGates: expect.arrayContaining([
+        expect.objectContaining({
+          value: 'npm test -- lib/skill-runtime/__tests__/query.test.js',
+          source: expect.objectContaining({ ref: expect.stringContaining('planning/task-manifest.json#/tasks/T002') })
+        })
+      ])
+    });
+    expect(context.progressiveDisclosure.defaultOpen).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        ref: expect.stringContaining('planning/design.md#design'),
+        reason: 'primary task contract',
+        exists: true,
+        sourceHash: expect.stringMatching(/^sha256:/)
+      }),
+      expect.objectContaining({
+        ref: expect.stringContaining('planning/task-manifest.json#/tasks/T002'),
+        reason: 'current task source of truth',
+        sourceHash: expect.stringMatching(/^sha256:/)
+      }),
+      expect.objectContaining({
+        ref: expect.stringContaining('change-meta.json#/spec')
+      })
+    ]));
+    expect(context.progressiveDisclosure.defaultOpen.every((entry) => entry.exists === true)).toBe(true);
+    expect(context.progressiveDisclosure.defaultRead).toBeUndefined();
+    expect(context.progressiveDisclosure.deepOpen).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        when: 'scope_or_contract_uncertain',
+        conditions: expect.arrayContaining(['confidence.scope < 0.85']),
+        refs: expect.arrayContaining([
+          expect.objectContaining({ ref: expect.stringContaining('planning/design.md') })
+        ])
+      }),
+      expect.objectContaining({
+        when: 'implementation_details_needed',
+        refs: expect.arrayContaining([
+          expect.objectContaining({ ref: 'lib/skill-runtime/query.js' })
+        ])
+      })
+    ]));
+    expect(context.progressiveDisclosure.defaultOpen).not.toEqual(expect.arrayContaining([
+      'design.md',
+      'tasks.md',
+      'change-meta.json'
+    ]));
+    expect(context.progressiveDisclosure.commandsToTrust).toContain('npm test -- lib/skill-runtime/__tests__/query.test.js');
+    expect(context.progressiveDisclosure.openWhen).toEqual(expect.arrayContaining([
+      expect.objectContaining({
+        trigger: expect.stringContaining('all tasks are complete'),
+        conditions: expect.arrayContaining(['nextAction.skill == cc-act'])
+      })
+    ]));
+    expect(context.planningMeta).toMatchObject({
+      reqPlanSkillVersion: '3.8.8',
+      sourceCapability: 'cap-compact-context',
+      specSyncStatus: 'planned'
+    });
+  });
+
+  test('routes compact workflow context through check and act after execution', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-workflow-terminal-'));
+
+    writeJson(getTaskManifestPath(repoRoot, 'REQ-127'), {
+      changeId: 'REQ-127',
+      goal: 'Expose terminal workflow routing',
+      createdAt: '2026-05-12T01:00:00.000Z',
+      updatedAt: '2026-05-12T01:05:00.000Z',
+      tasks: [
+        {
+          id: 'T001',
+          status: 'passed',
+          verification: ['npm test -- final.test.js'],
+          context: {
+            commands: ['npm test -- final.test.js']
+          }
+        }
+      ],
+      metadata: {
+        source: 'test',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-127')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-check',
+        action: 'build-fresh-verdict'
+      },
+      progressiveDisclosure: {
+        commandsToTrust: ['npm test -- final.test.js']
+      }
+    });
+
+    writeJson(getReportCardPath(repoRoot, 'REQ-127'), {
+      changeId: 'REQ-127',
+      verdict: 'pass',
+      overall: 'pass',
+      reroute: 'none',
+      specSyncReady: false,
+      blockingFindings: [],
+      timestamp: '2026-05-12T01:10:00.000Z'
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-127')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-check',
+        action: 'build-fresh-verdict',
+        blockers: expect.arrayContaining(['specSyncReady is not true'])
+      }
+    });
+
+    writeJson(getReportCardPath(repoRoot, 'REQ-127'), {
+      changeId: 'REQ-127',
+      verdict: 'pass',
+      overall: 'pass',
+      reroute: 'none',
+      specSyncReady: true,
+      blockingFindings: [],
+      timestamp: '2026-05-12T01:11:00.000Z'
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-127')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-act',
+        action: 'ship-or-handoff'
+      }
+    });
+  });
+
+  test('resumes current running task before selecting another ready task', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-workflow-resume-'));
+
+    writeJson(getTaskManifestPath(repoRoot, 'REQ-130'), {
+      changeId: 'REQ-130',
+      currentTaskId: 'T002',
+      tasks: [
+        { id: 'T001', status: 'passed' },
+        {
+          id: 'T002',
+          status: 'running',
+          dependsOn: ['T001'],
+          verification: ['npm test -- src/current.test.ts'],
+          context: {
+            commands: ['npm test -- src/current.test.ts']
+          }
+        },
+        {
+          id: 'T003',
+          status: 'pending',
+          dependsOn: ['T001'],
+          verification: ['npm test -- src/ready.test.ts'],
+          context: {
+            commands: ['npm test -- src/ready.test.ts']
+          }
+        }
+      ],
+      metadata: {
+        source: 'test',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-130')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-do',
+        action: 'resume-current-task',
+        taskId: 'T002'
+      },
+      currentTask: {
+        id: 'T002',
+        status: 'running'
+      }
+    });
+  });
+
+  test('resumes inferred running task before selecting ready task when currentTaskId is missing', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-workflow-inferred-resume-'));
+
+    writeJson(getTaskManifestPath(repoRoot, 'REQ-132'), {
+      changeId: 'REQ-132',
+      tasks: [
+        { id: 'T001', status: 'passed' },
+        {
+          id: 'T002',
+          status: 'running',
+          dependsOn: ['T001'],
+          verification: ['npm test -- src/current.test.ts'],
+          context: {
+            commands: ['npm test -- src/current.test.ts']
+          }
+        },
+        {
+          id: 'T003',
+          status: 'pending',
+          dependsOn: ['T001'],
+          verification: ['npm test -- src/ready.test.ts'],
+          context: {
+            commands: ['npm test -- src/ready.test.ts']
+          }
+        }
+      ],
+      metadata: {
+        source: 'test',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-132')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-do',
+        action: 'resume-current-task',
+        taskId: 'T002'
+      },
+      currentTask: {
+        id: 'T002',
+        status: 'running'
+      }
+    });
+  });
+
+  test('reports missing verification commands instead of trusting the query command', async () => {
+    const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-workflow-missing-commands-'));
+
+    writeJson(getTaskManifestPath(repoRoot, 'REQ-131'), {
+      changeId: 'REQ-131',
+      currentTaskId: 'T001',
+      tasks: [
+        {
+          id: 'T001',
+          status: 'pending',
+          context: {
+            readFiles: ['design.md']
+          }
+        }
+      ],
+      metadata: {
+        source: 'test',
+        generatedBy: 'test',
+        planVersion: 1
+      }
+    });
+
+    await expect(getWorkflowContext(repoRoot, 'REQ-131')).resolves.toMatchObject({
+      nextAction: {
+        skill: 'cc-plan',
+        action: 'repair-task-verification',
+        taskId: 'T001'
+      },
+      progressiveDisclosure: {
+        commandsToTrust: [],
+        missingVerificationCommands: true,
+        manifestIssue: 'current task has no executable verification command',
+        failClosed: expect.arrayContaining([
+          expect.stringContaining('verification command is missing')
+        ])
+      }
+    });
+  });
+
   test('dispatches typed query ids with trace metadata', async () => {
     const repoRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'cc-devflow-query-registry-'));
 
@@ -321,7 +702,7 @@ describe('query helpers', () => {
       }
     });
 
-    expect(listQueryIds()).toEqual(expect.arrayContaining(['full-state', 'next-task', 'progress']));
+    expect(listQueryIds()).toEqual(expect.arrayContaining(['full-state', 'next-task', 'progress', 'workflow-context']));
   });
 
   test('requires a full change key when duplicate local numbers exist', async () => {
@@ -354,7 +735,7 @@ describe('query helpers', () => {
       },
       trace: {
         event: 'query.progress.failed',
-        nextAction: 'inspect-runtime-artifacts'
+        nextAction: 'inspect-workflow-artifacts'
       }
     });
 
@@ -381,7 +762,7 @@ describe('query helpers', () => {
       queryId: 'unknown-query',
       error: {
         name: 'UnknownQueryError',
-        rescueAction: 'use one of: full-state, next-task, progress, ship-readiness'
+        rescueAction: 'use one of: full-state, next-task, progress, ship-readiness, workflow-context'
       },
       trace: {
         nextAction: 'choose-supported-query'
@@ -400,11 +781,11 @@ describe('query helpers', () => {
         artifactRefs: [
           expect.stringContaining('task-manifest.json')
         ],
-        rescueAction: 'create required runtime artifacts before running this query'
+        rescueAction: 'create required workflow artifacts before running this query'
       },
       trace: {
         event: 'query.progress.failed',
-        nextAction: 'create required runtime artifacts before running this query'
+        nextAction: 'create required workflow artifacts before running this query'
       }
     });
   });
@@ -423,11 +804,11 @@ describe('query helpers', () => {
         artifactRefs: [
           expect.stringContaining('task-manifest.json')
         ],
-        rescueAction: 'repair or regenerate the invalid runtime artifact before running this query'
+        rescueAction: 'repair or regenerate the invalid workflow artifact before running this query'
       },
       trace: {
         event: 'query.progress.failed',
-        nextAction: 'repair or regenerate the invalid runtime artifact before running this query'
+        nextAction: 'repair or regenerate the invalid workflow artifact before running this query'
       }
     });
   });