scene-capability-engine 3.6.32 → 3.6.36

package/lib/auto/observability-service.js

@@ -0,0 +1,132 @@
+async function buildAutoObservabilitySnapshot(projectPath, options = {}, dependencies = {}) {
+  const {
+    normalizeStatsWindowDays,
+    normalizeStatusFilter,
+    statsCloseLoopSessions,
+    statsCloseLoopBatchSummarySessions,
+    statsCloseLoopControllerSessions,
+    statsGovernanceCloseLoopSessions,
+    buildAutoGovernanceStats,
+    buildAutoKpiTrend,
+    calculatePercent,
+    schemaVersion,
+    now = () => new Date().toISOString()
+  } = dependencies;
+
+  const days = normalizeStatsWindowDays(options.days);
+  const statusFilter = normalizeStatusFilter(options.status);
+  const normalizedStatsOptions = {
+    days,
+    status: statusFilter.length > 0 ? statusFilter.join(',') : undefined
+  };
+  const normalizedTrendOptions = {
+    weeks: options.weeks,
+    mode: options.trendMode,
+    period: options.trendPeriod
+  };
+
+  const [
+    sessionStats,
+    batchStats,
+    controllerStats,
+    governanceSessionStats,
+    governanceHealth,
+    trend
+  ] = await Promise.all([
+    statsCloseLoopSessions(projectPath, normalizedStatsOptions),
+    statsCloseLoopBatchSummarySessions(projectPath, normalizedStatsOptions),
+    statsCloseLoopControllerSessions(projectPath, normalizedStatsOptions),
+    statsGovernanceCloseLoopSessions(projectPath, normalizedStatsOptions),
+    buildAutoGovernanceStats(projectPath, normalizedStatsOptions),
+    buildAutoKpiTrend(projectPath, normalizedTrendOptions)
+  ]);
+
+  const totalSessions =
+    (Number(sessionStats.total_sessions) || 0) +
+    (Number(batchStats.total_sessions) || 0) +
+    (Number(controllerStats.total_sessions) || 0) +
+    (Number(governanceSessionStats.total_sessions) || 0);
+  const completedSessions =
+    (Number(sessionStats.completed_sessions) || 0) +
+    (Number(batchStats.completed_sessions) || 0) +
+    (Number(controllerStats.completed_sessions) || 0) +
+    (Number(governanceSessionStats.completed_sessions) || 0);
+  const failedSessions =
+    (Number(sessionStats.failed_sessions) || 0) +
+    (Number(batchStats.failed_sessions) || 0) +
+    (Number(controllerStats.failed_sessions) || 0) +
+    (Number(governanceSessionStats.failed_sessions) || 0);
+  const governanceWeeklyOpsStop = governanceSessionStats &&
+    governanceSessionStats.release_gate &&
+    governanceSessionStats.release_gate.weekly_ops_stop &&
+    typeof governanceSessionStats.release_gate.weekly_ops_stop === 'object'
+    ? governanceSessionStats.release_gate.weekly_ops_stop
+    : null;
+
+  return {
+    mode: 'auto-observability-snapshot',
+    generated_at: now(),
+    schema_version: schemaVersion,
+    criteria: {
+      days,
+      status_filter: statusFilter,
+      trend_weeks: trend.weeks,
+      trend_mode: trend.mode,
+      trend_period: trend.period_unit
+    },
+    highlights: {
+      total_sessions: totalSessions,
+      completed_sessions: completedSessions,
+      failed_sessions: failedSessions,
+      completion_rate_percent: calculatePercent(completedSessions, totalSessions),
+      failure_rate_percent: calculatePercent(failedSessions, totalSessions),
+      governance_risk_level: governanceHealth && governanceHealth.health
+        ? governanceHealth.health.risk_level
+        : 'unknown',
+      governance_weekly_ops_stop_sessions: Number(
+        governanceWeeklyOpsStop && governanceWeeklyOpsStop.sessions
+      ) || 0,
+      governance_weekly_ops_stop_session_rate_percent: Number(
+        governanceWeeklyOpsStop && governanceWeeklyOpsStop.session_rate_percent
+      ) || 0,
+      governance_weekly_ops_high_pressure_sessions: Number(
+        governanceWeeklyOpsStop && governanceWeeklyOpsStop.high_pressure_sessions
+      ) || 0,
+      governance_weekly_ops_high_pressure_rate_percent: Number(
+        governanceWeeklyOpsStop && governanceWeeklyOpsStop.high_pressure_session_rate_percent
+      ) || 0,
+      governance_weekly_ops_config_warning_positive_sessions: Number(
+        governanceWeeklyOpsStop && governanceWeeklyOpsStop.config_warning_positive_sessions
+      ) || 0,
+      governance_weekly_ops_auth_tier_pressure_sessions: Number(
+        governanceWeeklyOpsStop && governanceWeeklyOpsStop.auth_tier_pressure_sessions
+      ) || 0,
+      governance_weekly_ops_dialogue_authorization_pressure_sessions: Number(
+        governanceWeeklyOpsStop && governanceWeeklyOpsStop.dialogue_authorization_pressure_sessions
+      ) || 0,
+      governance_weekly_ops_runtime_block_rate_high_sessions: Number(
+        governanceWeeklyOpsStop && governanceWeeklyOpsStop.runtime_block_rate_high_sessions
+      ) || 0,
+      governance_weekly_ops_runtime_ui_mode_violation_high_sessions: Number(
+        governanceWeeklyOpsStop && governanceWeeklyOpsStop.runtime_ui_mode_violation_high_sessions
+      ) || 0,
+      governance_weekly_ops_runtime_ui_mode_violation_total_sum: Number(
+        governanceWeeklyOpsStop && governanceWeeklyOpsStop.runtime_ui_mode_violation_total_sum
+      ) || 0,
+      kpi_anomaly_count: Array.isArray(trend.anomalies) ? trend.anomalies.length : 0
+    },
+    snapshots: {
+      close_loop_session: sessionStats,
+      batch_session: batchStats,
+      controller_session: controllerStats,
+      governance_session: governanceSessionStats,
+      governance_weekly_ops_stop: governanceWeeklyOpsStop,
+      governance_health: governanceHealth,
+      kpi_trend: trend
+    }
+  };
+}
+
+module.exports = {
+  buildAutoObservabilitySnapshot
+};

