kiro-spec-engine 1.47.0 → 1.47.1

package/CHANGELOG.md

@@ -32,6 +32,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **Spec growth/duplicate guardrails**: Added `--spec-session-max-created`, `--spec-session-max-created-per-goal`, and `--spec-session-max-duplicate-goals` (with hard-fail option) plus summary telemetry (`goal_input_guard`, `spec_session_growth_guard`) to reduce runaway autonomous portfolio expansion.
 - **Autonomous KPI trend command**: Added `kse auto kpi trend` to aggregate weekly success/completion, failure, sub-spec, and spec-growth telemetry from persisted autonomous summary sessions.
 - **Autonomous KPI trend period/csv/anomaly enhancement**: Extended `kse auto kpi trend` with `--period week|day`, `--csv` export mode, and JSON anomaly diagnostics (`anomaly_detection`, `anomalies`) for latest-period regression checks.
+- **Program governance stabilization loop**: Added `close-loop-program` governance controls (`--program-govern-until-stable`, `--program-govern-max-rounds`, `--program-govern-max-minutes`, anomaly knobs, `--program-govern-use-action`, `--no-program-govern-auto-action`) so gate/anomaly failures can trigger bounded replay/recover rounds with remediation action execution until stable, with `program_governance`, `program_kpi_trend`, and `program_kpi_anomalies` telemetry.
 - **Close-loop multi-goal batch command**: Added `kse auto close-loop-batch <goals-file>` with file-format autodetect (`json|lines`), `--continue-on-error`, and per-goal summary output so autonomous master/sub execution can scale across multiple goals in one run.
 - **Close-loop batch global scheduler**: Added `--batch-parallel` (`1-20`) to execute multiple goals concurrently in `close-loop-batch`, enabling master/sub portfolios to progress in parallel without manual orchestration handoffs.
 - **Close-loop batch resume from summary**: Added `--resume-from-summary <path>` to recover pending goals from a prior batch run and continue autonomous delivery without rebuilding the entire goal queue manually.

package/README.md

@@ -531,6 +531,7 @@ kse create-spec <name>             # Legacy: create empty Spec folder only
 # Autonomous close-loop program (one command, no confirmation loop)
 kse auto close-loop "<goal>"       # Auto split goal into master/sub specs and execute to closure
 kse auto close-loop "<goal>" --dry-run --json  # Preview decomposition plan only
+kse auto close-loop-program "<goal>" --program-govern-until-stable --program-govern-use-action 1 --json # Program-level recovery + governance with remediation action execution
 
 # Spec workflow (recommended)
 kse spec bootstrap --name <spec> --non-interactive         # Generate requirements/design/tasks draft

package/README.zh.md

@@ -448,6 +448,7 @@ kse create-spec <name>             # 兼容旧版：仅创建空 Spec 目录
 # 自动闭环主从编排（单命令）
 kse auto close-loop "<目标>"        # 自动拆分 Master/Sub Spec 并推进到完成态
 kse auto close-loop "<目标>" --dry-run --json  # 仅预览拆分与依赖计划
+kse auto close-loop-program "<目标>" --program-govern-until-stable --program-govern-use-action 1 --json # 程序级自动恢复 + 治理循环（含 remediation action 执行）直到稳定
 
 # Spec 工作流（推荐）
 kse spec bootstrap --name <spec> --non-interactive          # 生成 requirements/design/tasks 初稿

package/docs/autonomous-control-guide.md

@@ -300,6 +300,15 @@ Close-loop recovery command:
 - `--program-audit-out <path>` exports full recovery/program audit JSON.
 - Output includes `recovered_from_summary`, `recovery_plan` (including `selection_explain`), `recovery_cycle` (with elapsed/budget metadata), and `recovery_memory` (including scope + selection explanation) for full auditability of applied strategy changes.
 
+Program governance loop (for `close-loop-program`):
+- `--program-govern-until-stable` enables bounded post-run governance rounds.
+- `--program-govern-max-rounds <n>` and `--program-govern-max-minutes <n>` bound governance loop cost.
+- `--program-govern-anomaly-weeks <n>` + `--program-govern-anomaly-period <week|day>` make governance anomaly-aware using autonomous KPI trend.
+- `--no-program-govern-anomaly` limits governance trigger to gate/budget failures only.
+- `--program-govern-use-action <n>` pins remediation action index for governance rounds.
+- `--no-program-govern-auto-action` disables automatic remediation action selection/execution inside governance.
+- Output includes `program_governance`, `program_kpi_trend`, and `program_kpi_anomalies` for traceable autonomous stabilization history.
+
 KPI trend command:
 - `kse auto kpi trend --weeks <n> --mode <all|batch|program|recover> --period <week|day> --json` aggregates periodic success/completion, failure, sub-spec, and spec-growth telemetry from persisted autonomous session summaries.
 - Add `--csv` to print/export trend buckets as CSV (`--out` writes CSV when `--csv` is enabled).

package/docs/command-reference.md

@@ -337,6 +337,9 @@ kse auto close-loop-program \
   --program-gate-fallback-profile prod \
   --program-min-success-rate 95 \
   --program-max-risk-level medium \
+  --program-govern-until-stable \
+  --program-govern-max-rounds 3 \
+  --program-govern-use-action 1 \
   --program-kpi-out .kiro/reports/close-loop-program-kpi.json \
   --program-audit-out .kiro/reports/close-loop-program-audit.json \
   --json
@@ -521,6 +524,14 @@ Close-loop program (`kse auto close-loop-program "<goal>"`) options:
 - `--program-max-agent-budget <n>`: convergence gate max allowed agent budget/effective parallel budget (`1-500`)
 - `--program-max-total-sub-specs <n>`: convergence gate max total sub-specs across program goals (`1-500000`)
 - `--no-program-gate-auto-remediate`: disable automatic remediation hints/prune attempts after gate failure
