scene-capability-engine 3.6.32 → 3.6.36

package/lib/auto/batch-output.js

@@ -0,0 +1,201 @@
+function printCloseLoopBatchSummary(chalk, summary, options = {}, consoleLike = console) {
+  if (options.json) {
+    consoleLike.log(JSON.stringify(summary, null, 2));
+    return;
+  }
+
+  const title = summary.mode === 'auto-close-loop-program'
+    ? 'Autonomous close-loop program summary'
+    : summary.mode === 'auto-close-loop-recover'
+      ? 'Autonomous close-loop recovery summary'
+      : 'Autonomous close-loop batch summary';
+  consoleLike.log(chalk.blue(title));
+  consoleLike.log(chalk.gray(`  Status: ${summary.status}`));
+  consoleLike.log(chalk.gray(`  Processed: ${summary.processed_goals}/${summary.total_goals}`));
+  consoleLike.log(chalk.gray(`  Completed: ${summary.completed_goals}`));
+  consoleLike.log(chalk.gray(`  Failed: ${summary.failed_goals}`));
+  consoleLike.log(chalk.gray(`  Batch parallel: ${summary.batch_parallel}`));
+  if (summary.autonomous_policy && summary.autonomous_policy.enabled) {
+    consoleLike.log(chalk.gray(`  Autonomous policy: ${summary.autonomous_policy.profile}`));
+  }
+  if (summary.batch_retry && summary.batch_retry.performed_rounds > 0) {
+    consoleLike.log(chalk.gray(
+      `  Batch retry: ${summary.batch_retry.performed_rounds}/${summary.batch_retry.configured_rounds} extra rounds`
+    ));
+  }
+  if (summary.batch_retry && summary.batch_retry.recovery_recommended) {
+    consoleLike.log(chalk.yellow(
+      `  Rate-limit recovery recommended: signals=${summary.batch_retry.total_rate_limit_signals || 0}, ` +
+      `backoff=${summary.batch_retry.total_rate_limit_backoff_ms || 0}ms`
+    ));
+    if (summary.batch_retry.recovery_suggested_command) {
+      consoleLike.log(chalk.yellow(`  Suggested command: ${summary.batch_retry.recovery_suggested_command}`));
+    }
+  }
+  if (summary.resource_plan.agent_budget !== null) {
+    consoleLike.log(chalk.gray(
+      `  Agent budget: ${summary.resource_plan.agent_budget} ` +
+      `(per-goal maxParallel=${summary.resource_plan.per_goal_max_parallel})`
+    ));
+  }
+  consoleLike.log(chalk.gray(`  Success rate: ${summary.metrics.success_rate_percent}%`));
+  if (summary.program_kpi) {
+    consoleLike.log(chalk.gray(
+      `  Program KPI: ${summary.program_kpi.convergence_state}, ` +
+      `risk=${summary.program_kpi.risk_level}, ` +
+      `retry-recovery=${summary.program_kpi.retry_recovery_rate_percent}%`
+    ));
+  }
+  if (summary.program_gate) {
+    consoleLike.log(chalk.gray(
+      `  Program gate: ${summary.program_gate.passed ? 'passed' : 'failed'} ` +
+      `(profile=${summary.program_gate.policy.profile || 'default'}, ` +
+      `min-success=${summary.program_gate.policy.min_success_rate_percent}%, ` +
+      `max-risk=${summary.program_gate.policy.max_risk_level})`
+    ));
+    const gatePolicy = summary.program_gate.policy || {};
+    const gateActual = summary.program_gate.actual || {};
+    if (
+      gatePolicy.max_elapsed_minutes !== null ||
+      gatePolicy.max_agent_budget !== null ||
+      gatePolicy.max_total_sub_specs !== null
+    ) {
+      consoleLike.log(chalk.gray(
+        `  Program budget gate: elapsed=${gateActual.elapsed_minutes ?? 'n/a'}/${gatePolicy.max_elapsed_minutes ?? 'n/a'} min, ` +
+        `agent=${gateActual.agent_budget ?? 'n/a'}/${gatePolicy.max_agent_budget ?? 'n/a'}, ` +
+        `sub-specs=${gateActual.total_sub_specs ?? 'n/a'}/${gatePolicy.max_total_sub_specs ?? 'n/a'}`
+      ));
+    }
+    if (
+      summary.program_gate_effective &&
+      summary.program_gate_effective.source !== 'primary' &&
+      summary.program_gate_effective.fallback_profile
+    ) {
+      consoleLike.log(chalk.gray(
+        `  Program gate fallback accepted: profile=${summary.program_gate_effective.fallback_profile}`
+      ));
+    }
+  }
+  if (
+    summary.program_diagnostics &&
+    Array.isArray(summary.program_diagnostics.remediation_actions) &&
+    summary.program_diagnostics.remediation_actions.length > 0
+  ) {
+    const topAction = summary.program_diagnostics.remediation_actions[0];
+    consoleLike.log(chalk.gray(`  Top remediation: ${topAction.action}`));
+  }
+  if (summary.recovery_cycle && summary.recovery_cycle.enabled) {
+    consoleLike.log(chalk.gray(
+      `  Recovery rounds: ${summary.recovery_cycle.performed_rounds}/${summary.recovery_cycle.max_rounds}`
+    ));
+    if (summary.recovery_cycle.budget_exhausted) {
+      consoleLike.log(chalk.gray('  Recovery time budget exhausted before convergence.'));
+    }
+  }
+  if (summary.auto_recovery && summary.auto_recovery.triggered) {
+    consoleLike.log(chalk.gray(
+      `  Program auto-recovery: ${summary.auto_recovery.recovery_status} ` +
+      `(action ${summary.auto_recovery.selected_action_index || 'n/a'}, ` +
+      `source=${summary.auto_recovery.selection_source || 'default'})`
+    ));
+  }
+  if (summary.program_governance && summary.program_governance.enabled) {
+    consoleLike.log(chalk.gray(
+      `  Program governance: ${summary.program_governance.performed_rounds}/` +
+      `${summary.program_governance.max_rounds} rounds, stop=${summary.program_governance.stop_reason}`
+    ));
+    if (summary.program_governance.action_selection_enabled) {
+      consoleLike.log(chalk.gray(
+        `  Governance action selection: ` +
+        `${summary.program_governance.auto_action_enabled ? 'auto' : 'manual-only'}, ` +
+        `pinned=${summary.program_governance.pinned_action_index || 'none'}`
+      ));
+    }
+    if (Array.isArray(summary.program_governance.history) && summary.program_governance.history.length > 0) {
+      const latestRound = summary.program_governance.history[summary.program_governance.history.length - 1];
+      if (latestRound && latestRound.selected_action) {
+        consoleLike.log(chalk.gray(
+          `  Governance selected action: #${latestRound.selected_action_index || 'n/a'} ${latestRound.selected_action}`
+        ));
+      }
+    }
+    if (summary.program_governance.exhausted) {
+      consoleLike.log(chalk.yellow('  Program governance exhausted before reaching stable state.'));
+    }
+  }
+  if (Array.isArray(summary.program_kpi_anomalies) && summary.program_kpi_anomalies.length > 0) {
+    const highCount = summary.program_kpi_anomalies
+      .filter(item => `${item && item.severity ? item.severity : ''}`.trim().toLowerCase() === 'high')
+      .length;
+    consoleLike.log(chalk.gray(
+      `  Program KPI anomalies: total=${summary.program_kpi_anomalies.length}, high=${highCount}`
+    ));
+  }
+  if (summary.program_coordination) {
+    consoleLike.log(chalk.gray(
+      `  Master/Sub sync: masters=${summary.program_coordination.master_spec_count}, ` +
+      `sub-specs=${summary.program_coordination.sub_spec_count}, ` +
+      `unresolved=${summary.program_coordination.unresolved_goal_count}`
+    ));
+  }
+  if (summary.batch_session && summary.batch_session.file) {
+    consoleLike.log(chalk.gray(`  Batch session: ${summary.batch_session.file}`));
+  }
+  if (summary.goal_input_guard && summary.goal_input_guard.enabled) {
+    consoleLike.log(chalk.gray(
+      `  Goal duplicate guard: duplicates=${summary.goal_input_guard.duplicate_goals}/` +
+      `${summary.goal_input_guard.max_duplicate_goals}`
+    ));
+    if (summary.goal_input_guard.over_limit) {
+      consoleLike.log(chalk.yellow('  Goal duplicate guard exceeded.'));
+    }
+  }
+  if (summary.spec_session_prune && summary.spec_session_prune.enabled) {
+    consoleLike.log(chalk.gray(
+      `  Spec prune: deleted=${summary.spec_session_prune.deleted_count}, ` +
+      `protected=${summary.spec_session_prune.protected_count}`
+    ));
+  }
+  if (summary.spec_session_budget && summary.spec_session_budget.enabled) {
+    consoleLike.log(chalk.gray(
+      `  Spec budget: ${summary.spec_session_budget.total_after}/${summary.spec_session_budget.max_total} ` +
+      `(created~${summary.spec_session_budget.estimated_created}, pruned=${summary.spec_session_budget.pruned_count})`
+    ));
+    if (summary.spec_session_budget.over_limit_after) {
+      consoleLike.log(chalk.yellow(
+        `  Spec budget exceeded (${summary.spec_session_budget.total_after} > ${summary.spec_session_budget.max_total})`
+      ));
+    }
+  }
+  if (summary.spec_session_growth_guard && summary.spec_session_growth_guard.enabled) {
+    consoleLike.log(chalk.gray(
+      `  Spec growth guard: created~${summary.spec_session_growth_guard.estimated_created}` +
+      ` (per-goal=${summary.spec_session_growth_guard.estimated_created_per_goal})`
+    ));
+    if (summary.spec_session_growth_guard.over_limit) {
+      consoleLike.log(chalk.yellow(`  Spec growth guard exceeded: ${summary.spec_session_growth_guard.reasons.join('; ')}`));
+    }
+  }
+  if (summary.program_gate_auto_remediation && summary.program_gate_auto_remediation.enabled) {
+    const autoRemediationActions = Array.isArray(summary.program_gate_auto_remediation.actions)
+      ? summary.program_gate_auto_remediation.actions
+      : [];
+    consoleLike.log(chalk.gray(
+      `  Program auto-remediation: actions=${autoRemediationActions.length}, ` +
+      `next-patch=${summary.program_gate_auto_remediation.next_run_patch ? 'yes' : 'no'}`
+    ));
+  }
+  if (summary.program_kpi_file) {
+    consoleLike.log(chalk.gray(`  Program KPI file: ${summary.program_kpi_file}`));
+  }
+  if (summary.program_audit_file) {
+    consoleLike.log(chalk.gray(`  Program audit file: ${summary.program_audit_file}`));
+  }
+  if (summary.output_file) {
+    consoleLike.log(chalk.gray(`  Output: ${summary.output_file}`));
+  }
+}
+
+module.exports = {
+  printCloseLoopBatchSummary
+};