package/lib/auto/output-writer.js

@@ -0,0 +1,34 @@
+async function maybeWriteOutput(result, outCandidate, projectPath, dependencies = {}) {
+  const pathModule = dependencies.pathModule;
+  const fs = dependencies.fs;
+  if (!outCandidate) {
+    return;
+  }
+
+  const outputPath = pathModule.isAbsolute(outCandidate)
+    ? outCandidate
+    : pathModule.join(projectPath, outCandidate);
+  await fs.ensureDir(pathModule.dirname(outputPath));
+  await fs.writeJson(outputPath, result, { spaces: 2 });
+  result.output_file = outputPath;
+}
+
+async function maybeWriteTextOutput(result, content, outCandidate, projectPath, dependencies = {}) {
+  const pathModule = dependencies.pathModule;
+  const fs = dependencies.fs;
+  if (!outCandidate) {
+    return;
+  }
+
+  const outputPath = pathModule.isAbsolute(outCandidate)
+    ? outCandidate
+    : pathModule.join(projectPath, outCandidate);
+  await fs.ensureDir(pathModule.dirname(outputPath));
+  await fs.writeFile(outputPath, content, 'utf8');
+  result.output_file = outputPath;
+}
+
+module.exports = {
+  maybeWriteOutput,
+  maybeWriteTextOutput
+};

package/lib/auto/program-auto-remediation-service.js