+- `--program-govern-until-stable`: enable post-run governance loop that keeps replaying/recovering until gate/anomaly stability
+- `--program-govern-max-rounds <n>`: max governance rounds (`1-20`, default `3`)
+- `--program-govern-max-minutes <n>`: elapsed-time budget for governance loop (`1-10080`, default `60`)
+- `--program-govern-anomaly-weeks <n>`: KPI lookback weeks for anomaly-triggered governance (`1-260`, default `8`)
+- `--program-govern-anomaly-period <week|day>`: KPI bucket period for anomaly governance checks (default `week`)
+- `--no-program-govern-anomaly`: disable anomaly-triggered governance and only govern by gate/budget failures
+- `--program-govern-use-action <n>`: pin remediation action index (`1-20`) used in governance rounds
+- `--no-program-govern-auto-action`: disable automatic remediation action selection/execution in governance rounds
 - `--program-min-quality-score <n>`: minimum semantic decomposition quality score before automatic refinement (`0-100`, default `70`)
 - `--program-quality-gate`: fail run when final decomposition quality remains below `--program-min-quality-score`
 - `--recovery-memory-scope <scope>`: scope key for recovery memory isolation (default auto: project + git branch)
@@ -530,6 +541,10 @@ Close-loop program (`kse auto close-loop-program "<goal>"`) options:
 - Program summary includes `program_kpi`, `program_gate`, `program_gate_fallbacks`, `program_gate_effective`, and optional `program_kpi_file` / `program_audit_file` for portfolio-level observability pipelines.
   - `program_gate` now supports unified budget checks (success/risk + elapsed time + agent budget + total sub-spec ceiling).
   - On gate/budget failure, summary can include `program_gate_auto_remediation` with auto patch/prune actions.
+- With `--program-govern-until-stable`, summary additionally includes:
+  - `program_governance` (round history, stop reason, exhausted/converged state)
+  - `program_governance` includes action-selection metadata (`auto_action_enabled`, `action_selection_enabled`, `pinned_action_index`, per-round `selected_action*`).
+  - `program_kpi_trend` and `program_kpi_anomalies` (anomaly-aware governance context)
 - Program summary includes `program_diagnostics` with `failure_clusters` and `remediation_actions` (prioritized follow-up commands for convergence).
 - Program summary includes `program_coordination` (master/sub topology, unresolved goal indexes, scheduler snapshot) and `auto_recovery` metadata.
 

package/lib/commands/auto.js

