cc-devflow 4.5.9 → 4.5.10

package/lib/skill-runtime/operations/dispatch.js

@@ -1,24 +1,21 @@
 /**
- * [INPUT]: 依赖 manifest/checkpoint/events 与 shell 执行能力，接收并行度与重试参数。
- * [OUTPUT]: 更新 task-manifest 状态，写入每任务 events.jsonl 与 checkpoint.json。
+ * [INPUT]: 依赖 manifest/events 与 shell 执行能力，接收并行度与重试参数。
+ * [OUTPUT]: 更新 task-manifest 状态，失败或 debug 时写入每任务 events.jsonl。
  * [POS]: skill runtime Stage-4 执行入口，被内部执行与恢复链路复用。
  * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
  */
 
 const {
   nowIso,
-  ensureDir,
   appendJsonl,
   writeJson,
   readJson,
   runCommand,
   getTaskManifestPath,
   getRuntimeStatePath,
-  getRuntimeTaskDir,
-  getEventsPath,
-  getCheckpointPath
+  getEventsPath
 } = require('../store');
-const { parseManifest, parseCheckpoint } = require('../schemas');
+const { parseManifest } = require('../schemas');
 const { applyManifestExecutionState } = require('../planner');
 const { syncIntentMemory } = require('../intent');
 const {
@@ -84,12 +81,6 @@ function selectBatch(readyTasks, parallel) {
   return selected;
 }
 
-async function writeCheckpoint(repoRoot, changeId, taskId, payload, options = {}) {
-  const checkpointPath = getCheckpointPath(repoRoot, changeId, taskId);
-  const checkpoint = parseCheckpoint(payload);
-  await writeJson(checkpointPath, checkpoint);
-}
-
 async function writeEvent(repoRoot, changeId, taskId, event, debug = false) {
   if (!debug && !String(event.type || '').includes('failed') && !String(event.type || '').includes('rejected')) {
     return;
@@ -105,9 +96,6 @@ async function writeManifest(repoRoot, changeId, manifest) {
 }
 
 async function executeTask({ repoRoot, changeId, task, retryOverride, debug = false }) {
-  const taskRuntimeDir = getRuntimeTaskDir(repoRoot, changeId, task.id);
-  await ensureDir(taskRuntimeDir);
-
   const assignment = await findAssignment(repoRoot, changeId, task.id);
   const worker = await ensureWorkerWorkspace(repoRoot, changeId, assignment);
   const sessionId = toSessionId(task.id);
@@ -200,19 +188,6 @@ async function executeTask({ repoRoot, changeId, task, retryOverride, debug = fa
       task.status = 'passed';
       task.lastError = undefined;
 
-      await writeCheckpoint(repoRoot, changeId, task.id, {
-        changeId,
-        taskId: task.id,
-        sessionId,
-        planVersion: expectedPlanVersion,
-        status: task.status,
-        summary: `Task passed after ${task.attempts} attempt(s)`,
-        error: '',
-        outputExcerpt: '',
-        timestamp: nowIso(),
-        attempt: task.attempts
-      });
-
       await writeEvent(repoRoot, changeId, task.id, {
         type: 'task_passed',
         changeId,
@@ -246,19 +221,6 @@ async function executeTask({ repoRoot, changeId, task, retryOverride, debug = fa
     task.status = 'failed';
     task.lastError = failureMessage;
 
-    await writeCheckpoint(repoRoot, changeId, task.id, {
-      changeId,
-      taskId: task.id,
-      sessionId,
-      planVersion: expectedPlanVersion,
-      status: task.status,
-      summary: `Task failed: ${failureMessage.slice(0, 240)}`,
-      error: failureMessage,
-      outputExcerpt: failureMessage.slice(0, 400),
-      timestamp: nowIso(),
-      attempt: task.attempts
-    });
-
     await writeEvent(repoRoot, changeId, task.id, {
       type: failureMessage.includes('Stale result rejected') ? 'task_stale_rejected' : 'task_failed',
       changeId,

package/lib/skill-runtime/operations/init.js

@@ -11,7 +11,6 @@ const {
   writeJson,
   readJson,
   getChangeDir,
-  getRuntimeChangeDir,
   getRuntimeStatePath
 } = require('../store');
 const { getChangePaths, getChangeSlug } = require('../paths');
@@ -19,14 +18,11 @@ const { getChangePaths, getChangeSlug } = require('../paths');
 async function runInit({ repoRoot, changeId, goal }) {
   const changePaths = getChangePaths(repoRoot, changeId, { goal });
   const changeDir = getChangeDir(repoRoot, changeId, { goal });
-  const runtimeDir = getRuntimeChangeDir(repoRoot, changeId, { goal });
   const statePath = getRuntimeStatePath(repoRoot, changeId, { goal });
 
   await ensureDir(changeDir);
   await ensureDir(changePaths.metaDir);
   await ensureDir(changePaths.planningDir);
-  await ensureDir(runtimeDir);
-  await ensureDir(changePaths.tasksDir);
   await ensureDir(changePaths.reviewDir);
   await ensureDir(changePaths.handoffDir);
 
@@ -37,7 +33,7 @@ async function runInit({ repoRoot, changeId, goal }) {
     changeKey: changePaths.changeKey,
     slug: getChangeSlug(changeId, changePaths.changeKey),
     createdAt,
-    goal: goal || previous.goal || `Deliver ${changeId} safely with auditable checkpoints.`,
+    goal: goal || previous.goal || `Deliver ${changeId} safely with task-state truth.`,
     status: 'initialized',
     initializedAt: previous.initializedAt || nowIso(),
     approval: {
@@ -52,7 +48,7 @@ async function runInit({ repoRoot, changeId, goal }) {
   return {
     changeId,
     changeDir,
-    runtimeDir,
+    runtimeDir: changePaths.executionDir,
     changeKey: changePaths.changeKey,
     statePath,
     status: nextState.status

package/lib/skill-runtime/operations/janitor.js

@@ -1,6 +1,6 @@
 /**
- * [INPUT]: 依赖 devflow/changes 下 execution/tasks 目录与 checkpoint 状态，接收保留小时阈值。
- * [OUTPUT]: 删除过期且非运行中的任务运行态目录，并输出清理统计。
+ * [INPUT]: 依赖 devflow/changes 下 execution/tasks 目录与 mtime，接收保留小时阈值。
+ * [OUTPUT]: 删除过期任务运行态目录，并输出清理统计。
  * [POS]: skill runtime 熵清理入口，被 CLI `harness:janitor` 调用。
  * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
  */
@@ -8,7 +8,6 @@
 const fs = require('fs');
 const path = require('path');
 const {
-  readJson,
   listDirectories,
   getRuntimeRoot
 } = require('../store');
@@ -17,17 +16,6 @@ async function removeDirectoryRecursive(dirPath) {
   await fs.promises.rm(dirPath, { recursive: true, force: true });
 }
 
-async function isTaskActive(taskDir) {
-  const checkpointPath = path.join(taskDir, 'checkpoint.json');
-  const checkpoint = await readJson(checkpointPath, null);
-
-  if (!checkpoint) {
-    return false;
-  }
-
-  return checkpoint.status === 'running';
-}
-
 async function runJanitor({ repoRoot, hours = 72 }) {
   const runtimeRoot = getRuntimeRoot(repoRoot);
   const cutoffMs = Date.now() - Number(hours) * 60 * 60 * 1000;
@@ -46,10 +34,6 @@ async function runJanitor({ repoRoot, hours = 72 }) {
         continue;
       }
 
-      if (await isTaskActive(taskDir)) {
-        continue;
-      }
-
       await removeDirectoryRecursive(taskDir);
       removedTaskDirs += 1;
     }

package/lib/skill-runtime/operations/resume.js

@@ -1,6 +1,6 @@
 /**
- * [INPUT]: 依赖 manifest/checkpoint 当前状态与 dispatch 执行器，接收 changeId/并行度/重试参数。
- * [OUTPUT]: 将失败执行明确恢复到最近稳定 checkpoint，把未稳定任务重新排队后继续执行。
+ * [INPUT]: 依赖 manifest 当前状态与 dispatch 执行器，接收 changeId/并行度/重试参数。
+ * [OUTPUT]: 将失败执行恢复到最近已通过的 manifest 任务边界，把未稳定任务重新排队后继续执行。
  * [POS]: skill runtime 恢复执行入口，供内部恢复链路复用。
  * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
  */
@@ -9,8 +9,7 @@ const {
   readJson,
   writeJson,
   getTaskManifestPath,
-  getRuntimeStatePath,
-  getCheckpointPath
+  getRuntimeStatePath
 } = require('../store');
 const { parseManifest } = require('../schemas');
 const { applyManifestExecutionState } = require('../planner');
@@ -18,33 +17,17 @@ const { runDispatch } = require('./dispatch');
 const { syncIntentMemory } = require('../intent');
 const { getApprovalState, isExecutionApproved } = require('../lifecycle');
 
-async function resolveStableCheckpoint(repoRoot, changeId, manifest) {
-  const checkpoints = await Promise.all(
-    manifest.tasks.map(async (task) => {
-      const checkpoint = await readJson(getCheckpointPath(repoRoot, changeId, task.id), null);
-      if (!checkpoint) {
-        return null;
-      }
-
-      return {
-        taskId: task.id,
-        status: checkpoint.status,
-        timestamp: checkpoint.timestamp,
-        summary: checkpoint.summary,
-        planVersion: checkpoint.planVersion || null
-      };
-    })
-  );
-
-  const latestPassed = checkpoints
-    .filter((checkpoint) =>
-      checkpoint &&
-      checkpoint.status === 'passed' &&
-      checkpoint.planVersion === (manifest.metadata?.planVersion || 1)
-    )
-    .sort((left, right) => right.timestamp.localeCompare(left.timestamp))[0];
-
-  return latestPassed || null;
+async function resolveStableManifestPoint(manifest) {
+  const passedTasks = manifest.tasks
+    .filter((task) => task.status === 'passed')
+    .map((task) => ({
+      taskId: task.id,
+      status: task.status,
+      title: task.title || '',
+      planVersion: manifest.metadata?.planVersion || 1
+    }));
+
+  return passedTasks[passedTasks.length - 1] || null;
 }
 
 function restoreTaskToPending(task, restoreLabel) {
@@ -54,8 +37,8 @@ function restoreTaskToPending(task, restoreLabel) {
   task.lastError = `Restored from ${restoreLabel}.${previousError}`.trim();
 }
 
-function requeueFromStableCheckpoint(manifest, restoreTarget) {
-  const restoreLabel = restoreTarget ? `stable checkpoint ${restoreTarget.taskId}` : 'execution start';
+function requeueFromStableManifestPoint(manifest, restoreTarget) {
+  const restoreLabel = restoreTarget ? `stable manifest task ${restoreTarget.taskId}` : 'execution start';
   const restoredTaskIds = [];
 
   for (const task of manifest.tasks) {
@@ -106,16 +89,16 @@ async function runResume({
   }
 
   if (fromCheckpoint && fromCheckpoint !== 'stable') {
-    throw new Error(`Unsupported --from-checkpoint value: ${fromCheckpoint}`);
+    throw new Error(`Unsupported resume point: ${fromCheckpoint}`);
   }
 
-  const restoreTarget = await resolveStableCheckpoint(repoRoot, changeId, manifest);
-  const restoreSummary = requeueFromStableCheckpoint(manifest, restoreTarget);
+  const restoreTarget = await resolveStableManifestPoint(manifest);
+  const restoreSummary = requeueFromStableManifestPoint(manifest, restoreTarget);
 
   applyManifestExecutionState(manifest);
   await writeJson(manifestPath, manifest);
   await syncIntentMemory(repoRoot, changeId, {
-    event: 'resume_restored_checkpoint',
+    event: 'resume_restored_manifest_state',
     reason: restoreSummary.restoredTaskIds.length > 0
       ? `Restored ${restoreSummary.restoredTaskIds.join(', ')} from ${restoreSummary.restoreLabel}`
       : `Resume confirmed ${restoreSummary.restoreLabel}; no unresolved tasks required requeue`
@@ -132,7 +115,7 @@ async function runResume({
 
   return {
     ...dispatchResult,
-    restoredCheckpoint: restoreTarget,
+    restoredState: restoreTarget,
     restoredTasks: restoreSummary.restoredTaskIds,
     reason: dispatchResult.reason || `Resumed from ${restoreSummary.restoreLabel}`
   };

package/lib/skill-runtime/operations/review-records.js

@@ -0,0 +1,265 @@
+/**
+ * [INPUT]: 依赖 review-records helper、store.appendJsonl、ReviewLedgerEventSchema。
+ * [OUTPUT]: 实现 review durable records CLI operation，当前只写 review-started。
+ * [POS]: CLI 与 durable review ledger 的边界层；负责校验后追加 JSONL。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const path = require('path');
+
+const { getChangePaths } = require('../paths');
+const { appendJsonl, readText, writeText } = require('../store');
+const { parseReviewLedgerEvent } = require('../schemas');
+const {
+  getReviewLedgerPath,
+  nextReviewId,
+  parseSkippedNode
+} = require('../review-records');
+
+function readLedgerEvents(text) {
+  return String(text || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+}
+
+function normalizeArray(values) {
+  return (values || [])
+    .flatMap((value) => String(value || '').split(','))
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
+async function loadLedger(repoRoot, changeId, changeKey) {
+  const change = getChangePaths(repoRoot, changeId, { changeKey });
+  const ledgerPath = getReviewLedgerPath(repoRoot, changeId, { changeKey });
+  const events = readLedgerEvents(await readText(ledgerPath, ''));
+  return { change, ledgerPath, events };
+}
+
+function hasStarted(events, reviewId) {
+  return events.some((event) => event.reviewId === reviewId && event.event === 'review-started');
+}
+
+function hasClosed(events, reviewId) {
+  return events.some((event) => event.reviewId === reviewId && event.event === 'review-closed');
+}
+
+async function appendReviewEvent(options, eventFields) {
+  const {
+    repoRoot,
+    changeId,
+    changeKey,
+    reviewId,
+    now = new Date()
+  } = options;
+  const { change, ledgerPath, events } = await loadLedger(repoRoot, changeId, changeKey);
+
+  if (!reviewId || !hasStarted(events, reviewId)) {
+    return {
+      code: 4,
+      stderr: `Review ${reviewId || '<missing>'} has not been started`
+    };
+  }
+
+  if (eventFields.event === 'review-closed' && hasClosed(events, reviewId)) {
+    return {
+      code: 4,
+      stderr: `Review ${reviewId} is already closed`
+    };
+  }
+
+  const event = parseReviewLedgerEvent({
+    schema: 'review-ledger.v2',
+    change: change.changeKey,
+    reviewId,
+    createdAt: now.toISOString(),
+    createdBy: 'cc-devflow-cli',
+    ...eventFields
+  });
+
+  await appendJsonl(ledgerPath, event);
+
+  return {
+    code: 0,
+    reviewId,
+    ledgerPath: path.relative(repoRoot, ledgerPath),
+    event: event.event
+  };
+}
+
+async function runReviewStart(options) {
+  const {
+    repoRoot,
+    changeId,
+    changeKey,
+    mode = 'implementation',
+    scope = 'current-diff',
+    baseSha = 'unknown',
+    headSha = 'unknown',
+    selectedNodes = [],
+    skippedNodes = [],
+    riskLanes = [],
+    now = new Date()
+  } = options;
+  const change = getChangePaths(repoRoot, changeId, { changeKey });
+  const ledgerPath = getReviewLedgerPath(repoRoot, changeId, { changeKey });
+  const existingEvents = readLedgerEvents(await readText(ledgerPath, ''));
+  const reviewId = nextReviewId(existingEvents, now);
+  const event = parseReviewLedgerEvent({
+    schema: 'review-ledger.v2',
+    change: change.changeKey,
+    reviewId,
+    createdAt: now.toISOString(),
+    createdBy: 'cc-devflow-cli',
+    event: 'review-started',
+    mode,
+    scope,
+    baseSha,
+    headSha,
+    selectedNodes: normalizeArray(selectedNodes),
+    skippedNodes: skippedNodes.map(parseSkippedNode),
+    riskLanes: normalizeArray(riskLanes)
+  });
+
+  await appendJsonl(ledgerPath, event);
+
+  return {
+    code: 0,
+    reviewId,
+    ledgerPath: path.relative(repoRoot, ledgerPath),
+    event: event.event
+  };
+}
+
+async function runReviewRecordNode(options) {
+  return appendReviewEvent(options, {
+    event: 'review-node-checked',
+    nodeId: options.nodeId,
+    mode: options.mode || 'implementation',
+    target: options.target,
+    status: options.status || 'checked',
+    coverage: normalizeArray(options.coverage),
+    evidenceRefs: normalizeArray(options.evidenceRefs),
+    findings: normalizeArray(options.findings),
+    next: options.next || 'cc-check'
+  });
+}
+
+async function runReviewAddFinding(options) {
+  return appendReviewEvent(options, {
+    event: 'review-finding-added',
+    findingId: options.findingId,
+    severity: options.severity || 'important',
+    confidence: Number(options.confidence),
+    displayTier: options.displayTier || 'blocking',
+    fingerprint: options.fingerprint,
+    scope: options.scope,
+    path: options.path,
+    evidence: options.evidence,
+    recommendation: options.recommendation,
+    route: options.route || 'cc-do'
+  });
+}
+
+async function runReviewClose(options) {
+  return appendReviewEvent(options, {
+    event: 'review-closed',
+    status: options.status || 'clean',
+    blockingCount: Number(options.blockingCount || 0),
+    warningCount: Number(options.warningCount || 0),
+    next: options.next || 'cc-check'
+  });
+}
+
+function renderReviewMarkdown({ changeKey, reviewId, events }) {
+  const closed = events.find((event) => event.event === 'review-closed');
+  const findings = events.filter((event) => event.event === 'review-finding-added');
+  const lines = [
+    '---',
+    'Output language: en',
+    `reviewId: ${reviewId}`,
+    `change: ${changeKey}`,
+    '---',
+    '',
+    `# Review ${reviewId}`,
+    '',
+    '## Summary',
+    '',
+    `- Status: ${closed?.status || 'open'}`,
+    `- Blocking findings: ${closed?.blockingCount ?? 0}`,
+    `- Warnings: ${closed?.warningCount ?? 0}`,
+    `- Next: ${closed?.next || 'cc-check'}`,
+    '',
+    '## Findings',
+    ''
+  ];
+
+  if (findings.length === 0) {
+    lines.push('- None');
+  } else {
+    for (const finding of findings) {
+      lines.push(
+        `- ${finding.findingId} [${finding.severity}/${finding.displayTier}, confidence ${finding.confidence}] ${finding.path}`,
+        `  - Evidence: ${finding.evidence}`,
+        `  - Recommendation: ${finding.recommendation}`,
+        `  - Route: ${finding.route}`
+      );
+    }
+  }
+
+  lines.push('', '## Ledger Events', '');
+  for (const event of events) {
+    lines.push(`- ${event.event} at ${event.createdAt}`);
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+async function runReviewRender(options) {
+  const {
+    repoRoot,
+    changeId,
+    changeKey,
+    reviewId,
+    output
+  } = options;
+  const { change, events } = await loadLedger(repoRoot, changeId, changeKey);
+  const selectedReviewId = reviewId
+    || [...events].reverse().find((event) => event.event === 'review-started')?.reviewId;
+
+  if (!selectedReviewId) {
+    return { code: 4, stderr: 'No reviewId available to render' };
+  }
+
+  if (!output) {
+    return { code: 4, stderr: 'review render --output is required' };
+  }
+
+  const reviewEvents = events.filter((event) => event.reviewId === selectedReviewId);
+  if (reviewEvents.length === 0) {
+    return { code: 4, stderr: `Review ${selectedReviewId} has no ledger events` };
+  }
+
+  const outputPath = path.isAbsolute(output) ? output : path.join(repoRoot, output);
+  await writeText(outputPath, renderReviewMarkdown({
+    changeKey: change.changeKey,
+    reviewId: selectedReviewId,
+    events: reviewEvents
+  }));
+
+  return {
+    code: 0,
+    reviewId: selectedReviewId,
+    outputPath: path.relative(repoRoot, outputPath)
+  };
+}
+
+module.exports = {
+  runReviewAddFinding,
+  runReviewClose,
+  runReviewRecordNode,
+  runReviewRender,
+  runReviewStart
+};

package/lib/skill-runtime/operations/snapshot.js

@@ -28,7 +28,7 @@ async function collectGitFacts(repoRoot) {
 
 async function runPlanningSnapshot({ repoRoot, changeId, goal }) {
   const state = (await readJson(getRuntimeStatePath(repoRoot, changeId), {})) || {};
-  const effectiveGoal = goal || state.goal || `Deliver ${changeId} safely with auditable checkpoints.`;
+  const effectiveGoal = goal || state.goal || `Deliver ${changeId} safely with task-state truth.`;
   const gitFacts = await collectGitFacts(repoRoot);
   const scripts = await getPackageScripts(repoRoot);