package/lib/auto/batch-summary-storage-service.js

@@ -0,0 +1,110 @@
+const path = require('path');
+
+function getCloseLoopBatchSummaryDir(projectPath) {
+  return path.join(projectPath, '.sce', 'auto', 'close-loop-batch-summaries');
+}
+
+async function readCloseLoopBatchSummaryEntries(projectPath, dependencies = {}) {
+  const { fs } = dependencies;
+  const summaryDir = getCloseLoopBatchSummaryDir(projectPath);
+  if (!(await fs.pathExists(summaryDir))) {
+    return [];
+  }
+
+  const files = (await fs.readdir(summaryDir)).filter((item) => item.toLowerCase().endsWith('.json'));
+  const sessions = [];
+  for (const file of files) {
+    const filePath = path.join(summaryDir, file);
+    const stats = await fs.stat(filePath);
+    const fallbackTimestamp = new Date(stats.mtimeMs).toISOString();
+    const fallbackId = path.basename(file, '.json');
+    let payload = null;
+    let parseError = null;
+
+    try {
+      payload = await fs.readJson(filePath);
+    } catch (error) {
+      parseError = error;
+    }
+
+    sessions.push({
+      id: payload && typeof payload.batch_session === 'object' && typeof payload.batch_session.id === 'string'
+        ? payload.batch_session.id
+        : fallbackId,
+      file: filePath,
+      status: payload && typeof payload.status === 'string'
+        ? payload.status
+        : parseError
+          ? 'invalid'
+          : 'unknown',
+      goals_file: payload && typeof payload.goals_file === 'string' ? payload.goals_file : null,
+      total_goals: payload && Number.isInteger(Number(payload.total_goals)) ? Number(payload.total_goals) : null,
+      processed_goals: payload && Number.isInteger(Number(payload.processed_goals)) ? Number(payload.processed_goals) : null,
+      updated_at: payload && typeof payload.updated_at === 'string' ? payload.updated_at : fallbackTimestamp,
+      parse_error: parseError ? parseError.message : null,
+      mtime_ms: stats.mtimeMs
+    });
+  }
+
+  sessions.sort((a, b) => b.mtime_ms - a.mtime_ms);
+  return sessions;
+}
+
+async function resolveCloseLoopBatchSummaryFile(projectPath, summaryCandidate, dependencies = {}) {
+  const { fs } = dependencies;
+  if (typeof summaryCandidate !== 'string' || !summaryCandidate.trim()) {
+    throw new Error('--resume-from-summary requires a file path or "latest".');
+  }
+
+  const normalizedCandidate = summaryCandidate.trim();
+  if (normalizedCandidate.toLowerCase() === 'latest') {
+    const summaryDir = getCloseLoopBatchSummaryDir(projectPath);
+    if (!(await fs.pathExists(summaryDir))) {
+      throw new Error(`No batch summary sessions found in: ${summaryDir}`);
+    }
+    const candidates = (await fs.readdir(summaryDir)).filter((item) => item.toLowerCase().endsWith('.json'));
+    if (candidates.length === 0) {
+      throw new Error(`No batch summary sessions found in: ${summaryDir}`);
+    }
+    const entries = [];
+    for (const file of candidates) {
+      const filePath = path.join(summaryDir, file);
+      const stats = await fs.stat(filePath);
+      entries.push({ file: filePath, mtimeMs: stats.mtimeMs });
+    }
+    entries.sort((a, b) => b.mtimeMs - a.mtimeMs);
+    return entries[0].file;
+  }
+
+  return path.isAbsolute(normalizedCandidate)
+    ? normalizedCandidate
+    : path.join(projectPath, normalizedCandidate);
+}
+
+async function loadCloseLoopBatchSummaryPayload(projectPath, summaryCandidate, dependencies = {}) {
+  const { fs } = dependencies;
+  const summaryFile = await resolveCloseLoopBatchSummaryFile(projectPath, summaryCandidate, dependencies);
+  if (!(await fs.pathExists(summaryFile))) {
+    throw new Error(`Batch summary file not found: ${summaryFile}`);
+  }
+
+  let payload = null;
+  try {
+    payload = await fs.readJson(summaryFile);
+  } catch (error) {
+    throw new Error(`Invalid batch summary JSON: ${summaryFile} (${error.message})`);
+  }
+
+  if (!payload || typeof payload !== 'object') {
+    throw new Error(`Invalid batch summary payload: ${summaryFile}`);
+  }
+
+  return { file: summaryFile, payload };
+}
+
+module.exports = {
+  getCloseLoopBatchSummaryDir,
+  readCloseLoopBatchSummaryEntries,
+  resolveCloseLoopBatchSummaryFile,
+  loadCloseLoopBatchSummaryPayload
+};