@@ -416,6 +416,14 @@ function registerAutoCommands(program) {
     .option('--program-max-agent-budget <n>', 'Program convergence gate: maximum allowed agent budget/effective parallel budget', parseInt)
     .option('--program-max-total-sub-specs <n>', 'Program convergence gate: maximum total sub-specs generated across program goals', parseInt)
     .option('--no-program-gate-auto-remediate', 'Disable automatic remediation patch/prune suggestions after gate failure')
+    .option('--program-govern-until-stable', 'Enable post-run governance loop until gate/anomaly stability is reached')
+    .option('--program-govern-max-rounds <n>', 'Max governance rounds when --program-govern-until-stable is enabled (default: 3)', parseInt)
+    .option('--program-govern-max-minutes <n>', 'Max elapsed minutes for governance loop (default: 60)', parseInt)
+    .option('--program-govern-anomaly-weeks <n>', 'KPI trend lookback weeks for governance anomaly checks (default: 8)', parseInt)
+    .option('--program-govern-anomaly-period <period>', 'KPI trend period for governance anomaly checks: week|day', 'week')
+    .option('--no-program-govern-anomaly', 'Disable anomaly-triggered governance decisions (gate-only)')
+    .option('--program-govern-use-action <n>', 'Pinned remediation action index used by governance rounds (default: memory/default)', parseInt)
+    .option('--no-program-govern-auto-action', 'Disable automatic remediation action selection/execution inside governance loop')
     .option('--recovery-memory-scope <scope>', 'Recovery memory scope key (default: auto: project + git branch)')
     .option('--program-audit-out <path>', 'Write program audit JSON with recovery and coordination trace')
     .option('--program-kpi-out <path>', 'Write program KPI snapshot JSON to file')
@@ -429,6 +437,14 @@ function registerAutoCommands(program) {
         const programRecoverMaxRounds = normalizeRecoverMaxRounds(options.programRecoverMaxRounds);
         const programRecoverMaxMinutes = normalizeRecoverMaxMinutes(options.programRecoverMaxMinutes, '--program-recover-max-minutes');
         const programRecoverResumeStrategy = normalizeResumeStrategy(options.programRecoverResumeStrategy);
+        const programGovernUntilStable = Boolean(options.programGovernUntilStable);
+        const programGovernMaxRounds = normalizeProgramGovernMaxRounds(options.programGovernMaxRounds);
+        const programGovernMaxMinutes = normalizeProgramGovernMaxMinutes(options.programGovernMaxMinutes);
+        const programGovernAnomalyEnabled = options.programGovernAnomaly !== false;
+        const programGovernAnomalyWeeks = normalizeProgramGovernAnomalyWeeks(options.programGovernAnomalyWeeks);
+        const programGovernAnomalyPeriod = normalizeAutoKpiTrendPeriod(options.programGovernAnomalyPeriod);
+        const programGovernUseAction = normalizeProgramGovernUseAction(options.programGovernUseAction);
+        const programGovernAutoActionEnabled = options.programGovernAutoAction !== false;
         const programGatePolicy = resolveProgramGatePolicy({
           profile: options.programGateProfile,
           minSuccessRate: options.programMinSuccessRate,
@@ -559,60 +575,70 @@ function registerAutoCommands(program) {
         summary.program_completed_at = new Date(programCompletedAt).toISOString();
         summary.program_elapsed_ms = Math.max(0, programCompletedAt - programStartedAt);
 
-        summary.program_gate = evaluateProgramConvergenceGate(summary, {
-          profile: programGatePolicy.profile,
-          minSuccessRate: programGatePolicy.minSuccessRate,
-          maxRiskLevel: programGatePolicy.maxRiskLevel,
-          maxElapsedMinutes: programGatePolicy.maxElapsedMinutes,
-          maxAgentBudget: programGatePolicy.maxAgentBudget,
-          maxTotalSubSpecs: programGatePolicy.maxTotalSubSpecs
+        await applyProgramGateOutcome(summary, {
+          projectPath,
+          options: programOptions,
+          programGatePolicy,
+          gateFallbackChain,
+          enableAutoRemediation: options.programGateAutoRemediate !== false
         });
-        let effectiveGatePassed = summary.program_gate.passed;
-        let effectiveGateSource = 'primary';
-        let matchedFallbackProfile = null;
-        summary.program_gate_fallbacks = [];
-        if (!effectiveGatePassed && gateFallbackChain.length > 0) {
-          for (const fallbackProfile of gateFallbackChain) {
-            const fallbackResult = evaluateProgramConvergenceGate(summary, {
-              profile: fallbackProfile,
-              maxElapsedMinutes: programGatePolicy.maxElapsedMinutes,
-              maxAgentBudget: programGatePolicy.maxAgentBudget,
-              maxTotalSubSpecs: programGatePolicy.maxTotalSubSpecs
-            });
-            summary.program_gate_fallbacks.push(fallbackResult);
-            if (fallbackResult.passed) {
-              effectiveGatePassed = true;
-              effectiveGateSource = 'fallback-chain';
-              matchedFallbackProfile = fallbackProfile;
-              break;
-            }
-          }
-        }
-        summary.program_gate_fallback = summary.program_gate_fallbacks.length > 0
-          ? summary.program_gate_fallbacks[0]
-          : null;
-        summary.program_gate_effective = {
-          passed: effectiveGatePassed,
-          source: effectiveGateSource,
-          primary_passed: Boolean(summary.program_gate && summary.program_gate.passed),
-          fallback_profile: matchedFallbackProfile,
-          fallback_chain: gateFallbackChain,
-          fallback_passed: matchedFallbackProfile !== null,
-          attempted_fallback_count: summary.program_gate_fallbacks.length
-        };
-        if (
-          options.programGateAutoRemediate !== false &&
-          (
-            !summary.program_gate_effective.passed ||
-            isSpecSessionBudgetHardFailure(summary) ||
-            isSpecSessionGrowthGuardHardFailure(summary)
-          )
-        ) {
-          summary.program_gate_auto_remediation = await applyProgramGateAutoRemediation(summary, {
+
+        if (programGovernUntilStable) {
+          const governanceResult = await runProgramGovernanceLoop({
+            enabled: true,
+            summary,
             projectPath,
-            options: programOptions
+            programOptions,
+            baseGoalsResult: goalsResult,
+            maxRounds: programGovernMaxRounds,
+            maxMinutes: programGovernMaxMinutes,
+            anomalyEnabled: programGovernAnomalyEnabled,
+            anomalyWeeks: programGovernAnomalyWeeks,
+            anomalyPeriod: programGovernAnomalyPeriod,
+            programGatePolicy,
+            gateFallbackChain,
+            recoveryMemoryScope,
+            recoverResumeStrategy: programRecoverResumeStrategy,
+            recoverMaxRounds: programRecoverMaxRounds,
+            recoverMaxMinutes: programRecoverMaxMinutes,
+            programRecoverUseAction: options.programRecoverUseAction,
+            programGateAutoRemediate: options.programGateAutoRemediate !== false,
+            governUseAction: programGovernUseAction,
+            governAutoActionEnabled: programGovernAutoActionEnabled
           });
+          summary = governanceResult.summary;
+          summary.program_governance = governanceResult.governance;
+        } else {
+          summary.program_governance = {
+            enabled: false,
+            anomaly_enabled: programGovernAnomalyEnabled,
+            anomaly_weeks: programGovernAnomalyWeeks,
+            anomaly_period: programGovernAnomalyPeriod,
+            auto_action_enabled: programGovernAutoActionEnabled,
+            action_selection_enabled: false,
+            pinned_action_index: programGovernUseAction,
+            max_rounds: programGovernMaxRounds,
+            max_minutes: programGovernMaxMinutes,
+            performed_rounds: 0,
+            converged: Boolean(
+              summary &&
+              summary.program_gate_effective &&
+              summary.program_gate_effective.passed &&
+              !isSpecSessionBudgetHardFailure(summary) &&
+              !isSpecSessionGrowthGuardHardFailure(summary)
+            ),
+            exhausted: false,
+            stop_reason: 'disabled',
+            history: []
+          };
         }
+
+        const finalProgramCompletedAt = Date.now();
+        summary.program_completed_at = new Date(finalProgramCompletedAt).toISOString();
+        summary.program_elapsed_ms = Math.max(0, finalProgramCompletedAt - programStartedAt);
+
+        await maybeWriteProgramKpi(summary, options.programKpiOut, projectPath);
+        await maybeWriteOutput(summary, options.out, projectPath);
         await maybeWriteProgramAudit(summary, options.programAuditOut, projectPath);
 
         printCloseLoopBatchSummary(summary, programOptions);
@@ -787,60 +813,13 @@ function registerAutoCommands(program) {
         recoveryResult.summary.program_started_at = new Date(recoveryStartedAt).toISOString();
         recoveryResult.summary.program_completed_at = new Date(recoveryCompletedAt).toISOString();
         recoveryResult.summary.program_elapsed_ms = Math.max(0, recoveryCompletedAt - recoveryStartedAt);
-        recoveryResult.summary.program_gate = evaluateProgramConvergenceGate(recoveryResult.summary, {
-          profile: programGatePolicy.profile,
-          minSuccessRate: programGatePolicy.minSuccessRate,
-          maxRiskLevel: programGatePolicy.maxRiskLevel,
-          maxElapsedMinutes: programGatePolicy.maxElapsedMinutes,
-          maxAgentBudget: programGatePolicy.maxAgentBudget,
-          maxTotalSubSpecs: programGatePolicy.maxTotalSubSpecs
+        await applyProgramGateOutcome(recoveryResult.summary, {
+          projectPath,
+          options,
+          programGatePolicy,
+          gateFallbackChain,
+          enableAutoRemediation: options.programGateAutoRemediate !== false
         });
-        let effectiveRecoveryGatePassed = recoveryResult.summary.program_gate.passed;
-        let effectiveRecoveryGateSource = 'primary';
-        let matchedRecoveryFallbackProfile = null;
-        recoveryResult.summary.program_gate_fallbacks = [];
-        if (!effectiveRecoveryGatePassed && gateFallbackChain.length > 0) {
-          for (const fallbackProfile of gateFallbackChain) {
-            const fallbackResult = evaluateProgramConvergenceGate(recoveryResult.summary, {
-              profile: fallbackProfile,
-              maxElapsedMinutes: programGatePolicy.maxElapsedMinutes,
-              maxAgentBudget: programGatePolicy.maxAgentBudget,
-              maxTotalSubSpecs: programGatePolicy.maxTotalSubSpecs
-            });
-            recoveryResult.summary.program_gate_fallbacks.push(fallbackResult);
-            if (fallbackResult.passed) {
-              effectiveRecoveryGatePassed = true;
-              effectiveRecoveryGateSource = 'fallback-chain';
-              matchedRecoveryFallbackProfile = fallbackProfile;
-              break;
-            }
-          }
-        }
-        recoveryResult.summary.program_gate_fallback = recoveryResult.summary.program_gate_fallbacks.length > 0
-          ? recoveryResult.summary.program_gate_fallbacks[0]
-          : null;
-        recoveryResult.summary.program_gate_effective = {
-          passed: effectiveRecoveryGatePassed,
-          source: effectiveRecoveryGateSource,
-          primary_passed: Boolean(recoveryResult.summary.program_gate && recoveryResult.summary.program_gate.passed),
-          fallback_profile: matchedRecoveryFallbackProfile,
-          fallback_chain: gateFallbackChain,
-          fallback_passed: matchedRecoveryFallbackProfile !== null,
-          attempted_fallback_count: recoveryResult.summary.program_gate_fallbacks.length
-        };
-        if (
-          options.programGateAutoRemediate !== false &&
-          (
-            !recoveryResult.summary.program_gate_effective.passed ||
-            isSpecSessionBudgetHardFailure(recoveryResult.summary) ||
-            isSpecSessionGrowthGuardHardFailure(recoveryResult.summary)
-          )
-        ) {
-          recoveryResult.summary.program_gate_auto_remediation = await applyProgramGateAutoRemediation(recoveryResult.summary, {
-            projectPath,
-            options
-          });
-        }
         await maybeWriteProgramAudit(recoveryResult.summary, options.programAuditOut, projectPath);
 
         printCloseLoopBatchSummary(recoveryResult.summary, recoveryResult.options || options);
@@ -1807,7 +1786,7 @@ async function loadCloseLoopBatchSummaryPayload(projectPath, summaryCandidate) {
   };
 }
 
-function normalizeRecoveryActionIndex(actionCandidate, maxActions) {
+function normalizeRecoveryActionIndex(actionCandidate, maxActions, optionLabel = '--use-action') {
   if (!Number.isInteger(maxActions) || maxActions <= 0) {
     return 1;
   }
@@ -1819,10 +1798,10 @@ function normalizeRecoveryActionIndex(actionCandidate, maxActions) {
   const parsed = Number(actionCandidate);
   const upperBound = Math.max(20, maxActions);
   if (!Number.isInteger(parsed) || parsed < 1 || parsed > upperBound) {
-    throw new Error(`--use-action must be an integer between 1 and ${upperBound}.`);
+    throw new Error(`${optionLabel} must be an integer between 1 and ${upperBound}.`);
   }
   if (parsed > maxActions) {
-    throw new Error(`--use-action ${parsed} is out of range. Available remediation actions: 1-${maxActions}.`);
+    throw new Error(`${optionLabel} ${parsed} is out of range. Available remediation actions: 1-${maxActions}.`);
   }
   return parsed;
 }
@@ -2359,16 +2338,19 @@ function resolveRecoveryActionSelection(summaryPayload, actionCandidate, context
   const availableActions = Array.isArray(diagnostics.remediation_actions) && diagnostics.remediation_actions.length > 0
     ? diagnostics.remediation_actions
     : buildProgramRemediationActions(summaryPayload || {}, []);
+  const optionLabel = typeof context.optionLabel === 'string' && context.optionLabel.trim()
+    ? context.optionLabel.trim()
+    : '--use-action';
   let selectedIndex = null;
   let selectionSource = 'default';
   let memorySelection = null;
   let selectionExplain = null;
   if (actionCandidate !== undefined && actionCandidate !== null) {
-    selectedIndex = normalizeRecoveryActionIndex(actionCandidate, availableActions.length);
+    selectedIndex = normalizeRecoveryActionIndex(actionCandidate, availableActions.length, optionLabel);
     selectionSource = 'explicit';
     selectionExplain = {
       mode: 'explicit',
-      reason: '--use-action provided',
+      reason: `${optionLabel} provided`,
       selected_index: selectedIndex
     };
   } else {
@@ -2884,6 +2866,50 @@ function normalizeProgramMaxTotalSubSpecs(countCandidate) {
   return parsed;
 }
 
+function normalizeProgramGovernMaxRounds(roundsCandidate) {
+  if (roundsCandidate === undefined || roundsCandidate === null) {
+    return 3;
+  }
+  const parsed = Number(roundsCandidate);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 20) {
+    throw new Error('--program-govern-max-rounds must be an integer between 1 and 20.');
+  }
+  return parsed;
+}
+
+function normalizeProgramGovernMaxMinutes(minutesCandidate) {
+  if (minutesCandidate === undefined || minutesCandidate === null) {
+    return 60;
+  }
+  const parsed = Number(minutesCandidate);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 10080) {
+    throw new Error('--program-govern-max-minutes must be an integer between 1 and 10080.');
+  }
+  return parsed;
+}
+
+function normalizeProgramGovernAnomalyWeeks(weeksCandidate) {
+  if (weeksCandidate === undefined || weeksCandidate === null) {
+    return 8;
+  }
+  const parsed = Number(weeksCandidate);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 260) {
+    throw new Error('--program-govern-anomaly-weeks must be an integer between 1 and 260.');
+  }
+  return parsed;
+}
+
+function normalizeProgramGovernUseAction(actionCandidate) {
+  if (actionCandidate === undefined || actionCandidate === null) {
+    return null;
+  }
+  const parsed = Number(actionCandidate);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > 20) {
+    throw new Error('--program-govern-use-action must be an integer between 1 and 20.');
+  }
+  return parsed;
+}
+
 function resolveProgramGatePolicy(policy = {}) {
   const profile = normalizeProgramGateProfile(policy.profile);
   const profilePolicy = PROGRAM_GATE_PROFILE_POLICY[profile];
@@ -4172,6 +4198,38 @@ function printCloseLoopBatchSummary(summary, options) {
       `source=${summary.auto_recovery.selection_source || 'default'})`
     ));
   }
+  if (summary.program_governance && summary.program_governance.enabled) {
+    console.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) {
+      console.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) {
+        console.log(chalk.gray(
+          `  Governance selected action: #${latestRound.selected_action_index || 'n/a'} ${latestRound.selected_action}`
+        ));
+      }
+    }
+    if (summary.program_governance.exhausted) {
+      console.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;
+    console.log(chalk.gray(
+      `  Program KPI anomalies: total=${summary.program_kpi_anomalies.length}, high=${highCount}`
+    ));
+  }
   if (summary.program_coordination) {
     console.log(chalk.gray(
       `  Master/Sub sync: masters=${summary.program_coordination.master_spec_count}, ` +
@@ -4421,6 +4479,505 @@ function evaluateProgramConvergenceGate(summary, policy = {}) {
   };
 }
 
+async function applyProgramGateOutcome(summary, context = {}) {
+  const projectPath = context && context.projectPath ? context.projectPath : process.cwd();
+  const options = context && context.options && typeof context.options === 'object'
+    ? context.options
+    : {};
+  const resolvedPolicy = resolveProgramGatePolicy(context && context.programGatePolicy ? context.programGatePolicy : {});
+  const gateFallbackChain = Array.isArray(context && context.gateFallbackChain)
+    ? context.gateFallbackChain
+    : [];
+  const enableAutoRemediation = context && context.enableAutoRemediation !== undefined
+    ? Boolean(context.enableAutoRemediation)
+    : true;
+
+  summary.program_gate = evaluateProgramConvergenceGate(summary, {
+    profile: resolvedPolicy.profile,
+    minSuccessRate: resolvedPolicy.minSuccessRate,
+    maxRiskLevel: resolvedPolicy.maxRiskLevel,
+    maxElapsedMinutes: resolvedPolicy.maxElapsedMinutes,
+    maxAgentBudget: resolvedPolicy.maxAgentBudget,
+    maxTotalSubSpecs: resolvedPolicy.maxTotalSubSpecs
+  });
+
+  let effectiveGatePassed = summary.program_gate.passed;
+  let effectiveGateSource = 'primary';
+  let matchedFallbackProfile = null;
+  summary.program_gate_fallbacks = [];
+  if (!effectiveGatePassed && gateFallbackChain.length > 0) {
+    for (const fallbackProfile of gateFallbackChain) {
+      const fallbackResult = evaluateProgramConvergenceGate(summary, {
+        profile: fallbackProfile,
+        maxElapsedMinutes: resolvedPolicy.maxElapsedMinutes,
+        maxAgentBudget: resolvedPolicy.maxAgentBudget,
+        maxTotalSubSpecs: resolvedPolicy.maxTotalSubSpecs
+      });
+      summary.program_gate_fallbacks.push(fallbackResult);
+      if (fallbackResult.passed) {
+        effectiveGatePassed = true;
+        effectiveGateSource = 'fallback-chain';
+        matchedFallbackProfile = fallbackProfile;
+        break;
+      }
+    }
+  }
+  summary.program_gate_fallback = summary.program_gate_fallbacks.length > 0
+    ? summary.program_gate_fallbacks[0]
+    : null;
+  summary.program_gate_effective = {
+    passed: effectiveGatePassed,
+    source: effectiveGateSource,
+    primary_passed: Boolean(summary.program_gate && summary.program_gate.passed),
+    fallback_profile: matchedFallbackProfile,
+    fallback_chain: gateFallbackChain,
+    fallback_passed: matchedFallbackProfile !== null,
+    attempted_fallback_count: summary.program_gate_fallbacks.length
+  };
+
+  if (
+    enableAutoRemediation &&
+    (
+      !summary.program_gate_effective.passed ||
+      isSpecSessionBudgetHardFailure(summary) ||
+      isSpecSessionGrowthGuardHardFailure(summary)
+    )
+  ) {
+    summary.program_gate_auto_remediation = await applyProgramGateAutoRemediation(summary, {
+      projectPath,
+      options
+    });
+  }
+
+  return summary;
+}
+
+function hasRecoverableProgramGoals(summary) {
+  const failedStatuses = getBatchFailureStatusSet();
+  const results = Array.isArray(summary && summary.results) ? summary.results : [];
+  return results.some(item => failedStatuses.has(`${item && item.status ? item.status : ''}`.trim().toLowerCase()));
+}
+
+function buildProgramAnomalyGovernancePatch(summary, anomalies, options = {}) {
+  const sourceAnomalies = Array.isArray(anomalies) ? anomalies : [];
+  const highAnomalies = sourceAnomalies.filter(item => `${item && item.severity ? item.severity : ''}`.trim().toLowerCase() === 'high');
+  const patch = {};
+  const reasons = [];
+
+  const anomalyTypes = new Set(highAnomalies.map(item => `${item && item.type ? item.type : ''}`.trim().toLowerCase()));
+  if (anomalyTypes.has('success-rate-drop')) {
+    const currentRetryRounds = normalizeBatchRetryRounds(options.batchRetryRounds);
+    patch.batchRetryRounds = Math.min(5, Math.max(1, currentRetryRounds + 1));
+    patch.batchRetryUntilComplete = true;
+    reasons.push('increase retry rounds due to success-rate-drop anomaly');
+  }
+
+  if (anomalyTypes.has('failed-goals-spike')) {
+    const currentParallelCandidate = options.batchParallel !== undefined && options.batchParallel !== null
+      ? options.batchParallel
+      : (summary && summary.batch_parallel ? summary.batch_parallel : 1);
+    const currentParallel = normalizeBatchParallel(currentParallelCandidate);
+    if (currentParallel > 1) {
+      patch.batchParallel = currentParallel - 1;
+      reasons.push(`reduce batch parallel from ${currentParallel} to ${patch.batchParallel} due to failed-goals-spike`);
+    }
+
+    const currentAgentBudgetCandidate = options.batchAgentBudget !== undefined && options.batchAgentBudget !== null
+      ? options.batchAgentBudget
+      : (summary && summary.resource_plan ? summary.resource_plan.agent_budget : null);
+    const currentAgentBudget = normalizeBatchAgentBudget(currentAgentBudgetCandidate);
+    if (currentAgentBudget !== null && currentAgentBudget > 1) {
+      patch.batchAgentBudget = currentAgentBudget - 1;
+      reasons.push(`reduce batch agent budget from ${currentAgentBudget} to ${patch.batchAgentBudget} due to failed-goals-spike`);
+    }
+  }
+
+  if (anomalyTypes.has('spec-growth-spike')) {
+    patch.specSessionBudgetHardFail = true;
+    reasons.push('enable spec-session budget hard-fail due to spec-growth-spike');
+    if (options.specSessionMaxCreated === undefined || options.specSessionMaxCreated === null) {
+      const estimatedCreated = Number(summary && summary.spec_session_budget && summary.spec_session_budget.estimated_created) || 0;
+      patch.specSessionMaxCreated = Math.max(1, Math.ceil(estimatedCreated * 0.8));
+      reasons.push(`set specSessionMaxCreated=${patch.specSessionMaxCreated} due to spec-growth-spike`);
+    }
+  }
+
+  return {
+    patch,
+    reasons,
+    anomaly_count: highAnomalies.length,
+    anomaly_types: [...anomalyTypes]
+  };
+}
+
+function applyProgramGovernancePatch(baseOptions, patch) {
+  const merged = { ...baseOptions };
+  const sourcePatch = patch && typeof patch === 'object' ? patch : {};
+  for (const [key, value] of Object.entries(sourcePatch)) {
+    if (value === undefined) {
+      continue;
+    }
+    merged[key] = value;
+  }
+  return merged;
+}
+
+function buildProgramGovernanceReplayGoalsResult(baseGoalsResult, round, summary) {
+  const source = baseGoalsResult && typeof baseGoalsResult === 'object'
+    ? baseGoalsResult
+    : { file: '(generated-from-goal)', goals: [] };
+  const sourceSummary = summary && typeof summary === 'object' ? summary : {};
+  return {
+    ...source,
+    file: source.file || '(generated-from-goal)',
+    resumedFromSummary: {
+      file: sourceSummary.batch_session && sourceSummary.batch_session.file
+        ? sourceSummary.batch_session.file
+        : '(program-governance-replay)',
+      strategy: 'program-governance-replay',
+      round,
+      previous_status: sourceSummary.status || null,
+      previous_total_goals: Number(sourceSummary.total_goals) || null,
+      previous_processed_goals: Number(sourceSummary.processed_goals) || null
+    }
+  };
+}
+
+async function runProgramGovernanceLoop(context = {}) {
+  let summary = context.summary && typeof context.summary === 'object' ? context.summary : {};
+  const projectPath = context.projectPath || process.cwd();
+  const baseProgramOptions = context.programOptions && typeof context.programOptions === 'object'
+    ? context.programOptions
+    : {};
+  const baseGoalsResult = context.baseGoalsResult && typeof context.baseGoalsResult === 'object'
+    ? context.baseGoalsResult
+    : { file: '(generated-from-goal)', goals: [] };
+  const enabled = Boolean(context.enabled);
+  const maxRounds = normalizeProgramGovernMaxRounds(context.maxRounds);
+  const maxDurationMinutes = normalizeProgramGovernMaxMinutes(context.maxMinutes);
+  const maxDurationMs = maxDurationMinutes * 60 * 1000;
+  const anomalyEnabled = context.anomalyEnabled !== false;
+  const anomalyWeeks = normalizeProgramGovernAnomalyWeeks(context.anomalyWeeks);
+  const anomalyPeriod = normalizeAutoKpiTrendPeriod(context.anomalyPeriod);
+  const governUseAction = normalizeProgramGovernUseAction(context.governUseAction);
+  const governAutoActionEnabled = context.governAutoActionEnabled !== false;
+  const governActionEnabled = governAutoActionEnabled || governUseAction !== null;
+  const programGatePolicy = resolveProgramGatePolicy(context.programGatePolicy || {});
+  const gateFallbackChain = Array.isArray(context.gateFallbackChain) ? context.gateFallbackChain : [];
+  const recoveryMemoryScope = context.recoveryMemoryScope || null;
+  const normalizedRecoveryScope = normalizeRecoveryMemoryToken(recoveryMemoryScope || '') || 'default-scope';
+  const recoverResumeStrategy = normalizeResumeStrategy(context.recoverResumeStrategy || 'pending');
+  const recoverMaxRounds = normalizeRecoverMaxRounds(context.recoverMaxRounds);
+  const recoverMaxMinutes = normalizeRecoverMaxMinutes(
+    context.recoverMaxMinutes,
+    '--program-recover-max-minutes'
+  );
+  const recoverMaxDurationMs = recoverMaxMinutes === null ? null : recoverMaxMinutes * 60 * 1000;
+  const governanceStartedAt = Date.now();
+  const history = [];
+  let exhausted = false;
+  let stopReason = enabled ? 'stable' : 'disabled';
+  let settled = false;
+
+  if (!enabled) {
+    return {
+      summary,
+      governance: {
+        enabled: false,
+        anomaly_enabled: anomalyEnabled,
+        anomaly_weeks: anomalyWeeks,
+        anomaly_period: anomalyPeriod,
+        auto_action_enabled: governAutoActionEnabled,
+        action_selection_enabled: false,
+        pinned_action_index: governUseAction,
+        max_rounds: maxRounds,
+        max_minutes: maxDurationMinutes,
+        performed_rounds: 0,
+        converged: Boolean(
+          summary &&
+          summary.program_gate_effective &&
+          summary.program_gate_effective.passed &&
+          !isSpecSessionBudgetHardFailure(summary) &&
+          !isSpecSessionGrowthGuardHardFailure(summary)
+        ),
+        exhausted: false,
+        stop_reason: 'disabled',
+        history: []
+      }
+    };
+  }
+
+  for (let round = 1; round <= maxRounds; round += 1) {
+    const elapsedBeforeRound = Date.now() - governanceStartedAt;
+    if (elapsedBeforeRound >= maxDurationMs) {
+      exhausted = true;
+      stopReason = 'time-budget-exhausted';
+      break;
+    }
+
+    let trendResult = null;
+    let anomalies = [];
+    if (anomalyEnabled) {
+      trendResult = await buildAutoKpiTrend(projectPath, {
+        weeks: anomalyWeeks,
+        mode: 'program',
+        period: anomalyPeriod
+      });
+      anomalies = Array.isArray(trendResult.anomalies) ? trendResult.anomalies : [];
+      summary.program_kpi_trend = {
+        generated_at: trendResult.generated_at,
+        weeks: trendResult.weeks,
+        period_unit: trendResult.period_unit,
+        total_runs: trendResult.total_runs,
+        overall: trendResult.overall,
+        anomaly_detection: trendResult.anomaly_detection || null
+      };
+      summary.program_kpi_anomalies = anomalies;
+    }
+
+    const gateFailed = Boolean(
+      !summary.program_gate_effective ||
+      !summary.program_gate_effective.passed ||
+      isSpecSessionBudgetHardFailure(summary) ||
+      isSpecSessionGrowthGuardHardFailure(summary)
+    );
+    const highSeverityAnomalies = anomalies.filter(item => `${item && item.severity ? item.severity : ''}`.trim().toLowerCase() === 'high');
+    const anomalyFailed = anomalyEnabled && highSeverityAnomalies.length > 0;
+    if (!gateFailed && !anomalyFailed) {
+      stopReason = 'stable';
+      settled = true;
+      break;
+    }
+
+    const gatePatch = summary && summary.program_gate_auto_remediation && summary.program_gate_auto_remediation.next_run_patch
+      ? summary.program_gate_auto_remediation.next_run_patch
+      : {};
+    const anomalyPatch = buildProgramAnomalyGovernancePatch(summary, highSeverityAnomalies, baseProgramOptions);
+    let governanceActionSelection = null;
+    let governanceActionPatch = {};
+    if (governActionEnabled) {
+      const recoveryMemory = await loadCloseLoopRecoveryMemory(projectPath);
+      const recoverySignature = buildRecoveryMemorySignature(summary, {
+        scope: normalizedRecoveryScope
+      });
+      const recoveryMemoryEntry = getRecoveryMemoryEntry(recoveryMemory.payload, recoverySignature);
+      governanceActionSelection = resolveRecoveryActionSelection(summary, governUseAction, {
+        recoveryMemoryEntry,
+        optionLabel: '--program-govern-use-action'
+      });
+      governanceActionPatch = governanceActionSelection &&
+        governanceActionSelection.appliedPatch &&
+        typeof governanceActionSelection.appliedPatch === 'object'
+        ? governanceActionSelection.appliedPatch
+        : {};
+    }
+    const roundPatch = {
+      ...(governanceActionPatch && typeof governanceActionPatch === 'object' ? governanceActionPatch : {}),
+      ...(anomalyPatch.patch || {}),
+      ...(gatePatch && typeof gatePatch === 'object' ? gatePatch : {})
+    };
+    if (Object.keys(roundPatch).length === 0) {
+      stopReason = 'no-actionable-patch';
+      history.push({
+        round,
+        status_before: summary.status,
+        status_after: summary.status,
+        trigger: {
+          gate_failed: gateFailed,
+          anomaly_failed: anomalyFailed,
+          anomaly_count: highSeverityAnomalies.length
+        },
+        selected_action_index: governanceActionSelection ? governanceActionSelection.selectedIndex : null,
+        selected_action: governanceActionSelection && governanceActionSelection.selectedAction
+          ? governanceActionSelection.selectedAction.action
+          : null,
+        selected_action_priority: governanceActionSelection && governanceActionSelection.selectedAction
+          ? governanceActionSelection.selectedAction.priority
+          : null,
+        action_selection_source: governanceActionSelection ? governanceActionSelection.selectionSource : null,
+        action_selection_explain: governanceActionSelection ? governanceActionSelection.selectionExplain || null : null,
+        execution_mode: 'none',
+        applied_patch: null,
+        notes: [
+          'No actionable governance patch generated.'
+        ]
+      });
+      break;
+    }
+
+    const roundOptions = applyProgramGovernancePatch(baseProgramOptions, roundPatch);
+    roundOptions.out = null;
+    roundOptions.programKpiOut = null;
+    roundOptions.programAuditOut = null;
+
+    const statusBefore = summary.status;
+    const failedGoalsBefore = Number(summary.failed_goals) || 0;
+    const selectedGovernanceActionIndex = governanceActionSelection ? governanceActionSelection.selectedIndex : null;
+    let executionMode = 'program-replay';
+    let roundSummary = null;
+    if (hasRecoverableProgramGoals(summary)) {
+      executionMode = 'recover-cycle';
+      const roundSourceSummary = summary.batch_session && summary.batch_session.file
+        ? await loadCloseLoopBatchSummaryPayload(projectPath, summary.batch_session.file)
+        : {
+          file: '(program-governance-derived-summary)',
+          payload: summary
+        };
+      const recoveryResult = await executeCloseLoopRecoveryCycle({
+        projectPath,
+        sourceSummary: roundSourceSummary,
+        baseOptions: {
+          ...roundOptions,
+          useAction: selectedGovernanceActionIndex || context.programRecoverUseAction
+        },
+        recoverAutonomousEnabled: true,
+        resumeStrategy: recoverResumeStrategy,
+        recoverUntilComplete: true,
+        recoverMaxRounds,
+        recoverMaxDurationMs,
+        recoveryMemoryScope,
+        actionCandidate: selectedGovernanceActionIndex || context.programRecoverUseAction
+      });
+      roundSummary = mergeProgramRecoveryIntoProgramSummary(summary, recoveryResult.summary, {
+        enabled: true,
+        triggered: true,
+        governance_round: round,
+        recover_until_complete: true,
+        source: 'governance-recover-cycle'
+      });
+      roundSummary.resource_plan = recoveryResult.summary && recoveryResult.summary.resource_plan
+        ? recoveryResult.summary.resource_plan
+        : roundSummary.resource_plan;
+      roundSummary.batch_parallel = Number(recoveryResult.summary && recoveryResult.summary.batch_parallel) || roundSummary.batch_parallel;
+    } else {
+      const replayGoalsResult = buildProgramGovernanceReplayGoalsResult(baseGoalsResult, round, summary);
+      const replaySummary = await executeCloseLoopBatch(
+        replayGoalsResult,
+        roundOptions,
+        projectPath,
+        'auto-close-loop-program'
+      );
+      roundSummary = {
+        ...replaySummary,
+        auto_recovery: summary && summary.auto_recovery ? summary.auto_recovery : null
+      };
+    }
+
+    roundSummary.program_kpi = buildProgramKpiSnapshot(roundSummary);
+    roundSummary.program_diagnostics = buildProgramDiagnostics(roundSummary);
+    roundSummary.program_coordination = buildProgramCoordinationSnapshot(roundSummary);
+    await applyProgramGateOutcome(roundSummary, {
+      projectPath,
+      options: roundOptions,
+      programGatePolicy,
+      gateFallbackChain,
+      enableAutoRemediation: context.programGateAutoRemediate !== false
+    });
+
+    const failedGoalsAfter = Number(roundSummary.failed_goals) || 0;
+    history.push({
+      round,
+      status_before: statusBefore,
+      status_after: roundSummary.status,
+      trigger: {
+        gate_failed: gateFailed,
+        anomaly_failed: anomalyFailed,
+        anomaly_count: highSeverityAnomalies.length
+      },
+      selected_action_index: selectedGovernanceActionIndex,
+      selected_action: governanceActionSelection && governanceActionSelection.selectedAction
+        ? governanceActionSelection.selectedAction.action
+        : null,
+      selected_action_priority: governanceActionSelection && governanceActionSelection.selectedAction
+        ? governanceActionSelection.selectedAction.priority
+        : null,
+      action_selection_source: governanceActionSelection ? governanceActionSelection.selectionSource : null,
+      action_selection_explain: governanceActionSelection ? governanceActionSelection.selectionExplain || null : null,
+      execution_mode: executionMode,
+      applied_patch: roundPatch,
+      patch_reasons: [
+        ...(governanceActionSelection && governanceActionSelection.selectionExplain
+          ? [`governance-action: ${governanceActionSelection.selectionExplain.reason}`]
+          : []),
+        ...(Array.isArray(anomalyPatch.reasons) ? anomalyPatch.reasons : []),
+        ...(summary.program_gate_auto_remediation && Array.isArray(summary.program_gate_auto_remediation.reasons)
+          ? summary.program_gate_auto_remediation.reasons
+          : [])
+      ],
+      failed_goals_before: failedGoalsBefore,
+      failed_goals_after: failedGoalsAfter
+    });
+
+    summary = roundSummary;
+    if (
+      summary.program_gate_effective &&
+      summary.program_gate_effective.passed &&
+      !isSpecSessionBudgetHardFailure(summary) &&
+      !isSpecSessionGrowthGuardHardFailure(summary)
+    ) {
+      if (!anomalyEnabled) {
+        stopReason = 'gate-stable';
+        break;
+      }
+      const postTrend = await buildAutoKpiTrend(projectPath, {
+        weeks: anomalyWeeks,
+        mode: 'program',
+        period: anomalyPeriod
+      });
+      const postAnomalies = Array.isArray(postTrend.anomalies) ? postTrend.anomalies : [];
+      summary.program_kpi_trend = {
+        generated_at: postTrend.generated_at,
+        weeks: postTrend.weeks,
+        period_unit: postTrend.period_unit,
+        total_runs: postTrend.total_runs,
+        overall: postTrend.overall,
+        anomaly_detection: postTrend.anomaly_detection || null
+      };
+      summary.program_kpi_anomalies = postAnomalies;
+      const hasHighPostAnomaly = postAnomalies.some(item => `${item && item.severity ? item.severity : ''}`.trim().toLowerCase() === 'high');
+      if (!hasHighPostAnomaly) {
+        stopReason = 'stable';
+        settled = true;
+        break;
+      }
+    }
+  }
+
+  if (!settled && history.length >= maxRounds && stopReason === 'stable') {
+    stopReason = 'round-limit-reached';
+    exhausted = true;
+  }
+  if (!settled && history.length >= maxRounds && stopReason !== 'stable') {
+    exhausted = true;
+  }
+
+  return {
+    summary,
+    governance: {
+      enabled: true,
+      anomaly_enabled: anomalyEnabled,
+      anomaly_weeks: anomalyWeeks,
+      anomaly_period: anomalyPeriod,
+      auto_action_enabled: governAutoActionEnabled,
+      action_selection_enabled: governActionEnabled,
+      pinned_action_index: governUseAction,
+      max_rounds: maxRounds,
+      max_minutes: maxDurationMinutes,
+      performed_rounds: history.length,
+      converged: Boolean(
+        summary &&
+        summary.program_gate_effective &&
+        summary.program_gate_effective.passed &&
+        !isSpecSessionBudgetHardFailure(summary) &&
+        !isSpecSessionGrowthGuardHardFailure(summary)
+      ),
+      exhausted,
+      stop_reason: stopReason,
+      history
+    }
+  };
+}
+
 async function applyProgramGateAutoRemediation(summary, context = {}) {
   const projectPath = context && context.projectPath ? context.projectPath : process.cwd();
   const options = context && context.options && typeof context.options === 'object'
@@ -4718,6 +5275,9 @@ async function maybeWriteProgramKpi(summary, outCandidate, projectPath) {
     program_diagnostics: summary.program_diagnostics,
     program_coordination: summary.program_coordination || null,
     auto_recovery: summary.auto_recovery || null,
+    program_governance: summary.program_governance || null,
+    program_kpi_trend: summary.program_kpi_trend || null,
+    program_kpi_anomalies: Array.isArray(summary.program_kpi_anomalies) ? summary.program_kpi_anomalies : [],
     goal_input_guard: summary.goal_input_guard || null,
     spec_session_budget: summary.spec_session_budget || null,
     spec_session_growth_guard: summary.spec_session_growth_guard || null,
@@ -4765,6 +5325,9 @@ async function maybeWriteProgramAudit(summary, outCandidate, projectPath) {
     program_gate_fallbacks: Array.isArray(summary && summary.program_gate_fallbacks) ? summary.program_gate_fallbacks : [],
     program_gate_effective: summary && summary.program_gate_effective ? summary.program_gate_effective : null,
     auto_recovery: summary && summary.auto_recovery ? summary.auto_recovery : null,
+    program_governance: summary && summary.program_governance ? summary.program_governance : null,
+    program_kpi_trend: summary && summary.program_kpi_trend ? summary.program_kpi_trend : null,
+    program_kpi_anomalies: Array.isArray(summary && summary.program_kpi_anomalies) ? summary.program_kpi_anomalies : [],
     recovery_cycle: summary && summary.recovery_cycle ? summary.recovery_cycle : null,
     recovery_plan: summary && summary.recovery_plan ? summary.recovery_plan : null,
     recovery_memory: summary && summary.recovery_memory ? summary.recovery_memory : null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiro-spec-engine",
-  "version": "1.47.0",
+  "version": "1.47.1",
   "description": "kiro-spec-engine (kse) - A CLI tool and npm package for spec-driven development with AI coding assistants. NOT the Kiro IDE desktop application.",
   "main": "index.js",
   "bin": {