@@ -0,0 +1,130 @@
+async function applyProgramGateAutoRemediation(summary, context = {}, dependencies = {}) {
+  const {
+    collectSpecNamesFromBatchSummary,
+    pruneSpecSessions,
+    readSpecSessionEntries,
+    now = () => new Date().toISOString(),
+    cwd = () => process.cwd()
+  } = dependencies;
+
+  const projectPath = context && context.projectPath ? context.projectPath : cwd();
+  const options = context && context.options && typeof context.options === 'object'
+    ? context.options
+    : {};
+  const gate = summary && summary.program_gate && typeof summary.program_gate === 'object'
+    ? summary.program_gate
+    : null;
+  const policy = gate && gate.policy && typeof gate.policy === 'object' ? gate.policy : {};
+  const reasons = Array.isArray(gate && gate.reasons) ? gate.reasons : [];
+  const actions = [];
+  const nextRunPatch = {};
+
+  const maxAgentBudget = Number(policy.max_agent_budget);
+  if (
+    reasons.some(reason => `${reason || ''}`.includes('agent_budget')) &&
+    Number.isFinite(maxAgentBudget) &&
+    maxAgentBudget > 0
+  ) {
+    const currentAgentBudget = Number(options.batchAgentBudget || (summary && summary.batch_parallel) || 0);
+    nextRunPatch.batchAgentBudget = maxAgentBudget;
+    nextRunPatch.batchParallel = Math.max(1, Math.min(currentAgentBudget || maxAgentBudget, maxAgentBudget));
+    actions.push({
+      type: 'reduce-agent-budget',
+      applied: true,
+      details: `Set batchAgentBudget=${nextRunPatch.batchAgentBudget}, batchParallel=${nextRunPatch.batchParallel}.`
+    });
+  }
+
+  const maxTotalSubSpecs = Number(policy.max_total_sub_specs);
+  if (
+    reasons.some(reason => `${reason || ''}`.includes('total_sub_specs')) &&
+    Number.isFinite(maxTotalSubSpecs) &&
+    maxTotalSubSpecs > 0
+  ) {
+    const avgSubSpecs = Number(summary && summary.metrics && summary.metrics.average_sub_specs_per_goal) || 1;
+    const totalGoals = Number(summary && summary.total_goals) || 2;
+    const suggestedProgramGoals = Math.max(2, Math.min(totalGoals, Math.floor(maxTotalSubSpecs / Math.max(1, avgSubSpecs))));
+    nextRunPatch.programGoals = suggestedProgramGoals;
+    actions.push({
+      type: 'shrink-goal-width',
+      applied: true,
+      details: `Set programGoals=${suggestedProgramGoals} using max_total_sub_specs=${maxTotalSubSpecs}.`
+    });
+  }
+
+  const maxElapsedMinutes = Number(policy.max_elapsed_minutes);
+  if (
+    reasons.some(reason => `${reason || ''}`.includes('program_elapsed_minutes')) &&
+    Number.isFinite(maxElapsedMinutes) &&
+    maxElapsedMinutes > 0
+  ) {
+    const totalGoals = Number(summary && summary.total_goals) || 2;
+    const reducedProgramGoals = Math.max(2, Math.min(totalGoals, Math.ceil(totalGoals * 0.8)));
+    nextRunPatch.programGoals = Math.min(
+      Number(nextRunPatch.programGoals) || reducedProgramGoals,
+      reducedProgramGoals
+    );
+    nextRunPatch.batchRetryRounds = 0;
+    actions.push({
+      type: 'time-budget-constrain',
+      applied: true,
+      details: `Set programGoals=${nextRunPatch.programGoals}, batchRetryRounds=0 for elapsed budget ${maxElapsedMinutes}m.`
+    });
+  }
+
+  let appliedSpecPrune = null;
+  const specBudget = summary && summary.spec_session_budget && summary.spec_session_budget.enabled
+    ? summary.spec_session_budget
+    : null;
+  if (specBudget && specBudget.over_limit_after && Number.isFinite(Number(specBudget.max_total))) {
+    try {
+      const currentRunSpecNames = collectSpecNamesFromBatchSummary(summary || {});
+      appliedSpecPrune = await pruneSpecSessions(projectPath, {
+        keep: Number(specBudget.max_total),
+        olderThanDays: null,
+        dryRun: false,
+        protectActive: true,
+        protectWindowDays: options.specSessionProtectWindowDays,
+        additionalProtectedSpecs: currentRunSpecNames
+      });
+      summary.spec_session_auto_prune = appliedSpecPrune;
+      const specsAfter = await readSpecSessionEntries(projectPath);
+      const totalAfter = specsAfter.length;
+      const prunedCount = Number(appliedSpecPrune && appliedSpecPrune.deleted_count) || 0;
+      summary.spec_session_budget = {
+        ...specBudget,
+        total_after: totalAfter,
+        pruned_count: (Number(specBudget.pruned_count) || 0) + prunedCount,
+        estimated_created: Math.max(0, totalAfter + ((Number(specBudget.pruned_count) || 0) + prunedCount) - specBudget.total_before),
+        over_limit_after: totalAfter > specBudget.max_total,
+        hard_fail_triggered: Boolean(specBudget.hard_fail && totalAfter > specBudget.max_total)
+      };
+      actions.push({
+        type: 'trigger-spec-prune',
+        applied: true,
+        details: `Pruned specs to enforce max_total=${specBudget.max_total}. deleted=${appliedSpecPrune.deleted_count}`
+      });
+    } catch (error) {
+      actions.push({
+        type: 'trigger-spec-prune',
+        applied: false,
+        error: error.message
+      });
+    }
+  }
+
+  const hasPatch = Object.keys(nextRunPatch).length > 0;
+  return {
+    enabled: true,
+    attempted_at: now(),
+    reason_count: reasons.length,
+    reasons,
+    actions,
+    next_run_patch: hasPatch ? nextRunPatch : null,
+    applied_spec_prune: appliedSpecPrune
+  };
+}
+
+module.exports = {
+  applyProgramGateAutoRemediation
+};

package/lib/auto/program-diagnostics.js

