cc-devflow 4.5.10 → 4.5.12

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

@@ -1,337 +0,0 @@
-/**
- * [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

@@ -1,307 +0,0 @@
-/**
- * [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

@@ -1,48 +0,0 @@
-/**
- * [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, options = {}) {
-  const [state, manifest, report] = await Promise.all([
-    readJson(getRuntimeStatePath(repoRoot, changeId, options), null),
-    readJson(getTaskManifestPath(repoRoot, changeId, options), null),
-    readJson(getReportCardPath(repoRoot, changeId, options), null)
-  ]);
-
-  return { state, manifest, report };
-}
-
-module.exports = {
-  normalizeStage,
-  stageIndex,
-  hasUnresolvedTasks,
-  loadState,
-  getApprovalState,
-  isExecutionApproved
-};