cc-devflow 4.2.0 → 4.4.1

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

@@ -0,0 +1,163 @@
+/**
+ * [INPUT]: 依赖 autopilot shared/core/execution runner，接收 changeId、goal、from、resume 等推进参数。
+ * [OUTPUT]: 作为兼容入口串联最小阶段闭环，写入 autopilot 起止日志，并返回当前阶段、已执行步骤、resume 索引与 PR brief 路径。
+ * [POS]: skill runtime 的 autopilot 兼容入口，只保留阶段顺序与总结果汇总。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const {
+  exists
+} = require('../store');
+const {
+  getIntentResumeIndexPath
+} = require('../artifacts');
+const { syncIntentMemory } = require('../intent');
+const {
+  normalizeStage,
+  stageIndex,
+  resolveCompletedStage,
+  runDiscoverStage,
+  runConvergeStage,
+  runApprovalStage,
+  runDelegateStage,
+  runFinishStages
+} = require('./autopilot-core');
+const {
+  loadState
+} = require('./autopilot-shared');
+const {
+  runExecutionStage
+} = require('./autopilot-execution');
+
+async function runAutopilot({
+  repoRoot,
+  changeId,
+  goal,
+  from,
+  resume = false,
+  overwrite = false,
+  parallel = 3,
+  maxRetries,
+  strict = false,
+  skipReview = false,
+  release = false,
+  workerProvider,
+  workerProviderArgs,
+  workerCommand
+}) {
+  const executed = [];
+  const fromIndex = stageIndex(from);
+  const resolveResumeIndexPath = async () => (
+    await exists(getIntentResumeIndexPath(repoRoot, changeId))
+      ? getIntentResumeIndexPath(repoRoot, changeId)
+      : null
+  );
+
+  await syncIntentMemory(repoRoot, changeId, {
+    event: 'autopilot_started',
+    reason: `Autopilot entered at stage ${normalizeStage(from) || 'discover'}`
+  });
+
+  let snapshot = await loadState(repoRoot, changeId);
+
+  snapshot = await runDiscoverStage({
+    repoRoot,
+    changeId,
+    goal,
+    fromIndex,
+    executed,
+    snapshot
+  });
+
+  snapshot = await runConvergeStage({
+    repoRoot,
+    changeId,
+    goal,
+    fromIndex,
+    overwrite,
+    executed,
+    snapshot
+  });
+
+  const approvalResult = await runApprovalStage({
+    repoRoot,
+    changeId,
+    fromIndex,
+    executed,
+    snapshot
+  });
+  snapshot = approvalResult.snapshot;
+
+  if (approvalResult.shouldStop) {
+    const completedStage = resolveCompletedStage(snapshot);
+    await syncIntentMemory(repoRoot, changeId, {
+      event: 'autopilot_finished',
+      reason: `Autopilot stopped at stage ${completedStage}`
+    });
+
+    return {
+      changeId,
+      executed,
+      currentStage: completedStage,
+      lifecycleStatus: snapshot.state?.status || 'unknown',
+      reportOverall: snapshot.report?.overall || null,
+      resumeIndexPath: await resolveResumeIndexPath(),
+      prBriefPath: null
+    };
+  }
+
+  snapshot = await runDelegateStage({
+    repoRoot,
+    changeId,
+    fromIndex,
+    executed,
+    snapshot
+  });
+
+  snapshot = await runExecutionStage({
+    repoRoot,
+    changeId,
+    fromIndex,
+    snapshot,
+    executed,
+    parallel,
+    maxRetries,
+    resume,
+    workerProvider,
+    workerProviderArgs,
+    workerCommand
+  });
+
+  const finishResult = await runFinishStages({
+    repoRoot,
+    changeId,
+    from,
+    fromIndex,
+    strict,
+    skipReview,
+    release,
+    executed,
+    snapshot
+  });
+  snapshot = finishResult.snapshot;
+
+  const completedStage = resolveCompletedStage(snapshot);
+  await syncIntentMemory(repoRoot, changeId, {
+    event: 'autopilot_finished',
+    reason: `Autopilot stopped at stage ${completedStage}`
+  });
+
+  return {
+    changeId,
+    executed,
+    currentStage: completedStage,
+    lifecycleStatus: snapshot.state?.status || 'unknown',
+    reportOverall: snapshot.report?.overall || null,
+    resumeIndexPath: await resolveResumeIndexPath(),
+    prBriefPath: finishResult.prBriefPath
+  };
+}
+
+module.exports = {
+  runAutopilot
+};

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

@@ -0,0 +1,454 @@
+/**
+ * [INPUT]: 依赖 manifest/checkpoint/events 与 shell 执行能力，接收并行度与重试参数。
+ * [OUTPUT]: 更新 task-manifest 状态，写入每任务 events.jsonl 与 checkpoint.json。
+ * [POS]: skill runtime Stage-4 执行入口，被内部执行与恢复链路复用。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const {
+  nowIso,
+  ensureDir,
+  appendJsonl,
+  writeJson,
+  readJson,
+  runCommand,
+  getTaskManifestPath,
+  getRuntimeStatePath,
+  getRuntimeTaskDir,
+  getEventsPath,
+  getCheckpointPath
+} = require('../store');
+const { parseManifest, parseCheckpoint } = require('../schemas');
+const { applyManifestExecutionState } = require('../planner');
+const { syncIntentMemory } = require('../intent');
+const {
+  summarizeTaskStates,
+  classifyDelegationMode,
+  getApprovalState,
+  isExecutionApproved
+} = require('../lifecycle');
+const {
+  findAssignment,
+  ensureWorkerWorkspace,
+  updateAssignmentStatus,
+  updateWorkerState,
+  appendWorkerJournal,
+  appendMessageBus
+} = require('../delegation');
+
+function toSessionId(taskId) {
+  return `${taskId}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function dependenciesPassed(task, taskMap) {
+  return task.dependsOn.every((depId) => {
+    const dep = taskMap.get(depId);
+    return dep && dep.status === 'passed';
+  });
+}
+
+function dependenciesFailed(task, taskMap) {
+  return task.dependsOn.some((depId) => {
+    const dep = taskMap.get(depId);
+    return dep && (dep.status === 'failed' || dep.status === 'skipped');
+  });
+}
+
+function hasTouchConflict(task, lockedTouches) {
+  if (!task.touches || task.touches.length === 0) {
+    return false;
+  }
+
+  return task.touches.some((filePath) => lockedTouches.has(filePath));
+}
+
+function selectBatch(readyTasks, parallel) {
+  const selected = [];
+  const lockedTouches = new Set();
+
+  for (const task of readyTasks) {
+    if (selected.length >= parallel) {
+      break;
+    }
+
+    if (hasTouchConflict(task, lockedTouches)) {
+      continue;
+    }
+
+    selected.push(task);
+    for (const touched of task.touches) {
+      lockedTouches.add(touched);
+    }
+  }
+
+  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;
+  }
+  const eventsPath = getEventsPath(repoRoot, changeId, taskId);
+  await appendJsonl(eventsPath, event);
+}
+
+async function writeManifest(repoRoot, changeId, manifest) {
+  const manifestPath = getTaskManifestPath(repoRoot, changeId);
+  applyManifestExecutionState(manifest, nowIso());
+  await writeJson(manifestPath, 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);
+  const commands = [...task.run, ...task.checks];
+  const taskRetry = Number.isInteger(retryOverride) ? retryOverride : task.maxRetries;
+  const maxAttempts = Math.max(1, taskRetry + 1);
+  const expectedPlanVersion = task.planVersion || 1;
+
+  if (assignment) {
+    await updateAssignmentStatus(repoRoot, changeId, task.id, {
+      status: 'running',
+      workspace: worker.workspacePath,
+      sessionId,
+      summary: worker.mode === 'worktree'
+        ? `Worker ${assignment.workerId} running in worktree`
+        : `Worker ${assignment.workerId} fell back to controller workspace: ${worker.reason}`
+    });
+    await updateWorkerState(repoRoot, changeId, assignment.workerId, {
+      role: assignment.role,
+      planVersion: expectedPlanVersion,
+      status: 'running',
+      currentTask: task.id,
+      workspace: worker.workspacePath
+    });
+    await appendWorkerJournal(
+      repoRoot,
+      changeId,
+      assignment.workerId,
+      `started ${task.id} in ${worker.mode === 'worktree' ? worker.workspacePath : 'controller workspace'}`
+    );
+    await appendMessageBus(
+      repoRoot,
+      changeId,
+      `${assignment.workerId} started ${task.id} in ${worker.mode === 'worktree' ? worker.workspacePath : 'controller workspace'}`
+    );
+  }
+
+  while (task.attempts < maxAttempts) {
+    task.attempts += 1;
+    task.status = 'running';
+
+    await writeEvent(repoRoot, changeId, task.id, {
+      type: 'task_started',
+      changeId,
+      taskId: task.id,
+      sessionId,
+      attempt: task.attempts,
+      timestamp: nowIso()
+    }, debug);
+
+    let failed = false;
+    let failureMessage = '';
+
+    for (const command of commands) {
+      const result = await runCommand(command, {
+        cwd: worker.cwd,
+        timeoutMs: 30 * 60 * 1000
+      });
+
+      await writeEvent(repoRoot, changeId, task.id, {
+        type: 'command_finished',
+        changeId,
+        taskId: task.id,
+        sessionId,
+        attempt: task.attempts,
+        command,
+        code: result.code,
+        durationMs: result.durationMs,
+        timestamp: nowIso()
+      }, debug);
+
+      if (result.code !== 0) {
+        failed = true;
+        failureMessage = (result.stderr || result.stdout || 'Command failed').trim();
+        break;
+      }
+    }
+
+    if (!failed) {
+      const latestManifest = parseManifest(await readJson(getTaskManifestPath(repoRoot, changeId)));
+      const latestPlanVersion = latestManifest.metadata?.planVersion || 1;
+
+      if (latestPlanVersion !== expectedPlanVersion) {
+        failed = true;
+        failureMessage = `Stale result rejected: task ran with plan_version ${expectedPlanVersion} but current plan_version is ${latestPlanVersion}`;
+      }
+    }
+
+    if (!failed) {
+      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,
+        taskId: task.id,
+        sessionId,
+        attempts: task.attempts,
+        timestamp: nowIso()
+      }, debug);
+
+      if (assignment) {
+        await updateAssignmentStatus(repoRoot, changeId, task.id, {
+          status: 'completed',
+          workspace: worker.workspacePath,
+          sessionId,
+          summary: `Worker ${assignment.workerId} completed task successfully`
+        });
+        await updateWorkerState(repoRoot, changeId, assignment.workerId, {
+          role: assignment.role,
+          planVersion: expectedPlanVersion,
+          status: 'idle',
+          currentTask: 'none',
+          workspace: worker.workspacePath
+        });
+        await appendWorkerJournal(repoRoot, changeId, assignment.workerId, `completed ${task.id}`);
+        await appendMessageBus(repoRoot, changeId, `${assignment.workerId} completed ${task.id}`);
+      }
+
+      return;
+    }
+
+    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,
+      taskId: task.id,
+      sessionId,
+      attempt: task.attempts,
+      error: failureMessage,
+      timestamp: nowIso()
+    }, debug);
+
+    if (assignment) {
+      await updateAssignmentStatus(repoRoot, changeId, task.id, {
+        status: 'failed',
+        workspace: worker.workspacePath,
+        sessionId,
+        summary: failureMessage.slice(0, 240)
+      });
+      await updateWorkerState(repoRoot, changeId, assignment.workerId, {
+        role: assignment.role,
+        planVersion: expectedPlanVersion,
+        status: 'idle',
+        currentTask: 'none',
+        workspace: worker.workspacePath
+      });
+      await appendWorkerJournal(
+        repoRoot,
+        changeId,
+        assignment.workerId,
+        `failed ${task.id}: ${failureMessage.slice(0, 120)}`
+      );
+      await appendMessageBus(repoRoot, changeId, `${assignment.workerId} failed ${task.id}: ${failureMessage.slice(0, 120)}`);
+    }
+  }
+}
+
+function isTaskIncluded(task, executionScope, state) {
+  if (executionScope === 'direct') {
+    return classifyDelegationMode(task, state || {}) === 'direct';
+  }
+
+  return true;
+}
+
+async function runDispatch({
+  repoRoot,
+  changeId,
+  parallel = 3,
+  maxRetries,
+  resume = false,
+  executionScope = 'all',
+  debug = false
+}) {
+  const manifestPath = getTaskManifestPath(repoRoot, changeId);
+  const manifest = parseManifest(await readJson(manifestPath));
+  const activePlanVersion = manifest.metadata?.planVersion || 1;
+
+  // Update change-state.json to in_progress on first dispatch
+  const statePath = getRuntimeStatePath(repoRoot, changeId);
+  const state = await readJson(statePath, null);
+  const stateExists = require('fs').existsSync(statePath);
+  const approval = getApprovalState(state, manifest);
+  if (!isExecutionApproved(state, manifest)) {
+    await syncIntentMemory(repoRoot, changeId, {
+      event: 'dispatch_blocked_unapproved',
+      reason: `Plan version ${approval.planVersion || activePlanVersion} must be approved before execute`
+    });
+
+    return {
+      changeId,
+      manifestPath,
+      summary: summarizeTaskStates(manifest.tasks),
+      success: false,
+      reason: `Execution blocked until plan_version ${approval.planVersion || activePlanVersion} is approved. Return to the cc-plan approval gate and keep execution mode ${approval.executionMode}.`
+    };
+  }
+
+  if (stateExists) {
+    if (state.status === 'planned' || state.status === 'initialized') {
+      state.status = 'in_progress';
+      state.updatedAt = nowIso();
+      await writeJson(statePath, state);
+    }
+  }
+
+  if (resume) {
+    for (const task of manifest.tasks) {
+      if (task.status === 'running') {
+        task.status = 'pending';
+      }
+    }
+  }
+
+  for (const task of manifest.tasks) {
+    task.planVersion = activePlanVersion;
+  }
+
+  await syncIntentMemory(repoRoot, changeId, {
+    event: resume ? 'resume_started' : 'dispatch_started',
+    reason: resume ? 'Resume flow entered dispatch loop' : 'Dispatch flow entered execution loop'
+  });
+
+  const safeParallel = Math.max(1, Number.parseInt(parallel, 10) || 1);
+
+  while (true) {
+    const taskMap = new Map(manifest.tasks.map((task) => [task.id, task]));
+    const pending = manifest.tasks.filter((task) =>
+      task.status === 'pending' && isTaskIncluded(task, executionScope, state)
+    );
+
+    if (pending.length === 0) {
+      break;
+    }
+
+    for (const task of pending) {
+      if (dependenciesFailed(task, taskMap)) {
+        task.status = 'skipped';
+        task.lastError = 'Blocked by failed dependency';
+      }
+    }
+
+    const ready = manifest.tasks.filter(
+      (task) => task.status === 'pending' &&
+        isTaskIncluded(task, executionScope, state) &&
+        dependenciesPassed(task, taskMap)
+    );
+
+    if (ready.length === 0) {
+      await writeManifest(repoRoot, changeId, manifest);
+
+      await syncIntentMemory(repoRoot, changeId, {
+        event: 'dispatch_blocked',
+        reason: 'No ready tasks left after dependency evaluation'
+      });
+
+      return {
+        changeId,
+        manifestPath,
+        summary: summarizeTaskStates(manifest.tasks),
+        success: false,
+        reason: 'No ready tasks left. Check dependencies and failed tasks.'
+      };
+    }
+
+    const batch = selectBatch(ready, safeParallel);
+
+    if (batch.length === 0) {
+      const firstReady = ready[0];
+      batch.push(firstReady);
+    }
+
+    await Promise.all(
+      batch.map((task) =>
+        executeTask({
+          repoRoot,
+          changeId,
+          task,
+          retryOverride: Number.isInteger(maxRetries) ? maxRetries : undefined,
+          debug
+        })
+      )
+    );
+
+    await writeManifest(repoRoot, changeId, manifest);
+    await syncIntentMemory(repoRoot, changeId, {
+      event: 'dispatch_batch_completed',
+      reason: `Completed batch of ${batch.length} task(s)`
+    });
+  }
+
+  await writeManifest(repoRoot, changeId, manifest);
+
+  const summary = summarizeTaskStates(manifest.tasks);
+  const scopedPending = manifest.tasks.filter((task) =>
+    ['pending', 'running', 'failed'].includes(task.status) && isTaskIncluded(task, executionScope, state)
+  );
+  const success = scopedPending.length === 0;
+
+  await syncIntentMemory(repoRoot, changeId, {
+    event: success ? 'dispatch_completed' : 'dispatch_incomplete',
+    reason: success ? 'All executable tasks completed' : 'Dispatch loop ended with unresolved tasks'
+  });
+
+  return {
+    changeId,
+    manifestPath,
+    summary,
+    success
+  };
+}
+
+module.exports = {
+  runDispatch
+};

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

@@ -0,0 +1,64 @@
+/**
+ * [INPUT]: 依赖 store 提供 repo/change 路径与读写能力，接收 changeId/goal 初始化参数。
+ * [OUTPUT]: 写入 canonical devflow 目录与 change-state.json，返回初始化摘要。
+ * [POS]: skill runtime Stage-1 初始化入口，供内部初始化链路复用。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const {
+  nowIso,
+  ensureDir,
+  writeJson,
+  readJson,
+  getChangeDir,
+  getRuntimeChangeDir,
+  getRuntimeStatePath
+} = require('../store');
+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);
+
+  const previous = (await readJson(statePath, {})) || {};
+  const createdAt = previous.createdAt || nowIso();
+  const nextState = {
+    changeId,
+    changeKey: changePaths.changeKey,
+    slug: getChangeSlug(changeId, changePaths.changeKey),
+    createdAt,
+    goal: goal || previous.goal || `Deliver ${changeId} safely with auditable checkpoints.`,
+    status: 'initialized',
+    initializedAt: previous.initializedAt || nowIso(),
+    approval: {
+      status: 'pending',
+      executionMode: previous.approval?.executionMode || 'delegate'
+    },
+    updatedAt: nowIso()
+  };
+
+  await writeJson(statePath, nextState);
+
+  return {
+    changeId,
+    changeDir,
+    runtimeDir,
+    changeKey: changePaths.changeKey,
+    statePath,
+    status: nextState.status
+  };
+}
+
+module.exports = {
+  runInit
+};

package/lib/{harness → skill-runtime}/operations/janitor.js

@@ -1,7 +1,7 @@
 /**
- * [INPUT]: 依赖 .harness/runtime 目录与 checkpoint 状态，接收保留小时阈值。
+ * [INPUT]: 依赖 devflow/changes 下 execution/tasks 目录与 checkpoint 状态，接收保留小时阈值。
  * [OUTPUT]: 删除过期且非运行中的任务运行态目录，并输出清理统计。
- * [POS]: harness 熵清理入口，被 CLI `harness:janitor` 调用。
+ * [POS]: skill runtime 熵清理入口，被 CLI `harness:janitor` 调用。
  * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
  */
 
@@ -37,7 +37,7 @@ async function runJanitor({ repoRoot, hours = 72 }) {
   let removedChangeDirs = 0;
 
   for (const changeDir of changeDirs) {
-    const taskDirs = await listDirectories(changeDir);
+    const taskDirs = await listDirectories(path.join(changeDir, 'execution', 'tasks'));
 
     for (const taskDir of taskDirs) {
       const stat = await fs.promises.stat(taskDir);
@@ -54,10 +54,13 @@ async function runJanitor({ repoRoot, hours = 72 }) {
       removedTaskDirs += 1;
     }
 
-    const remaining = await listDirectories(changeDir);
+    const remaining = await listDirectories(path.join(changeDir, 'execution', 'tasks'));
     if (remaining.length === 0) {
-      await removeDirectoryRecursive(changeDir);
-      removedChangeDirs += 1;
+      const stat = await fs.promises.stat(changeDir);
+      if (stat.mtimeMs < cutoffMs) {
+        await removeDirectoryRecursive(path.join(changeDir, 'execution', 'tasks'));
+        removedChangeDirs += 1;
+      }
     }
   }