cc-devflow 4.3.0 → 4.5.0

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

@@ -0,0 +1,337 @@
+/**
+ * [INPUT]: 依赖 store/intent/delegation 与 discover/converge/delegate/verify/release 原语，接收阶段上下文。
+ * [OUTPUT]: 对外提供 autopilot 的阶段判定、approval gate、state 读取与非执行类 stage runner。
+ * [POS]: autopilot 的核心生命周期层，负责阶段顺序、记忆写点与 finish 收尾，而不处理具体执行循环。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const { getIntentPrBriefPath } = require('../artifacts');
+const { syncIntentMemory } = require('../intent');
+const { syncDelegationRuntime } = require('../delegation');
+const { isTaskSettledStatus } = require('../lifecycle');
+const { runInit } = require('./init');
+const { runPlanningSnapshot } = require('./snapshot');
+const { runPlan } = require('./plan');
+const { runPreparePr } = require('./prepare-pr');
+const { runVerify } = require('./verify');
+const { runRelease } = require('./release');
+const {
+  normalizeStage,
+  stageIndex,
+  hasUnresolvedTasks,
+  loadState,
+  getApprovalState
+} = require('./autopilot-shared');
+
+function allTasksSettled(manifest) {
+  if (!manifest) {
+    return false;
+  }
+
+  return manifest.tasks.every((task) => isTaskSettledStatus(task.status));
+}
+
+function shouldRunVerify(from, snapshot) {
+  if (!snapshot.manifest || !allTasksSettled(snapshot.manifest)) {
+    return false;
+  }
+
+  return (
+    !snapshot.report ||
+    snapshot.report.overall === 'fail' ||
+    normalizeStage(from) === 'verify' ||
+    normalizeStage(from) === 'document' ||
+    normalizeStage(from) === 'prepare-pr'
+  );
+}
+
+function resolveCompletedStage(snapshot) {
+  if (snapshot.state?.status === 'released') {
+    return 'release';
+  }
+
+  const approval = getApprovalState(snapshot.state, snapshot.manifest);
+
+  if (snapshot.report?.overall === 'pass') {
+    return 'prepare-pr';
+  }
+
+  if (snapshot.manifest && approval.status !== 'approved') {
+    return 'approve';
+  }
+
+  if (snapshot.manifest && hasUnresolvedTasks(snapshot.manifest)) {
+    return 'execute';
+  }
+
+  return snapshot.manifest ? 'verify' : 'converge';
+}
+
+async function runVerificationStage({
+  repoRoot,
+  changeId,
+  from,
+  strict,
+  skipReview,
+  executed,
+  snapshot
+}) {
+  if (!shouldRunVerify(from, snapshot)) {
+    return snapshot;
+  }
+
+  const result = await runVerify({
+    repoRoot,
+    changeId,
+    strict,
+    skipReview
+  });
+  executed.push('verify');
+
+  await syncIntentMemory(repoRoot, changeId, {
+    event: result.overall === 'pass' ? 'autopilot_verify_passed' : 'autopilot_verify_failed',
+    reason: result.overall === 'pass' ? 'Verification passed' : 'Verification produced blocking findings'
+  });
+
+  return loadState(repoRoot, changeId);
+}
+
+async function runPreparePrStage({
+  repoRoot,
+  changeId,
+  fromIndex,
+  executed,
+  snapshot
+}) {
+  if (fromIndex > stageIndex('prepare-pr') || snapshot.report?.overall !== 'pass') {
+    return {
+      snapshot,
+      prBriefPath: snapshot.report?.overall === 'pass' ? getIntentPrBriefPath(repoRoot, changeId) : null
+    };
+  }
+
+  const prepared = await runPreparePr({ repoRoot, changeId });
+  executed.push('prepare-pr');
+
+  return {
+    snapshot: await loadState(repoRoot, changeId),
+    prBriefPath: prepared.prBriefPath
+  };
+}
+
+async function runReleaseStage({
+  repoRoot,
+  changeId,
+  release,
+  executed,
+  snapshot
+}) {
+  if (!release || snapshot.report?.overall !== 'pass') {
+    return snapshot;
+  }
+
+  await runRelease({ repoRoot, changeId });
+  executed.push('release');
+
+  await syncIntentMemory(repoRoot, changeId, {
+    event: 'autopilot_release_completed',
+    reason: 'Release stage completed after successful verification'
+  });
+
+  return loadState(repoRoot, changeId);
+}
+
+async function runDiscoverStage({
+  repoRoot,
+  changeId,
+  goal,
+  fromIndex,
+  executed,
+  snapshot
+}) {
+  if (fromIndex > stageIndex('discover') && snapshot.state) {
+    return snapshot;
+  }
+
+  if (!snapshot.state) {
+    await runInit({ repoRoot, changeId, goal });
+    executed.push('init');
+  }
+
+  await runPlanningSnapshot({ repoRoot, changeId, goal });
+  executed.push('snapshot');
+
+  await syncIntentMemory(repoRoot, changeId, {
+    event: 'autopilot_discover_completed',
+    reason: 'Requirement state and planning snapshot are ready'
+  });
+
+  return loadState(repoRoot, changeId);
+}
+
+async function runConvergeStage({
+  repoRoot,
+  changeId,
+  goal,
+  fromIndex,
+  overwrite,
+  executed,
+  snapshot
+}) {
+  if (fromIndex > stageIndex('converge') && snapshot.manifest && !overwrite) {
+    return snapshot;
+  }
+
+  const plannedFresh = !snapshot.manifest || overwrite;
+  if (!snapshot.manifest || overwrite) {
+    await runPlan({ repoRoot, changeId, goal, overwrite });
+    executed.push('plan');
+  }
+
+  await syncIntentMemory(repoRoot, changeId, {
+    event: 'autopilot_converge_completed',
+    reason: plannedFresh ? 'Execution plan is ready and waiting for approval' : 'Plan already existed and was reused'
+  });
+
+  return loadState(repoRoot, changeId);
+}
+
+async function runApprovalStage({
+  repoRoot,
+  changeId,
+  fromIndex,
+  executed,
+  snapshot
+}) {
+  if (!snapshot.manifest) {
+    return {
+      snapshot,
+      shouldStop: false
+    };
+  }
+
+  const approval = getApprovalState(snapshot.state, snapshot.manifest);
+  if (approval.status !== 'approved') {
+    await syncIntentMemory(repoRoot, changeId, {
+      event: 'autopilot_awaiting_approval',
+      reason: `Plan version ${approval.planVersion || 1} is waiting for explicit approval before execute`
+    });
+
+    return {
+      snapshot: await loadState(repoRoot, changeId),
+      shouldStop: true
+    };
+  }
+
+  if (fromIndex <= stageIndex('approve')) {
+    executed.push('approve');
+  }
+
+  await syncIntentMemory(repoRoot, changeId, {
+    event: 'autopilot_approval_confirmed',
+    reason: `Plan version ${approval.planVersion || 1} approved for ${approval.executionMode} execution`
+  });
+
+  return {
+    snapshot: await loadState(repoRoot, changeId),
+    shouldStop: false
+  };
+}
+
+async function runDelegateStage({
+  repoRoot,
+  changeId,
+  fromIndex,
+  executed,
+  snapshot
+}) {
+  if (fromIndex > stageIndex('delegate')) {
+    return snapshot;
+  }
+
+  const approval = getApprovalState(snapshot.state, snapshot.manifest);
+  if (approval.status !== 'approved') {
+    return snapshot;
+  }
+
+  let delegationSummary = null;
+  if (snapshot.manifest && approval.executionMode !== 'direct') {
+    delegationSummary = await syncDelegationRuntime(repoRoot, changeId, snapshot.manifest, snapshot.state);
+  }
+
+  if (delegationSummary && delegationSummary.delegatedCount > 0) {
+    executed.push('delegate');
+  }
+
+  await syncIntentMemory(repoRoot, changeId, {
+    event: 'autopilot_delegate_completed',
+    reason: approval.executionMode === 'direct'
+      ? 'Approved plan stays in direct mode, so delegation runtime was skipped'
+      : delegationSummary && delegationSummary.delegatedCount > 0
+      ? `Prepared ${delegationSummary.delegatedCount} delegated assignment(s) for local execution`
+      : 'Current plan stays on direct execution'
+  });
+
+  return loadState(repoRoot, changeId);
+}
+
+async function runFinishStages({
+  repoRoot,
+  changeId,
+  from,
+  fromIndex,
+  strict,
+  skipReview,
+  release,
+  executed,
+  snapshot
+}) {
+  let nextSnapshot = snapshot;
+
+  if (fromIndex <= stageIndex('verify')) {
+    nextSnapshot = await runVerificationStage({
+      repoRoot,
+      changeId,
+      from,
+      strict,
+      skipReview,
+      executed,
+      snapshot: nextSnapshot
+    });
+  }
+
+  const preparePrResult = await runPreparePrStage({
+    repoRoot,
+    changeId,
+    fromIndex,
+    executed,
+    snapshot: nextSnapshot
+  });
+  nextSnapshot = preparePrResult.snapshot;
+
+  nextSnapshot = await runReleaseStage({
+    repoRoot,
+    changeId,
+    release,
+    executed,
+    snapshot: nextSnapshot
+  });
+
+  return {
+    snapshot: nextSnapshot,
+    prBriefPath: preparePrResult.prBriefPath
+  };
+}
+
+module.exports = {
+  normalizeStage,
+  stageIndex,
+  hasUnresolvedTasks,
+  loadState,
+  resolveCompletedStage,
+  runDiscoverStage,
+  runConvergeStage,
+  runApprovalStage,
+  runDelegateStage,
+  runFinishStages
+};

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

@@ -0,0 +1,307 @@
+/**
+ * [INPUT]: 依赖 store/intent/delegation 与 dispatch/resume/worker-run，接收执行阶段上下文与 worker 配置。
+ * [OUTPUT]: 对外提供 autopilot 的执行阶段工具与 runner，返回更新后的 snapshot 与 executed。
+ * [POS]: autopilot 的执行层，负责 direct/controller 与 delegated worker 的混合执行循环。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const {
+  readJson,
+  writeJson,
+  getTaskManifestPath
+} = require('../store');
+const { applyManifestExecutionState } = require('../planner');
+const {
+  syncIntentMemory
+} = require('../intent');
+const { findAssignment } = require('../delegation');
+const { runDispatch } = require('./dispatch');
+const { runResume } = require('./resume');
+const { runWorkerCommand } = require('./worker-run');
+const { classifyDelegationMode } = require('../lifecycle');
+const {
+  stageIndex,
+  hasUnresolvedTasks,
+  loadState,
+  isExecutionApproved
+} = require('./autopilot-shared');
+
+function hasDirectUnresolvedTasks(manifest, state = {}) {
+  if (!manifest) {
+    return false;
+  }
+
+  return manifest.tasks.some((task) =>
+    classifyDelegationMode(task, state) === 'direct' &&
+    ['pending', 'running', 'failed'].includes(task.status)
+  );
+}
+
+function dependenciesPassed(task, taskMap) {
+  return task.dependsOn.every((depId) => {
+    const dep = taskMap.get(depId);
+    return dep && dep.status === 'passed';
+  });
+}
+
+function usesWorkerPool(workerProvider, workerCommand) {
+  return Boolean(workerProvider || workerCommand);
+}
+
+function shouldResumeTasks(manifest, executionScope = 'all', state = {}) {
+  if (!manifest) {
+    return false;
+  }
+
+  return manifest.tasks.some((task) => {
+    if (executionScope === 'direct' && classifyDelegationMode(task, state) !== 'direct') {
+      return false;
+    }
+
+    return task.status === 'failed' || task.status === 'running';
+  });
+}
+
+async function requeueDelegatedTasksForResume(repoRoot, changeId, state = {}) {
+  const manifestPath = getTaskManifestPath(repoRoot, changeId);
+  const manifest = await readJson(manifestPath, null);
+  if (!manifest) {
+    return 0;
+  }
+
+  let updated = 0;
+  for (const task of manifest.tasks) {
+    if (classifyDelegationMode(task, state) === 'direct') {
+      continue;
+    }
+
+    if (task.status === 'running' || task.status === 'failed') {
+      task.status = 'pending';
+      updated += 1;
+    }
+  }
+
+  if (updated > 0) {
+    applyManifestExecutionState(manifest, new Date().toISOString());
+    await writeJson(manifestPath, manifest);
+  }
+
+  return updated;
+}
+
+async function runDelegatedAutopilotWorkers({
+  repoRoot,
+  changeId,
+  state,
+  workerProvider,
+  workerProviderArgs,
+  workerCommand
+}) {
+  const manifest = await readJson(getTaskManifestPath(repoRoot, changeId), null);
+  if (!manifest) {
+    return { executedCount: 0 };
+  }
+
+  const taskMap = new Map(manifest.tasks.map((task) => [task.id, task]));
+  const readyDelegatedTasks = manifest.tasks.filter((task) =>
+    classifyDelegationMode(task, state || {}) !== 'direct' &&
+    task.status === 'pending' &&
+    dependenciesPassed(task, taskMap)
+  );
+
+  let executedCount = 0;
+
+  for (const task of readyDelegatedTasks) {
+    const assignment = await findAssignment(repoRoot, changeId, task.id);
+    if (!assignment) {
+      continue;
+    }
+
+    await runWorkerCommand({
+      repoRoot,
+      changeId,
+      workerId: assignment.workerId,
+      taskId: task.id,
+      provider: workerProvider,
+      providerArgs: workerProviderArgs,
+      command: workerCommand
+    });
+    executedCount += 1;
+  }
+
+  return { executedCount };
+}
+
+async function runControllerExecutionPass({
+  repoRoot,
+  changeId,
+  manifest,
+  parallel,
+  maxRetries,
+  resume,
+  state,
+  executionScope = 'all'
+}) {
+  const shouldResume = resume || shouldResumeTasks(manifest, executionScope, state);
+  const command = shouldResume ? 'resume' : 'dispatch';
+  const runnerArgs = {
+    repoRoot,
+    changeId,
+    parallel,
+    maxRetries
+  };
+
+  if (executionScope === 'direct') {
+    runnerArgs.executionScope = 'direct';
+  }
+
+  const result = shouldResume
+    ? await runResume(runnerArgs)
+    : await runDispatch(runnerArgs);
+
+  await syncIntentMemory(repoRoot, changeId, {
+    event: shouldResume ? 'autopilot_resume_completed' : 'autopilot_execute_completed',
+    reason: result.success
+      ? (executionScope === 'direct'
+        ? 'Controller execution completed current direct frontier'
+        : 'Execution stage completed without unresolved tasks')
+      : result.reason || 'Execution stopped with unresolved tasks'
+  });
+
+  return {
+    command,
+    snapshot: await loadState(repoRoot, changeId)
+  };
+}
+
+async function runHybridExecutionStage({
+  repoRoot,
+  changeId,
+  snapshot,
+  executed,
+  parallel,
+  maxRetries,
+  resume,
+  workerProvider,
+  workerProviderArgs,
+  workerCommand
+}) {
+  let nextSnapshot = snapshot;
+  let workerResumeApplied = !resume;
+  let executedWorkerPool = false;
+
+  while (nextSnapshot.manifest && hasUnresolvedTasks(nextSnapshot.manifest)) {
+    let progressed = false;
+
+    if (!workerResumeApplied) {
+      const requeued = await requeueDelegatedTasksForResume(repoRoot, changeId, nextSnapshot.state);
+      workerResumeApplied = true;
+
+      if (requeued > 0) {
+        progressed = true;
+        nextSnapshot = await loadState(repoRoot, changeId);
+      }
+    }
+
+    const workerResult = await runDelegatedAutopilotWorkers({
+      repoRoot,
+      changeId,
+      state: nextSnapshot.state,
+      workerProvider,
+      workerProviderArgs,
+      workerCommand
+    });
+
+    if (workerResult.executedCount > 0) {
+      executedWorkerPool = true;
+      progressed = true;
+      nextSnapshot = await loadState(repoRoot, changeId);
+    }
+
+    if (nextSnapshot.manifest && hasDirectUnresolvedTasks(nextSnapshot.manifest, nextSnapshot.state)) {
+      const controllerPass = await runControllerExecutionPass({
+        repoRoot,
+        changeId,
+        manifest: nextSnapshot.manifest,
+        parallel,
+        maxRetries,
+        resume,
+        state: nextSnapshot.state,
+        executionScope: 'direct'
+      });
+
+      executed.push(controllerPass.command);
+      nextSnapshot = controllerPass.snapshot;
+      progressed = true;
+    }
+
+    if (!progressed) {
+      break;
+    }
+  }
+
+  if (executedWorkerPool) {
+    executed.push('worker-run');
+    await syncIntentMemory(repoRoot, changeId, {
+      event: 'autopilot_worker_pool_completed',
+      reason: `Delegated worker pool executed via ${workerProvider || 'custom-command'}`
+    });
+    nextSnapshot = await loadState(repoRoot, changeId);
+  }
+
+  return nextSnapshot;
+}
+
+async function runExecutionStage({
+  repoRoot,
+  changeId,
+  fromIndex,
+  snapshot,
+  executed,
+  parallel,
+  maxRetries,
+  resume,
+  workerProvider,
+  workerProviderArgs,
+  workerCommand
+}) {
+  if (fromIndex > stageIndex('execute') || !snapshot.manifest || !hasUnresolvedTasks(snapshot.manifest)) {
+    return snapshot;
+  }
+
+  if (!isExecutionApproved(snapshot.state, snapshot.manifest)) {
+    return snapshot;
+  }
+
+  if (usesWorkerPool(workerProvider, workerCommand)) {
+    return runHybridExecutionStage({
+      repoRoot,
+      changeId,
+      snapshot,
+      executed,
+      parallel,
+      maxRetries,
+      resume,
+      workerProvider,
+      workerProviderArgs,
+      workerCommand
+    });
+  }
+
+  const controllerPass = await runControllerExecutionPass({
+    repoRoot,
+    changeId,
+    manifest: snapshot.manifest,
+    parallel,
+    maxRetries,
+    resume,
+    state: snapshot.state
+  });
+
+  executed.push(controllerPass.command);
+  return controllerPass.snapshot;
+}
+
+module.exports = {
+  runExecutionStage
+};

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

@@ -0,0 +1,48 @@
+/**
+ * [INPUT]: 依赖 store 提供的 requirement 状态读取能力，接收阶段名与 repo/change 标识。
+ * [OUTPUT]: 对外提供 autopilot 共享阶段工具、approval 判定与 snapshot 读取函数。
+ * [POS]: autopilot 的共享基础层，被 core 与 execution 共同复用，避免跨层互相借实现。
+ * [PROTOCOL]: 变更时更新此头部，然后检查 CLAUDE.md
+ */
+
+const {
+  readJson,
+  getRuntimeStatePath,
+  getTaskManifestPath,
+  getReportCardPath
+} = require('../store');
+const {
+  normalizeStage,
+  stageIndex,
+  getApprovalState,
+  isExecutionApproved
+} = require('../lifecycle');
+
+function hasUnresolvedTasks(manifest) {
+  if (!manifest) {
+    return false;
+  }
+
+  return manifest.tasks.some((task) =>
+    ['pending', 'running', 'failed'].includes(task.status)
+  );
+}
+
+async function loadState(repoRoot, changeId) {
+  const [state, manifest, report] = await Promise.all([
+    readJson(getRuntimeStatePath(repoRoot, changeId), null),
+    readJson(getTaskManifestPath(repoRoot, changeId), null),
+    readJson(getReportCardPath(repoRoot, changeId), null)
+  ]);
+
+  return { state, manifest, report };
+}
+
+module.exports = {
+  normalizeStage,
+  stageIndex,
+  hasUnresolvedTasks,
+  loadState,
+  getApprovalState,
+  isExecutionApproved
+};