@@ -0,0 +1,138 @@
+function buildProgramFailureClusters(results = [], normalizeFailureSignatureFromError = (value) => String(value || 'unknown')) {
+  const failedStatuses = new Set(['failed', 'error', 'unknown', 'stopped']);
+  const source = Array.isArray(results) ? results : [];
+  const clusters = new Map();
+
+  for (const item of source) {
+    if (!item || typeof item !== 'object') {
+      continue;
+    }
+    const status = String(item.status || 'unknown').trim().toLowerCase();
+    if (!failedStatuses.has(status)) {
+      continue;
+    }
+
+    const signatureSeed = normalizeFailureSignatureFromError(item.error);
+    const signature = status + ':' + signatureSeed;
+    if (!clusters.has(signature)) {
+      clusters.set(signature, {
+        signature,
+        status,
+        count: 0,
+        goal_indexes: [],
+        example_goal: item.goal || null,
+        example_error: item.error || null
+      });
+    }
+
+    const cluster = clusters.get(signature);
+    cluster.count += 1;
+    const sourceIndex = Number.isInteger(item.source_index) ? item.source_index + 1 : Number(item.index);
+    if (Number.isInteger(sourceIndex) && sourceIndex > 0) {
+      cluster.goal_indexes.push(sourceIndex);
+    }
+  }
+
+  return [...clusters.values()]
+    .sort((left, right) => {
+      if (right.count !== left.count) {
+        return right.count - left.count;
+      }
+      return String(left.signature).localeCompare(String(right.signature));
+    })
+    .map((cluster) => ({
+      ...cluster,
+      goal_indexes: cluster.goal_indexes.slice(0, 20)
+    }));
+}
+
+function buildProgramRemediationActions(summary, failureClusters) {
+  const failedGoals = Number(summary && summary.failed_goals) || 0;
+  const retry = summary && summary.batch_retry ? summary.batch_retry : {};
+  const actions = [];
+
+  if (failedGoals === 0) {
+    return [{
+      priority: 'monitor',
+      action: 'No remediation required. Program converged successfully.',
+      reason: 'All goals completed in the current run.',
+      suggested_command: null,
+      strategy_patch: {}
+    }];
+  }
+
+  actions.push({
+    priority: 'high',
+    action: 'Resume unresolved goals from latest program/batch summary.',
+    reason: failedGoals + ' goals are unresolved after the current run.',
+    suggested_command: 'sce auto close-loop-recover latest --json',
+    strategy_patch: {
+      batchAutonomous: true,
+      continueOnError: true,
+      batchRetryUntilComplete: true
+    }
+  });
+
+  if ((Number(retry.max_rounds) || 0) > 0 && (Number(retry.performed_rounds) || 0) >= (Number(retry.max_rounds) || 0)) {
+    actions.push({
+      priority: 'high',
+      action: 'Increase retry ceiling or split the program into smaller sub-goal groups.',
+      reason: 'Retry rounds were exhausted before convergence.',
+      suggested_command: 'sce auto close-loop-recover latest --batch-retry-max-rounds 15 --json',
+      strategy_patch: {
+        batchRetryUntilComplete: true,
+        batchRetryMaxRounds: 15
+      }
+    });
+  }
+
+  const failureText = (Array.isArray(failureClusters) ? failureClusters : [])
+    .map((cluster) => String(cluster.signature) + ' ' + (cluster.example_error || ''))
+    .join(' | ')
+    .toLowerCase();
+
+  if (/timeout|timed out|deadline|terminated|killed/.test(failureText)) {
+    actions.push({
+      priority: 'medium',
+      action: 'Reduce parallel pressure and increase orchestration timeout budget.',
+      reason: 'Failure clusters indicate timeout/resource-pressure symptoms.',
+      suggested_command: 'sce auto close-loop-recover latest --batch-parallel 2 --batch-agent-budget 2 --json',
+      strategy_patch: {
+        batchParallel: 2,
+        batchAgentBudget: 2,
+        batchPriority: 'complex-first',
+        batchAgingFactor: 2
+      }
+    });
+  }
+
+  if (/dod|test|validation|checklist|compliance/.test(failureText)) {
+    actions.push({
+      priority: 'medium',
+      action: 'Run strict quality gates early to surface deterministic failures.',
+      reason: 'Failure clusters indicate DoD/test/compliance gate issues.',
+      suggested_command: 'sce auto close-loop-recover latest --dod-tests "npm run test:smoke" --dod-tasks-closed --json',
+      strategy_patch: {
+        dodTests: 'npm run test:smoke',
+        dodTasksClosed: true
+      }
+    });
+  }
+
+  return actions.slice(0, 5);
+}
+
+function buildProgramDiagnostics(summary, normalizeFailureSignatureFromError) {
+  const failureClusters = buildProgramFailureClusters(summary && summary.results, normalizeFailureSignatureFromError);
+  return {
+    failed_goal_count: Number(summary && summary.failed_goals) || 0,
+    failure_clusters: failureClusters,
+    remediation_actions: buildProgramRemediationActions(summary, failureClusters)
+  };
+}
+
+module.exports = {
+  buildProgramFailureClusters,
+  buildProgramRemediationActions,
+  buildProgramDiagnostics
+};