package/lib/auto/close-loop-batch-service.js

@@ -0,0 +1,116 @@
+async function executeCloseLoopBatch(goalsResult, options, projectPath, mode = 'auto-close-loop-batch', dependencies = {}) {
+  const {
+    buildGoalInputGuard,
+    startSpecSessionBudgetEvaluation,
+    resolveBatchAutonomousPolicy,
+    normalizeBatchParallel,
+    runCloseLoopBatchWithRetries,
+    buildBatchRunOptions,
+    buildBatchMetrics,
+    collectSpecNamesFromBatchSummary,
+    maybePruneSpecSessionsWithPolicy,
+    finalizeSpecSessionBudgetEvaluation,
+    buildSpecSessionGrowthGuard,
+    buildProgramKpiSnapshot,
+    buildProgramDiagnostics,
+    buildProgramCoordinationSnapshot,
+    maybeWriteProgramKpi,
+    maybePersistCloseLoopBatchSummary,
+    maybeWriteOutput
+  } = dependencies;
+
+  const goalInputGuard = buildGoalInputGuard(goalsResult && goalsResult.goals, options);
+  if (goalInputGuard.over_limit && goalInputGuard.hard_fail_triggered) {
+    throw new Error(
+      `Goal input duplicate guard exceeded: ${goalInputGuard.duplicate_goals} > ${goalInputGuard.max_duplicate_goals}. ` +
+      'Reduce duplicated goals or raise --spec-session-max-duplicate-goals.'
+    );
+  }
+
+  const specSessionBudget = await startSpecSessionBudgetEvaluation(projectPath, options);
+  if (specSessionBudget && specSessionBudget.hard_fail && specSessionBudget.over_limit_before) {
+    throw new Error(
+      `Spec session budget exceeded before run: ${specSessionBudget.total_before} > ${specSessionBudget.max_total}. ` +
+      'Run "sce auto spec-session prune ..." or raise --spec-session-max-total.'
+    );
+  }
+
+  const batchAutonomousPolicy = resolveBatchAutonomousPolicy(options, goalsResult.goals.length);
+  const effectiveBatchOptions = batchAutonomousPolicy.options;
+  const batchParallel = normalizeBatchParallel(effectiveBatchOptions.batchParallel);
+  const batchRun = await runCloseLoopBatchWithRetries(goalsResult.goals, {
+    projectPath,
+    continueOnError: Boolean(effectiveBatchOptions.continueOnError),
+    batchParallel,
+    batchAgentBudget: effectiveBatchOptions.batchAgentBudget,
+    batchPriority: effectiveBatchOptions.batchPriority,
+    batchAgingFactor: effectiveBatchOptions.batchAgingFactor,
+    batchRetryRounds: effectiveBatchOptions.batchRetryRounds,
+    batchRetryStrategy: effectiveBatchOptions.batchRetryStrategy,
+    batchRetryUntilComplete: effectiveBatchOptions.batchRetryUntilComplete,
+    batchRetryMaxRounds: effectiveBatchOptions.batchRetryMaxRounds,
+    goalEntries: Array.isArray(goalsResult.goal_entries) ? goalsResult.goal_entries : null,
+    runOptions: buildBatchRunOptions(effectiveBatchOptions)
+  });
+
+  const results = batchRun.results;
+  const stoppedEarly = batchRun.stoppedEarly;
+  const failedStatuses = new Set(['failed', 'error', 'unknown', 'stopped']);
+  const failedGoals = results.filter(item => failedStatuses.has(item.status)).length;
+  const completedGoals = results.length - failedGoals;
+  const status = failedGoals === 0
+    ? 'completed'
+    : completedGoals === 0
+      ? 'failed'
+      : 'partial-failed';
+  const metrics = buildBatchMetrics(results, goalsResult.goals.length);
+
+  const summary = {
+    mode,
+    status,
+    goals_file: goalsResult.file,
+    resumed_from_summary: goalsResult.resumedFromSummary || null,
+    generated_from_goal: goalsResult.generatedFromGoal || null,
+    total_goals: goalsResult.goals.length,
+    processed_goals: results.length,
+    completed_goals: completedGoals,
+    failed_goals: failedGoals,
+    batch_parallel: batchRun.effectiveParallel,
+    autonomous_policy: batchAutonomousPolicy.summary,
+    resource_plan: batchRun.resourcePlan,
+    batch_retry: batchRun.retry,
+    stopped_early: stoppedEarly,
+    metrics,
+    goal_input_guard: goalInputGuard,
+    results
+  };
+
+  const currentRunSpecNames = collectSpecNamesFromBatchSummary(summary);
+  summary.spec_session_prune = await maybePruneSpecSessionsWithPolicy(
+    projectPath,
+    options,
+    currentRunSpecNames
+  );
+  summary.spec_session_budget = await finalizeSpecSessionBudgetEvaluation(
+    projectPath,
+    specSessionBudget,
+    summary.spec_session_prune
+  );
+  summary.spec_session_growth_guard = buildSpecSessionGrowthGuard(summary, options);
+
+  if (mode === 'auto-close-loop-program' || mode === 'auto-close-loop-recover') {
+    summary.program_kpi = buildProgramKpiSnapshot(summary);
+    summary.program_diagnostics = buildProgramDiagnostics(summary);
+    summary.program_coordination = buildProgramCoordinationSnapshot(summary);
+    await maybeWriteProgramKpi(summary, options.programKpiOut, projectPath);
+  }
+
+  await maybePersistCloseLoopBatchSummary(summary, options, projectPath);
+  await maybeWriteOutput(summary, options.out, projectPath);
+
+  return summary;
+}
+
+module.exports = {
+  executeCloseLoopBatch
+};