scene-capability-engine 3.2.0 → 3.3.2

package/lib/commands/auto.js

@@ -47,7 +47,7 @@ const AUTO_HANDOFF_POLICY_PROFILE_PRESETS = {
     require_capability_coverage: true,
     require_capability_semantic: true,
     require_capability_lexicon: true,
-    require_release_gate_preflight: false,
+    require_release_gate_preflight: true,
     dependency_batching: true,
     release_evidence_window: 5
   },
@@ -66,7 +66,7 @@ const AUTO_HANDOFF_POLICY_PROFILE_PRESETS = {
     require_capability_coverage: true,
     require_capability_semantic: true,
     require_capability_lexicon: true,
-    require_release_gate_preflight: false,
+    require_release_gate_preflight: true,
     dependency_batching: true,
     release_evidence_window: 5
   },
@@ -1930,6 +1930,77 @@ function registerAutoCommands(program) {
       }
     });
 
+  autoHandoff
+    .command('preflight-check')
+    .description('Evaluate release-gate preflight readiness from gate-history signals')
+    .option('--profile <profile>', 'Handoff policy profile: default|moqui|enterprise (default: default)', 'default')
+    .option('--history-file <path>', `Release gate history file (default: ${AUTO_HANDOFF_RELEASE_GATE_HISTORY_FILE})`)
+    .option('--require-release-gate-preflight', 'Gate: require release-gate preflight signal to be available and unblocked (default: enabled)')
+    .option('--no-require-release-gate-preflight', 'Gate: disable release-gate preflight hard requirement (not recommended)')
+    .option('--release-evidence-window <n>', 'Release evidence trend window size (2-50, default from profile)', parseInt)
+    .option('--require-pass', 'Exit non-zero when preflight status is not pass')
+    .option('--json', 'Output machine-readable JSON')
+    .action(async (options) => {
+      try {
+        const result = await buildAutoHandoffPreflightCheck(process.cwd(), options);
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+        } else {
+          console.log(chalk.blue('Auto handoff preflight check:'));
+          console.log(chalk.gray(`  Status: ${result.status}`));
+          console.log(chalk.gray(`  Profile: ${result.policy.profile}`));
+          console.log(chalk.gray(`  Hard-gate preflight: ${result.policy.require_release_gate_preflight ? 'enabled' : 'advisory'}`));
+          console.log(chalk.gray(`  History file: ${result.release_gate_preflight.file || 'n/a'}`));
+          console.log(chalk.gray(`  Preflight available: ${result.release_gate_preflight.available === true ? 'yes' : 'no'}`));
+          console.log(chalk.gray(`  Preflight blocked: ${result.release_gate_preflight.blocked === true ? 'yes' : 'no'}`));
+          if (result.release_gate_preflight.latest_tag) {
+            console.log(chalk.gray(`  Latest tag: ${result.release_gate_preflight.latest_tag}`));
+          }
+          if (
+            Number.isFinite(Number(result.release_gate_preflight.latest_weekly_ops_runtime_block_rate_percent)) ||
+            Number.isFinite(Number(result.release_gate_preflight.latest_weekly_ops_runtime_ui_mode_violation_total))
+          ) {
+            const runtimeBlockRateText = Number.isFinite(Number(result.release_gate_preflight.latest_weekly_ops_runtime_block_rate_percent))
+              ? `${result.release_gate_preflight.latest_weekly_ops_runtime_block_rate_percent}%`
+              : 'n/a';
+            const runtimeUiModeTotalText = Number.isFinite(Number(result.release_gate_preflight.latest_weekly_ops_runtime_ui_mode_violation_total))
+              ? `${result.release_gate_preflight.latest_weekly_ops_runtime_ui_mode_violation_total}`
+              : 'n/a';
+            const runtimeUiModeRateText = Number.isFinite(Number(result.release_gate_preflight.latest_weekly_ops_runtime_ui_mode_violation_rate_percent))
+              ? `${result.release_gate_preflight.latest_weekly_ops_runtime_ui_mode_violation_rate_percent}%`
+              : 'n/a';
+            console.log(
+              chalk.gray(
+                `  Runtime pressure (latest): block-rate=${runtimeBlockRateText} | ui-mode=${runtimeUiModeTotalText}/${runtimeUiModeRateText}`
+              )
+            );
+          }
+          if (Array.isArray(result.reasons) && result.reasons.length > 0) {
+            console.log(chalk.gray('  Reasons:'));
+            result.reasons.forEach(item => {
+              console.log(chalk.gray(`    - ${item}`));
+            });
+          }
+          if (Array.isArray(result.recommended_commands) && result.recommended_commands.length > 0) {
+            console.log(chalk.gray('  Recommended commands:'));
+            result.recommended_commands.slice(0, 5).forEach(item => {
+              console.log(chalk.gray(`    - ${item}`));
+            });
+          }
+        }
+        if (options.requirePass && result.status !== 'pass') {
+          process.exit(1);
+        }
+      } catch (error) {
+        if (options.json) {
+          console.log(JSON.stringify({ success: false, error: error.message }, null, 2));
+        } else {
+          console.error(chalk.red(`Error: ${error.message}`));
+        }
+        process.exit(1);
+      }
+    });
+
   autoHandoff
     .command('run')
     .description('Execute handoff integration pipeline: plan -> queue -> close-loop-batch -> observability')
@@ -1969,8 +2040,8 @@ function registerAutoCommands(program) {
     .option('--no-require-capability-coverage', 'Gate: disable capability coverage requirement (not recommended)')
     .option('--require-capability-lexicon', 'Gate: require capability lexicon normalization (unknown expected/provided aliases not allowed, default: enabled)')
     .option('--no-require-capability-lexicon', 'Gate: disable capability lexicon normalization requirement (not recommended)')
-    .option('--require-release-gate-preflight', 'Gate: require release-gate preflight signal to be available and unblocked (default: disabled/advisory)')
-    .option('--no-require-release-gate-preflight', 'Gate: disable release-gate preflight hard requirement (default)')
+    .option('--require-release-gate-preflight', 'Gate: require release-gate preflight signal to be available and unblocked (default: enabled)')
+    .option('--no-require-release-gate-preflight', 'Gate: disable release-gate preflight hard requirement (not recommended)')
     .option('--release-evidence-window <n>', 'Release evidence trend window size (2-50, default: 5)', parseInt)
     .option('--json', 'Output machine-readable JSON')
     .action(async (options) => {
@@ -2006,6 +2077,25 @@ function registerAutoCommands(program) {
             if (preflight.latest_tag) {
               console.log(chalk.gray(`    Latest tag: ${preflight.latest_tag}`));
             }
+            if (
+              Number.isFinite(Number(preflight.latest_weekly_ops_runtime_block_rate_percent)) ||
+              Number.isFinite(Number(preflight.latest_weekly_ops_runtime_ui_mode_violation_total))
+            ) {
+              const runtimeBlockRateText = Number.isFinite(Number(preflight.latest_weekly_ops_runtime_block_rate_percent))
+                ? `${preflight.latest_weekly_ops_runtime_block_rate_percent}%`
+                : 'n/a';
+              const runtimeUiModeTotalText = Number.isFinite(Number(preflight.latest_weekly_ops_runtime_ui_mode_violation_total))
+                ? `${preflight.latest_weekly_ops_runtime_ui_mode_violation_total}`
+                : 'n/a';
+              const runtimeUiModeRateText = Number.isFinite(Number(preflight.latest_weekly_ops_runtime_ui_mode_violation_rate_percent))
+                ? `${preflight.latest_weekly_ops_runtime_ui_mode_violation_rate_percent}%`
+                : 'n/a';
+              console.log(
+                chalk.gray(
+                  `    Runtime pressure: block-rate=${runtimeBlockRateText} | ui-mode=${runtimeUiModeTotalText}/${runtimeUiModeRateText}`
+                )
+              );
+            }
             if (preflight.reasons && preflight.reasons.length > 0) {
               console.log(chalk.gray(`    Reasons: ${preflight.reasons.join(' | ')}`));
             }
@@ -5197,6 +5287,50 @@ async function runCloseLoopBatchWithRetries(goals, options) {
       'Goal was not processed.'
     ));
   const effectivePerformedRounds = Math.min(retryMaxRounds, Math.max(0, retryHistory.length - 1));
+  const totalRateLimitSignals = retryHistory.reduce((sum, item) => {
+    return sum + (Number(item && item.rate_limit_signals) || 0);
+  }, 0);
+  const totalRateLimitBackoffMs = retryHistory.reduce((sum, item) => {
+    return sum + (Number(item && item.rate_limit_backoff_ms) || 0);
+  }, 0);
+  const totalRateLimitLaunchHoldMs = retryHistory.reduce((sum, item) => {
+    return sum + (Number(item && item.rate_limit_launch_hold_ms) || 0);
+  }, 0);
+  const rateLimitPressureDetected =
+    totalRateLimitSignals > 0 || totalRateLimitBackoffMs > 0 || totalRateLimitLaunchHoldMs > 0;
+  const rateLimitRecoveryRecommended = exhausted && rateLimitPressureDetected;
+
+  const safeBatchParallel = Number.isInteger(configuredBatchParallel)
+    ? configuredBatchParallel
+    : 1;
+  const safeBatchAgentBudget = Number.isInteger(configuredBatchAgentBudget)
+    ? configuredBatchAgentBudget
+    : null;
+  const recommendedBatchParallel = Math.max(1, Math.min(2, safeBatchParallel));
+  const recommendedBatchAgentBudget = safeBatchAgentBudget === null
+    ? 2
+    : Math.max(1, Math.min(2, safeBatchAgentBudget));
+  const recommendedRetryMaxRounds = Math.max(2, Math.min(20, retryMaxRounds + 2));
+  const recoveryPatch = rateLimitRecoveryRecommended
+    ? {
+      batch_parallel: recommendedBatchParallel,
+      batch_agent_budget: recommendedBatchAgentBudget,
+      batch_retry_until_complete: true,
+      batch_retry_strategy: 'adaptive',
+      batch_retry_max_rounds: recommendedRetryMaxRounds
+    }
+    : null;
+  const recoverySuggestedCommand = rateLimitRecoveryRecommended
+    ? [
+      'sce auto close-loop-recover latest',
+      `--batch-parallel ${recommendedBatchParallel}`,
+      `--batch-agent-budget ${recommendedBatchAgentBudget}`,
+      '--batch-retry-until-complete',
+      '--batch-retry-strategy adaptive',
+      `--batch-retry-max-rounds ${recommendedRetryMaxRounds}`,
+      '--json'
+    ].join(' ')
+    : null;
 
   return {
     effectiveParallel,
@@ -5211,6 +5345,13 @@ async function runCloseLoopBatchWithRetries(goals, options) {
       max_rounds: retryMaxRounds,
       performed_rounds: effectivePerformedRounds,
       exhausted,
+      rate_limit_pressure_detected: rateLimitPressureDetected,
+      total_rate_limit_signals: totalRateLimitSignals,
+      total_rate_limit_backoff_ms: totalRateLimitBackoffMs,
+      total_rate_limit_launch_hold_ms: totalRateLimitLaunchHoldMs,
+      recovery_recommended: rateLimitRecoveryRecommended,
+      recovery_patch: recoveryPatch,
+      recovery_suggested_command: recoverySuggestedCommand,
       history: retryHistory
     }
   };
@@ -6536,6 +6677,15 @@ function printCloseLoopBatchSummary(summary, options) {
       `  Batch retry: ${summary.batch_retry.performed_rounds}/${summary.batch_retry.configured_rounds} extra rounds`
     ));
   }
+  if (summary.batch_retry && summary.batch_retry.recovery_recommended) {
+    console.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) {
+      console.log(chalk.yellow(`  Suggested command: ${summary.batch_retry.recovery_suggested_command}`));
+    }
+  }
   if (summary.resource_plan.agent_budget !== null) {
     console.log(chalk.gray(
       `  Agent budget: ${summary.resource_plan.agent_budget} ` +
@@ -9287,6 +9437,162 @@ function buildAutoHandoffReleaseGateHistoryEntry(entry = {}, options = {}) {
       ? entry.drift_evaluated_at
       : drift.evaluated_at
   );
+  const weeklyOps = entry && typeof entry.weekly_ops === 'object' && !Array.isArray(entry.weekly_ops)
+    ? entry.weekly_ops
+    : {};
+  const weeklyOpsSignals = weeklyOps && typeof weeklyOps.signals === 'object' && !Array.isArray(weeklyOps.signals)
+    ? weeklyOps.signals
+    : {};
+  const weeklyOpsViolations = Array.isArray(weeklyOps.violations)
+    ? weeklyOps.violations.map(item => `${item}`)
+    : [];
+  const weeklyOpsWarnings = Array.isArray(weeklyOps.warnings)
+    ? weeklyOps.warnings.map(item => `${item}`)
+    : [];
+  const weeklyOpsConfigWarnings = Array.isArray(weeklyOps.config_warnings)
+    ? weeklyOps.config_warnings.map(item => `${item}`)
+    : [];
+  const weeklyOpsAvailable = parseAutoHandoffGateBoolean(entry.weekly_ops_available, null) === true
+    || Object.keys(weeklyOps).length > 0;
+  const weeklyOpsBlocked = parseAutoHandoffGateBoolean(
+    entry.weekly_ops_blocked !== undefined
+      ? entry.weekly_ops_blocked
+      : weeklyOps.blocked,
+    null
+  );
+  const weeklyOpsRiskRaw = normalizeHandoffText(
+    entry.weekly_ops_risk_level !== undefined
+      ? entry.weekly_ops_risk_level
+      : weeklyOpsSignals.risk
+  );
+  const weeklyOpsRiskLevel = weeklyOpsRiskRaw
+    ? normalizeAutoHandoffGateRiskLevel(weeklyOpsRiskRaw)
+    : null;
+  const weeklyOpsGovernanceStatus = normalizeHandoffText(
+    entry.weekly_ops_governance_status !== undefined
+      ? entry.weekly_ops_governance_status
+      : weeklyOpsSignals.governance_status
+  ) || null;
+  const weeklyOpsAuthorizationTierBlockRatePercentCandidate = (
+    entry.weekly_ops_authorization_tier_block_rate_percent !== undefined
+      ? entry.weekly_ops_authorization_tier_block_rate_percent
+      : weeklyOpsSignals.authorization_tier_block_rate_percent
+  );
+  const weeklyOpsDialogueAuthorizationBlockRatePercentCandidate = (
+    entry.weekly_ops_dialogue_authorization_block_rate_percent !== undefined
+      ? entry.weekly_ops_dialogue_authorization_block_rate_percent
+      : weeklyOpsSignals.dialogue_authorization_block_rate_percent
+  );
+  const weeklyOpsMatrixRegressionPositiveRatePercentCandidate = (
+    entry.weekly_ops_matrix_regression_positive_rate_percent !== undefined
+      ? entry.weekly_ops_matrix_regression_positive_rate_percent
+      : weeklyOpsSignals.matrix_regression_positive_rate_percent
+  );
+  const weeklyOpsRuntimeBlockRatePercentCandidate = (
+    entry.weekly_ops_runtime_block_rate_percent !== undefined
+      ? entry.weekly_ops_runtime_block_rate_percent
+      : weeklyOpsSignals.runtime_block_rate_percent
+  );
+  const weeklyOpsRuntimeUiModeViolationTotalCandidate = (
+    entry.weekly_ops_runtime_ui_mode_violation_total !== undefined
+      ? entry.weekly_ops_runtime_ui_mode_violation_total
+      : weeklyOpsSignals.runtime_ui_mode_violation_total
+  );
+  const weeklyOpsRuntimeUiModeViolationRatePercentCandidate = (
+    entry.weekly_ops_runtime_ui_mode_violation_rate_percent !== undefined
+      ? entry.weekly_ops_runtime_ui_mode_violation_rate_percent
+      : weeklyOpsSignals.runtime_ui_mode_violation_rate_percent
+  );
+  const weeklyOpsViolationsCountCandidate = (
+    entry.weekly_ops_violations_count !== undefined
+      ? entry.weekly_ops_violations_count
+      : (
+        weeklyOps.violations_count !== undefined
+          ? weeklyOps.violations_count
+          : (weeklyOpsAvailable ? weeklyOpsViolations.length : null)
+      )
+  );
+  const weeklyOpsWarningCountCandidate = (
+    entry.weekly_ops_warning_count !== undefined
+      ? entry.weekly_ops_warning_count
+      : (
+        weeklyOps.warning_count !== undefined
+          ? weeklyOps.warning_count
+          : (weeklyOpsAvailable ? weeklyOpsWarnings.length : null)
+      )
+  );
+  const weeklyOpsConfigWarningCountCandidate = (
+    entry.weekly_ops_config_warning_count !== undefined
+      ? entry.weekly_ops_config_warning_count
+      : (
+        weeklyOps.config_warning_count !== undefined
+          ? weeklyOps.config_warning_count
+          : (weeklyOpsAvailable ? weeklyOpsConfigWarnings.length : null)
+      )
+  );
+  const weeklyOpsAuthorizationTierBlockRatePercent = (
+    weeklyOpsAuthorizationTierBlockRatePercentCandidate === null
+    || weeklyOpsAuthorizationTierBlockRatePercentCandidate === undefined
+    || weeklyOpsAuthorizationTierBlockRatePercentCandidate === ''
+  )
+    ? null
+    : parseAutoHandoffGateNumber(weeklyOpsAuthorizationTierBlockRatePercentCandidate);
+  const weeklyOpsDialogueAuthorizationBlockRatePercent = (
+    weeklyOpsDialogueAuthorizationBlockRatePercentCandidate === null
+    || weeklyOpsDialogueAuthorizationBlockRatePercentCandidate === undefined
+    || weeklyOpsDialogueAuthorizationBlockRatePercentCandidate === ''
+  )
+    ? null
+    : parseAutoHandoffGateNumber(weeklyOpsDialogueAuthorizationBlockRatePercentCandidate);
+  const weeklyOpsMatrixRegressionPositiveRatePercent = (
+    weeklyOpsMatrixRegressionPositiveRatePercentCandidate === null
+    || weeklyOpsMatrixRegressionPositiveRatePercentCandidate === undefined
+    || weeklyOpsMatrixRegressionPositiveRatePercentCandidate === ''
+  )
+    ? null
+    : parseAutoHandoffGateNumber(weeklyOpsMatrixRegressionPositiveRatePercentCandidate);
+  const weeklyOpsRuntimeBlockRatePercent = (
+    weeklyOpsRuntimeBlockRatePercentCandidate === null
+    || weeklyOpsRuntimeBlockRatePercentCandidate === undefined
+    || weeklyOpsRuntimeBlockRatePercentCandidate === ''
+  )
+    ? null
+    : parseAutoHandoffGateNumber(weeklyOpsRuntimeBlockRatePercentCandidate);
+  const weeklyOpsRuntimeUiModeViolationTotal = (
+    weeklyOpsRuntimeUiModeViolationTotalCandidate === null
+    || weeklyOpsRuntimeUiModeViolationTotalCandidate === undefined
+    || weeklyOpsRuntimeUiModeViolationTotalCandidate === ''
+  )
+    ? null
+    : parseAutoHandoffGateNumber(weeklyOpsRuntimeUiModeViolationTotalCandidate);
+  const weeklyOpsRuntimeUiModeViolationRatePercent = (
+    weeklyOpsRuntimeUiModeViolationRatePercentCandidate === null
+    || weeklyOpsRuntimeUiModeViolationRatePercentCandidate === undefined
+    || weeklyOpsRuntimeUiModeViolationRatePercentCandidate === ''
+  )
+    ? null
+    : parseAutoHandoffGateNumber(weeklyOpsRuntimeUiModeViolationRatePercentCandidate);
+  const weeklyOpsViolationsCount = (
+    weeklyOpsViolationsCountCandidate === null
+    || weeklyOpsViolationsCountCandidate === undefined
+    || weeklyOpsViolationsCountCandidate === ''
+  )
+    ? null
+    : parseAutoHandoffGateNumber(weeklyOpsViolationsCountCandidate);
+  const weeklyOpsWarningCount = (
+    weeklyOpsWarningCountCandidate === null
+    || weeklyOpsWarningCountCandidate === undefined
+    || weeklyOpsWarningCountCandidate === ''
+  )
+    ? null
+    : parseAutoHandoffGateNumber(weeklyOpsWarningCountCandidate);
+  const weeklyOpsConfigWarningCount = (
+    weeklyOpsConfigWarningCountCandidate === null
+    || weeklyOpsConfigWarningCountCandidate === undefined
+    || weeklyOpsConfigWarningCountCandidate === ''
+  )
+    ? null
+    : parseAutoHandoffGateNumber(weeklyOpsConfigWarningCountCandidate);
   const violations = Array.isArray(entry.violations)
     ? entry.violations.map(item => `${item}`)
     : [];
@@ -9351,6 +9657,37 @@ function buildAutoHandoffReleaseGateHistoryEntry(entry = {}, options = {}) {
     drift_blocked: typeof driftBlocked === 'boolean' ? driftBlocked : null,
     drift_enforce: typeof driftEnforce === 'boolean' ? driftEnforce : null,
     drift_evaluated_at: driftEvaluatedAt || null,
+    weekly_ops_available: weeklyOpsAvailable,
+    weekly_ops_blocked: typeof weeklyOpsBlocked === 'boolean' ? weeklyOpsBlocked : null,
+    weekly_ops_risk_level: weeklyOpsRiskLevel,
+    weekly_ops_governance_status: weeklyOpsGovernanceStatus,
+    weekly_ops_authorization_tier_block_rate_percent: Number.isFinite(weeklyOpsAuthorizationTierBlockRatePercent)
+      ? weeklyOpsAuthorizationTierBlockRatePercent
+      : null,
+    weekly_ops_dialogue_authorization_block_rate_percent: Number.isFinite(weeklyOpsDialogueAuthorizationBlockRatePercent)
+      ? weeklyOpsDialogueAuthorizationBlockRatePercent
+      : null,
+    weekly_ops_matrix_regression_positive_rate_percent: Number.isFinite(weeklyOpsMatrixRegressionPositiveRatePercent)
+      ? weeklyOpsMatrixRegressionPositiveRatePercent
+      : null,
+    weekly_ops_runtime_block_rate_percent: Number.isFinite(weeklyOpsRuntimeBlockRatePercent)
+      ? weeklyOpsRuntimeBlockRatePercent
+      : null,
+    weekly_ops_runtime_ui_mode_violation_total: Number.isFinite(weeklyOpsRuntimeUiModeViolationTotal)
+      ? Math.max(0, Number(weeklyOpsRuntimeUiModeViolationTotal))
+      : null,
+    weekly_ops_runtime_ui_mode_violation_rate_percent: Number.isFinite(weeklyOpsRuntimeUiModeViolationRatePercent)
+      ? Math.max(0, Number(weeklyOpsRuntimeUiModeViolationRatePercent))
+      : null,
+    weekly_ops_violations_count: Number.isFinite(weeklyOpsViolationsCount)
+      ? Math.max(0, Number(weeklyOpsViolationsCount))
+      : null,
+    weekly_ops_warning_count: Number.isFinite(weeklyOpsWarningCount)
+      ? Math.max(0, Number(weeklyOpsWarningCount))
+      : null,
+    weekly_ops_config_warning_count: Number.isFinite(weeklyOpsConfigWarningCount)
+      ? Math.max(0, Number(weeklyOpsConfigWarningCount))
+      : null,
     violations_count: Math.max(0, Number(violationsCount) || 0),
     config_warning_count: Math.max(0, Number(configWarningCount) || 0),
     thresholds,
@@ -9496,6 +9833,20 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
   let driftAlertRuns = 0;
   let driftBlockedRuns = 0;
   let driftKnownRuns = 0;
+  let weeklyOpsKnownRuns = 0;
+  let weeklyOpsBlockedRuns = 0;
+  let weeklyOpsViolationsTotal = 0;
+  let weeklyOpsWarningsTotal = 0;
+  let weeklyOpsConfigWarningsTotal = 0;
+  let weeklyOpsConfigWarningRuns = 0;
+  let weeklyOpsRuntimeUiModeViolationKnownRuns = 0;
+  let weeklyOpsRuntimeUiModeViolationRuns = 0;
+  let weeklyOpsRuntimeUiModeViolationTotal = 0;
+  const weeklyOpsAuthorizationTierBlockRates = [];
+  const weeklyOpsDialogueAuthorizationBlockRates = [];
+  const weeklyOpsMatrixRegressionPositiveRates = [];
+  const weeklyOpsRuntimeBlockRates = [];
+  const weeklyOpsRuntimeUiModeViolationRates = [];
   let preflightKnownRuns = 0;
   let preflightAvailableRuns = 0;
   let preflightBlockedRuns = 0;
@@ -9630,6 +9981,145 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
       driftKnownRuns += 1;
     }
 
+    const weeklyOpsBlocked = parseAutoHandoffGateBoolean(entry && entry.weekly_ops_blocked, null);
+    const weeklyOpsViolationsCountRaw = entry && entry.weekly_ops_violations_count;
+    const weeklyOpsWarningCountRaw = entry && entry.weekly_ops_warning_count;
+    const weeklyOpsConfigWarningCountRaw = entry && entry.weekly_ops_config_warning_count;
+    const weeklyOpsAuthorizationTierBlockRateRaw = entry && entry.weekly_ops_authorization_tier_block_rate_percent;
+    const weeklyOpsDialogueAuthorizationBlockRateRaw = entry && entry.weekly_ops_dialogue_authorization_block_rate_percent;
+    const weeklyOpsMatrixRegressionPositiveRateRaw = entry && entry.weekly_ops_matrix_regression_positive_rate_percent;
+    const weeklyOpsRuntimeBlockRateRaw = entry && entry.weekly_ops_runtime_block_rate_percent;
+    const weeklyOpsRuntimeUiModeViolationTotalRaw = entry && entry.weekly_ops_runtime_ui_mode_violation_total;
+    const weeklyOpsRuntimeUiModeViolationRateRaw = entry && entry.weekly_ops_runtime_ui_mode_violation_rate_percent;
+    const weeklyOpsViolationsCount = (
+      weeklyOpsViolationsCountRaw === null
+      || weeklyOpsViolationsCountRaw === undefined
+      || weeklyOpsViolationsCountRaw === ''
+    )
+      ? null
+      : parseAutoHandoffGateNumber(weeklyOpsViolationsCountRaw);
+    const weeklyOpsWarningCount = (
+      weeklyOpsWarningCountRaw === null
+      || weeklyOpsWarningCountRaw === undefined
+      || weeklyOpsWarningCountRaw === ''
+    )
+      ? null
+      : parseAutoHandoffGateNumber(weeklyOpsWarningCountRaw);
+    const weeklyOpsConfigWarningCount = (
+      weeklyOpsConfigWarningCountRaw === null
+      || weeklyOpsConfigWarningCountRaw === undefined
+      || weeklyOpsConfigWarningCountRaw === ''
+    )
+      ? null
+      : parseAutoHandoffGateNumber(weeklyOpsConfigWarningCountRaw);
+    const weeklyOpsAuthorizationTierBlockRate = (
+      weeklyOpsAuthorizationTierBlockRateRaw === null
+      || weeklyOpsAuthorizationTierBlockRateRaw === undefined
+      || weeklyOpsAuthorizationTierBlockRateRaw === ''
+    )
+      ? null
+      : parseAutoHandoffGateNumber(weeklyOpsAuthorizationTierBlockRateRaw);
+    const weeklyOpsDialogueAuthorizationBlockRate = (
+      weeklyOpsDialogueAuthorizationBlockRateRaw === null
+      || weeklyOpsDialogueAuthorizationBlockRateRaw === undefined
+      || weeklyOpsDialogueAuthorizationBlockRateRaw === ''
+    )
+      ? null
+      : parseAutoHandoffGateNumber(weeklyOpsDialogueAuthorizationBlockRateRaw);
+    const weeklyOpsMatrixRegressionPositiveRate = (
+      weeklyOpsMatrixRegressionPositiveRateRaw === null
+      || weeklyOpsMatrixRegressionPositiveRateRaw === undefined
+      || weeklyOpsMatrixRegressionPositiveRateRaw === ''
+    )
+      ? null
+      : parseAutoHandoffGateNumber(weeklyOpsMatrixRegressionPositiveRateRaw);
+    const weeklyOpsRuntimeBlockRate = (
+      weeklyOpsRuntimeBlockRateRaw === null
+      || weeklyOpsRuntimeBlockRateRaw === undefined
+      || weeklyOpsRuntimeBlockRateRaw === ''
+    )
+      ? null
+      : parseAutoHandoffGateNumber(weeklyOpsRuntimeBlockRateRaw);
+    const weeklyOpsRuntimeUiModeViolationTotalCount = (
+      weeklyOpsRuntimeUiModeViolationTotalRaw === null
+      || weeklyOpsRuntimeUiModeViolationTotalRaw === undefined
+      || weeklyOpsRuntimeUiModeViolationTotalRaw === ''
+    )
+      ? null
+      : parseAutoHandoffGateNumber(weeklyOpsRuntimeUiModeViolationTotalRaw);
+    const weeklyOpsRuntimeUiModeViolationRate = (
+      weeklyOpsRuntimeUiModeViolationRateRaw === null
+      || weeklyOpsRuntimeUiModeViolationRateRaw === undefined
+      || weeklyOpsRuntimeUiModeViolationRateRaw === ''
+    )
+      ? null
+      : parseAutoHandoffGateNumber(weeklyOpsRuntimeUiModeViolationRateRaw);
+    const weeklyOpsHasSignal = (
+      entry && entry.weekly_ops_available === true
+      || weeklyOpsBlocked === true
+      || weeklyOpsBlocked === false
+      || Number.isFinite(weeklyOpsViolationsCount)
+      || Number.isFinite(weeklyOpsWarningCount)
+      || Number.isFinite(weeklyOpsConfigWarningCount)
+      || Number.isFinite(weeklyOpsAuthorizationTierBlockRate)
+      || Number.isFinite(weeklyOpsDialogueAuthorizationBlockRate)
+      || Number.isFinite(weeklyOpsMatrixRegressionPositiveRate)
+      || Number.isFinite(weeklyOpsRuntimeBlockRate)
+      || Number.isFinite(weeklyOpsRuntimeUiModeViolationTotalCount)
+      || Number.isFinite(weeklyOpsRuntimeUiModeViolationRate)
+    );
+    if (weeklyOpsHasSignal) {
+      weeklyOpsKnownRuns += 1;
+      if (weeklyOpsBlocked === true) {
+        weeklyOpsBlockedRuns += 1;
+      }
+      const normalizedWeeklyViolations = Number.isFinite(weeklyOpsViolationsCount)
+        ? Math.max(0, Number(weeklyOpsViolationsCount))
+        : 0;
+      const normalizedWeeklyWarnings = Number.isFinite(weeklyOpsWarningCount)
+        ? Math.max(0, Number(weeklyOpsWarningCount))
+        : 0;
+      const normalizedWeeklyConfigWarnings = Number.isFinite(weeklyOpsConfigWarningCount)
+        ? Math.max(0, Number(weeklyOpsConfigWarningCount))
+        : 0;
+      weeklyOpsViolationsTotal += normalizedWeeklyViolations;
+      weeklyOpsWarningsTotal += normalizedWeeklyWarnings;
+      weeklyOpsConfigWarningsTotal += normalizedWeeklyConfigWarnings;
+      if (normalizedWeeklyConfigWarnings > 0) {
+        weeklyOpsConfigWarningRuns += 1;
+      }
+      if (Number.isFinite(weeklyOpsAuthorizationTierBlockRate)) {
+        weeklyOpsAuthorizationTierBlockRates.push(Math.max(0, Number(weeklyOpsAuthorizationTierBlockRate)));
+      }
+      if (Number.isFinite(weeklyOpsDialogueAuthorizationBlockRate)) {
+        weeklyOpsDialogueAuthorizationBlockRates.push(Math.max(0, Number(weeklyOpsDialogueAuthorizationBlockRate)));
+      }
+      if (Number.isFinite(weeklyOpsMatrixRegressionPositiveRate)) {
+        weeklyOpsMatrixRegressionPositiveRates.push(Math.max(0, Number(weeklyOpsMatrixRegressionPositiveRate)));
+      }
+      if (Number.isFinite(weeklyOpsRuntimeBlockRate)) {
+        weeklyOpsRuntimeBlockRates.push(Math.max(0, Number(weeklyOpsRuntimeBlockRate)));
+      }
+      const hasRuntimeUiModeSignal = (
+        Number.isFinite(weeklyOpsRuntimeUiModeViolationTotalCount) ||
+        Number.isFinite(weeklyOpsRuntimeUiModeViolationRate) ||
+        Number.isFinite(weeklyOpsRuntimeBlockRate)
+      );
+      if (hasRuntimeUiModeSignal) {
+        weeklyOpsRuntimeUiModeViolationKnownRuns += 1;
+      }
+      if (Number.isFinite(weeklyOpsRuntimeUiModeViolationTotalCount)) {
+        const normalizedRuntimeUiModeViolationTotal = Math.max(0, Number(weeklyOpsRuntimeUiModeViolationTotalCount));
+        weeklyOpsRuntimeUiModeViolationTotal += normalizedRuntimeUiModeViolationTotal;
+        if (normalizedRuntimeUiModeViolationTotal > 0) {
+          weeklyOpsRuntimeUiModeViolationRuns += 1;
+        }
+      }
+      if (Number.isFinite(weeklyOpsRuntimeUiModeViolationRate)) {
+        weeklyOpsRuntimeUiModeViolationRates.push(Math.max(0, Number(weeklyOpsRuntimeUiModeViolationRate)));
+      }
+    }
+
     violationsTotal += Math.max(0, Number(entry && entry.violations_count) || 0);
     configWarningsTotal += Math.max(0, Number(entry && entry.config_warning_count) || 0);
   });
@@ -9680,6 +10170,45 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
   const driftBlockRate = driftKnownRuns > 0
     ? Number(((driftBlockedRuns / driftKnownRuns) * 100).toFixed(2))
     : null;
+  const weeklyOpsBlockRate = weeklyOpsKnownRuns > 0
+    ? Number(((weeklyOpsBlockedRuns / weeklyOpsKnownRuns) * 100).toFixed(2))
+    : null;
+  const weeklyOpsConfigWarningRunRate = weeklyOpsKnownRuns > 0
+    ? Number(((weeklyOpsConfigWarningRuns / weeklyOpsKnownRuns) * 100).toFixed(2))
+    : null;
+  const weeklyOpsAuthorizationTierBlockRateAvg = weeklyOpsAuthorizationTierBlockRates.length > 0
+    ? Number((weeklyOpsAuthorizationTierBlockRates.reduce((sum, value) => sum + value, 0) / weeklyOpsAuthorizationTierBlockRates.length).toFixed(2))
+    : null;
+  const weeklyOpsAuthorizationTierBlockRateMax = weeklyOpsAuthorizationTierBlockRates.length > 0
+    ? Number(Math.max(...weeklyOpsAuthorizationTierBlockRates).toFixed(2))
+    : null;
+  const weeklyOpsDialogueAuthorizationBlockRateAvg = weeklyOpsDialogueAuthorizationBlockRates.length > 0
+    ? Number((weeklyOpsDialogueAuthorizationBlockRates.reduce((sum, value) => sum + value, 0) / weeklyOpsDialogueAuthorizationBlockRates.length).toFixed(2))
+    : null;
+  const weeklyOpsDialogueAuthorizationBlockRateMax = weeklyOpsDialogueAuthorizationBlockRates.length > 0
+    ? Number(Math.max(...weeklyOpsDialogueAuthorizationBlockRates).toFixed(2))
+    : null;
+  const weeklyOpsMatrixRegressionPositiveRateAvg = weeklyOpsMatrixRegressionPositiveRates.length > 0
+    ? Number((weeklyOpsMatrixRegressionPositiveRates.reduce((sum, value) => sum + value, 0) / weeklyOpsMatrixRegressionPositiveRates.length).toFixed(2))
+    : null;
+  const weeklyOpsMatrixRegressionPositiveRateMax = weeklyOpsMatrixRegressionPositiveRates.length > 0
+    ? Number(Math.max(...weeklyOpsMatrixRegressionPositiveRates).toFixed(2))
+    : null;
+  const weeklyOpsRuntimeBlockRateAvg = weeklyOpsRuntimeBlockRates.length > 0
+    ? Number((weeklyOpsRuntimeBlockRates.reduce((sum, value) => sum + value, 0) / weeklyOpsRuntimeBlockRates.length).toFixed(2))
+    : null;
+  const weeklyOpsRuntimeBlockRateMax = weeklyOpsRuntimeBlockRates.length > 0
+    ? Number(Math.max(...weeklyOpsRuntimeBlockRates).toFixed(2))
+    : null;
+  const weeklyOpsRuntimeUiModeViolationRateAvg = weeklyOpsRuntimeUiModeViolationRates.length > 0
+    ? Number((weeklyOpsRuntimeUiModeViolationRates.reduce((sum, value) => sum + value, 0) / weeklyOpsRuntimeUiModeViolationRates.length).toFixed(2))
+    : null;
+  const weeklyOpsRuntimeUiModeViolationRateMax = weeklyOpsRuntimeUiModeViolationRates.length > 0
+    ? Number(Math.max(...weeklyOpsRuntimeUiModeViolationRates).toFixed(2))
+    : null;
+  const weeklyOpsRuntimeUiModeViolationRunRate = weeklyOpsRuntimeUiModeViolationKnownRuns > 0
+    ? Number(((weeklyOpsRuntimeUiModeViolationRuns / weeklyOpsRuntimeUiModeViolationKnownRuns) * 100).toFixed(2))
+    : null;
   const preflightAvailabilityRate = preflightKnownRuns > 0
     ? Number(((preflightAvailableRuns / preflightKnownRuns) * 100).toFixed(2))
     : null;
@@ -9722,6 +10251,28 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
     drift_blocked_runs: driftBlockedRuns,
     drift_alert_rate_percent: driftAlertRate,
     drift_block_rate_percent: driftBlockRate,
+    weekly_ops_known_runs: weeklyOpsKnownRuns,
+    weekly_ops_blocked_runs: weeklyOpsBlockedRuns,
+    weekly_ops_block_rate_percent: weeklyOpsBlockRate,
+    weekly_ops_violations_total: weeklyOpsViolationsTotal,
+    weekly_ops_warnings_total: weeklyOpsWarningsTotal,
+    weekly_ops_config_warnings_total: weeklyOpsConfigWarningsTotal,
+    weekly_ops_config_warning_runs: weeklyOpsConfigWarningRuns,
+    weekly_ops_config_warning_run_rate_percent: weeklyOpsConfigWarningRunRate,
+    weekly_ops_authorization_tier_block_rate_avg_percent: weeklyOpsAuthorizationTierBlockRateAvg,
+    weekly_ops_authorization_tier_block_rate_max_percent: weeklyOpsAuthorizationTierBlockRateMax,
+    weekly_ops_dialogue_authorization_block_rate_avg_percent: weeklyOpsDialogueAuthorizationBlockRateAvg,
+    weekly_ops_dialogue_authorization_block_rate_max_percent: weeklyOpsDialogueAuthorizationBlockRateMax,
+    weekly_ops_matrix_regression_positive_rate_avg_percent: weeklyOpsMatrixRegressionPositiveRateAvg,
+    weekly_ops_matrix_regression_positive_rate_max_percent: weeklyOpsMatrixRegressionPositiveRateMax,
+    weekly_ops_runtime_block_rate_avg_percent: weeklyOpsRuntimeBlockRateAvg,
+    weekly_ops_runtime_block_rate_max_percent: weeklyOpsRuntimeBlockRateMax,
+    weekly_ops_runtime_ui_mode_violation_known_runs: weeklyOpsRuntimeUiModeViolationKnownRuns,
+    weekly_ops_runtime_ui_mode_violation_runs: weeklyOpsRuntimeUiModeViolationRuns,
+    weekly_ops_runtime_ui_mode_violation_run_rate_percent: weeklyOpsRuntimeUiModeViolationRunRate,
+    weekly_ops_runtime_ui_mode_violation_total: weeklyOpsRuntimeUiModeViolationTotal,
+    weekly_ops_runtime_ui_mode_violation_rate_avg_percent: weeklyOpsRuntimeUiModeViolationRateAvg,
+    weekly_ops_runtime_ui_mode_violation_rate_max_percent: weeklyOpsRuntimeUiModeViolationRateMax,
     release_gate_preflight_known_runs: preflightKnownRuns,
     release_gate_preflight_available_runs: preflightAvailableRuns,
     release_gate_preflight_blocked_runs: preflightBlockedRuns,
@@ -9786,6 +10337,18 @@ async function buildAutoHandoffReleaseGateHistoryIndex(projectPath, options = {}
         release_gate_preflight_available: latestEntry.release_gate_preflight_available,
         release_gate_preflight_blocked: latestEntry.release_gate_preflight_blocked,
         require_release_gate_preflight: latestEntry.require_release_gate_preflight,
+        weekly_ops_blocked: latestEntry.weekly_ops_blocked,
+        weekly_ops_risk_level: latestEntry.weekly_ops_risk_level,
+        weekly_ops_governance_status: latestEntry.weekly_ops_governance_status,
+        weekly_ops_authorization_tier_block_rate_percent: latestEntry.weekly_ops_authorization_tier_block_rate_percent,
+        weekly_ops_dialogue_authorization_block_rate_percent: latestEntry.weekly_ops_dialogue_authorization_block_rate_percent,
+        weekly_ops_matrix_regression_positive_rate_percent: latestEntry.weekly_ops_matrix_regression_positive_rate_percent,
+        weekly_ops_runtime_block_rate_percent: latestEntry.weekly_ops_runtime_block_rate_percent,
+        weekly_ops_runtime_ui_mode_violation_total: latestEntry.weekly_ops_runtime_ui_mode_violation_total,
+        weekly_ops_runtime_ui_mode_violation_rate_percent: latestEntry.weekly_ops_runtime_ui_mode_violation_rate_percent,
+        weekly_ops_violations_count: latestEntry.weekly_ops_violations_count,
+        weekly_ops_warning_count: latestEntry.weekly_ops_warning_count,
+        weekly_ops_config_warning_count: latestEntry.weekly_ops_config_warning_count,
         drift_alert_count: latestEntry.drift_alert_count,
         drift_blocked: latestEntry.drift_blocked
       }
@@ -9833,6 +10396,18 @@ function renderAutoHandoffReleaseGateHistoryMarkdown(payload = {}) {
     lines.push(`- Release preflight available: ${latest.release_gate_preflight_available === true ? 'yes' : (latest.release_gate_preflight_available === false ? 'no' : 'n/a')}`);
     lines.push(`- Release preflight blocked: ${latest.release_gate_preflight_blocked === true ? 'yes' : (latest.release_gate_preflight_blocked === false ? 'no' : 'n/a')}`);
     lines.push(`- Release preflight hard-gate: ${latest.require_release_gate_preflight === true ? 'enabled' : (latest.require_release_gate_preflight === false ? 'advisory' : 'n/a')}`);
+    lines.push(`- Weekly ops blocked: ${latest.weekly_ops_blocked === true ? 'yes' : (latest.weekly_ops_blocked === false ? 'no' : 'n/a')}`);
+    lines.push(`- Weekly ops risk: ${formatAutoHandoffRegressionValue(latest.weekly_ops_risk_level)}`);
+    lines.push(`- Weekly ops governance status: ${formatAutoHandoffRegressionValue(latest.weekly_ops_governance_status)}`);
+    lines.push(`- Weekly ops auth-tier block rate: ${formatAutoHandoffRegressionValue(latest.weekly_ops_authorization_tier_block_rate_percent)}%`);
+    lines.push(`- Weekly ops dialogue-auth block rate: ${formatAutoHandoffRegressionValue(latest.weekly_ops_dialogue_authorization_block_rate_percent)}%`);
+    lines.push(`- Weekly ops matrix regression-positive rate: ${formatAutoHandoffRegressionValue(latest.weekly_ops_matrix_regression_positive_rate_percent)}%`);
+    lines.push(`- Weekly ops runtime block rate: ${formatAutoHandoffRegressionValue(latest.weekly_ops_runtime_block_rate_percent)}%`);
+    lines.push(`- Weekly ops runtime ui-mode violations: ${formatAutoHandoffRegressionValue(latest.weekly_ops_runtime_ui_mode_violation_total, '0')}`);
+    lines.push(`- Weekly ops runtime ui-mode violation rate: ${formatAutoHandoffRegressionValue(latest.weekly_ops_runtime_ui_mode_violation_rate_percent)}%`);
+    lines.push(`- Weekly ops violations: ${formatAutoHandoffRegressionValue(latest.weekly_ops_violations_count, '0')}`);
+    lines.push(`- Weekly ops warnings: ${formatAutoHandoffRegressionValue(latest.weekly_ops_warning_count, '0')}`);
+    lines.push(`- Weekly ops config warnings: ${formatAutoHandoffRegressionValue(latest.weekly_ops_config_warning_count, '0')}`);
     lines.push(`- Drift alerts: ${formatAutoHandoffRegressionValue(latest.drift_alert_count, '0')}`);
     lines.push(`- Drift blocked: ${latest.drift_blocked === true ? 'yes' : (latest.drift_blocked === false ? 'no' : 'n/a')}`);
     lines.push('');
@@ -9861,6 +10436,23 @@ function renderAutoHandoffReleaseGateHistoryMarkdown(payload = {}) {
   lines.push(`- Drift blocked runs: ${formatAutoHandoffRegressionValue(aggregates.drift_blocked_runs, '0')}`);
   lines.push(`- Drift alert rate: ${formatAutoHandoffRegressionValue(aggregates.drift_alert_rate_percent)}%`);
   lines.push(`- Drift block rate: ${formatAutoHandoffRegressionValue(aggregates.drift_block_rate_percent)}%`);
+  lines.push(`- Weekly ops known runs: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_known_runs, '0')}`);
+  lines.push(`- Weekly ops blocked runs: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_blocked_runs, '0')}`);
+  lines.push(`- Weekly ops block rate: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_block_rate_percent)}%`);
+  lines.push(`- Weekly ops violations total: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_violations_total, '0')}`);
+  lines.push(`- Weekly ops warnings total: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_warnings_total, '0')}`);
+  lines.push(`- Weekly ops config warnings total: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_config_warnings_total, '0')}`);
+  lines.push(`- Weekly ops config warning runs: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_config_warning_runs, '0')}`);
+  lines.push(`- Weekly ops config warning run rate: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_config_warning_run_rate_percent)}%`);
+  lines.push(`- Weekly ops auth-tier block rate avg/max: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_authorization_tier_block_rate_avg_percent)}/${formatAutoHandoffRegressionValue(aggregates.weekly_ops_authorization_tier_block_rate_max_percent)}%`);
+  lines.push(`- Weekly ops dialogue-auth block rate avg/max: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_dialogue_authorization_block_rate_avg_percent)}/${formatAutoHandoffRegressionValue(aggregates.weekly_ops_dialogue_authorization_block_rate_max_percent)}%`);
+  lines.push(`- Weekly ops matrix regression-positive rate avg/max: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_matrix_regression_positive_rate_avg_percent)}/${formatAutoHandoffRegressionValue(aggregates.weekly_ops_matrix_regression_positive_rate_max_percent)}%`);
+  lines.push(`- Weekly ops runtime block rate avg/max: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_runtime_block_rate_avg_percent)}/${formatAutoHandoffRegressionValue(aggregates.weekly_ops_runtime_block_rate_max_percent)}%`);
+  lines.push(`- Weekly ops runtime ui-mode known runs: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_runtime_ui_mode_violation_known_runs, '0')}`);
+  lines.push(`- Weekly ops runtime ui-mode violation runs: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_runtime_ui_mode_violation_runs, '0')}`);
+  lines.push(`- Weekly ops runtime ui-mode violation run rate: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_runtime_ui_mode_violation_run_rate_percent)}%`);
+  lines.push(`- Weekly ops runtime ui-mode violations total: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_runtime_ui_mode_violation_total, '0')}`);
+  lines.push(`- Weekly ops runtime ui-mode violation rate avg/max: ${formatAutoHandoffRegressionValue(aggregates.weekly_ops_runtime_ui_mode_violation_rate_avg_percent)}/${formatAutoHandoffRegressionValue(aggregates.weekly_ops_runtime_ui_mode_violation_rate_max_percent)}%`);
   lines.push(`- Release preflight known runs: ${formatAutoHandoffRegressionValue(aggregates.release_gate_preflight_known_runs, '0')}`);
   lines.push(`- Release preflight available runs: ${formatAutoHandoffRegressionValue(aggregates.release_gate_preflight_available_runs, '0')}`);
   lines.push(`- Release preflight blocked runs: ${formatAutoHandoffRegressionValue(aggregates.release_gate_preflight_blocked_runs, '0')}`);
@@ -9906,11 +10498,38 @@ function renderAutoHandoffReleaseGateHistoryMarkdown(payload = {}) {
       const driftBlocked = entry && entry.drift_blocked === true
         ? 'yes'
         : (entry && entry.drift_blocked === false ? 'no' : 'n/a');
+      const weeklyOpsBlocked = entry && entry.weekly_ops_blocked === true
+        ? 'yes'
+        : (entry && entry.weekly_ops_blocked === false ? 'no' : 'n/a');
+      const weeklyOpsConfigWarnings = formatAutoHandoffRegressionValue(
+        entry && entry.weekly_ops_config_warning_count,
+        '0'
+      );
+      const weeklyOpsDialogueRate = formatAutoHandoffRegressionValue(
+        entry && entry.weekly_ops_dialogue_authorization_block_rate_percent
+      );
+      const weeklyOpsAuthTierRate = formatAutoHandoffRegressionValue(
+        entry && entry.weekly_ops_authorization_tier_block_rate_percent
+      );
+      const weeklyOpsRuntimeBlockRate = formatAutoHandoffRegressionValue(
+        entry && entry.weekly_ops_runtime_block_rate_percent
+      );
+      const weeklyOpsRuntimeUiModeViolationTotal = formatAutoHandoffRegressionValue(
+        entry && entry.weekly_ops_runtime_ui_mode_violation_total,
+        '0'
+      );
+      const weeklyOpsRuntimeUiModeViolationRate = formatAutoHandoffRegressionValue(
+        entry && entry.weekly_ops_runtime_ui_mode_violation_rate_percent
+      );
       lines.push(
         `- ${tag} | passed=${passed} | risk=${risk} | scene-batch=${sceneBatch} | ` +
         `scene-failures=${sceneBatchFailures} | capability-unknown=${capabilityExpectedUnknown}/${capabilityProvidedUnknown} | ` +
         `preflight-blocked=${preflightBlocked} | hard-gate=${preflightHardGate} | ` +
         `drift-alerts=${driftAlerts} | drift-blocked=${driftBlocked} | ` +
+        `weekly-blocked=${weeklyOpsBlocked} | weekly-config-warnings=${weeklyOpsConfigWarnings} | ` +
+        `weekly-auth-tier-rate=${weeklyOpsAuthTierRate}% | weekly-dialogue-rate=${weeklyOpsDialogueRate}% | ` +
+        `weekly-runtime-block-rate=${weeklyOpsRuntimeBlockRate}% | ` +
+        `weekly-runtime-ui-mode=${weeklyOpsRuntimeUiModeViolationTotal}/${weeklyOpsRuntimeUiModeViolationRate}% | ` +
         `success=${successRate} | violations=${violations} | at=${evaluatedAt}`
       );
     });
@@ -10239,6 +10858,9 @@ function renderAutoHandoffEvidenceReviewMarkdown(payload = {}) {
     `- Scene batch pass rate: ${formatAutoHandoffRegressionValue(releaseGatePreflight.scene_package_batch_pass_rate_percent)}%`,
     `- Drift alert rate: ${formatAutoHandoffRegressionValue(releaseGatePreflight.drift_alert_rate_percent)}%`,
     `- Drift blocked runs: ${formatAutoHandoffRegressionValue(releaseGatePreflight.drift_blocked_runs)}`,
+    `- Runtime block rate (latest/max): ${formatAutoHandoffRegressionValue(releaseGatePreflight.latest_weekly_ops_runtime_block_rate_percent)}/${formatAutoHandoffRegressionValue(releaseGatePreflight.weekly_ops_runtime_block_rate_max_percent)}%`,
+    `- Runtime ui-mode violations (latest/total): ${formatAutoHandoffRegressionValue(releaseGatePreflight.latest_weekly_ops_runtime_ui_mode_violation_total, '0')}/${formatAutoHandoffRegressionValue(releaseGatePreflight.weekly_ops_runtime_ui_mode_violation_total, '0')}`,
+    `- Runtime ui-mode violation rate (latest/run-rate/max): ${formatAutoHandoffRegressionValue(releaseGatePreflight.latest_weekly_ops_runtime_ui_mode_violation_rate_percent)}/${formatAutoHandoffRegressionValue(releaseGatePreflight.weekly_ops_runtime_ui_mode_violation_run_rate_percent)}/${formatAutoHandoffRegressionValue(releaseGatePreflight.weekly_ops_runtime_ui_mode_violation_rate_max_percent)}%`,
     `- Reasons: ${Array.isArray(releaseGatePreflight.reasons) && releaseGatePreflight.reasons.length > 0 ? releaseGatePreflight.reasons.join(' | ') : 'none'}`,
     `- Parse error: ${formatAutoHandoffRegressionValue(releaseGatePreflight.parse_error)}`,
     '',
@@ -10547,6 +11169,9 @@ function renderAutoHandoffReleaseNotesDraft(payload = {}, context = {}) {
     `- Release gate preflight blocked: ${releaseGatePreflight.blocked === true ? 'yes' : 'no'}`,
     `- Release gate preflight hard-gate: ${currentPolicy.require_release_gate_preflight === true ? 'enabled' : 'advisory'}`,
     `- Release gate preflight reasons: ${Array.isArray(releaseGatePreflight.reasons) && releaseGatePreflight.reasons.length > 0 ? releaseGatePreflight.reasons.join(' | ') : 'none'}`,
+    `- Release gate runtime block rate (latest/max): ${formatAutoHandoffRegressionValue(releaseGatePreflight.latest_weekly_ops_runtime_block_rate_percent)}/${formatAutoHandoffRegressionValue(releaseGatePreflight.weekly_ops_runtime_block_rate_max_percent)}%`,
+    `- Release gate runtime ui-mode violations (latest/total): ${formatAutoHandoffRegressionValue(releaseGatePreflight.latest_weekly_ops_runtime_ui_mode_violation_total, '0')}/${formatAutoHandoffRegressionValue(releaseGatePreflight.weekly_ops_runtime_ui_mode_violation_total, '0')}`,
+    `- Release gate runtime ui-mode violation rate (latest/run-rate/max): ${formatAutoHandoffRegressionValue(releaseGatePreflight.latest_weekly_ops_runtime_ui_mode_violation_rate_percent)}/${formatAutoHandoffRegressionValue(releaseGatePreflight.weekly_ops_runtime_ui_mode_violation_run_rate_percent)}/${formatAutoHandoffRegressionValue(releaseGatePreflight.weekly_ops_runtime_ui_mode_violation_rate_max_percent)}%`,
     `- Failure summary highlights: ${Array.isArray(failureSummary.highlights) && failureSummary.highlights.length > 0 ? failureSummary.highlights.join(' | ') : 'none'}`,
     `- Spec success rate: ${formatAutoHandoffRegressionValue(gateActual.spec_success_rate_percent)}`,
     `- Risk level: ${formatAutoHandoffRegressionValue(gateActual.risk_level)}`,
@@ -11636,73 +12261,351 @@ function buildAutoHandoffReleaseGatePreflight(signals = null) {
     drift_alert_rate_percent: toNumber(source.drift_alert_rate_percent),
     drift_alert_runs: toNumber(source.drift_alert_runs),
     drift_blocked_runs: toNumber(source.drift_blocked_runs),
+    latest_weekly_ops_runtime_block_rate_percent: toNumber(
+      source.latest_weekly_ops_runtime_block_rate_percent
+    ),
+    latest_weekly_ops_runtime_ui_mode_violation_total: toNumber(
+      source.latest_weekly_ops_runtime_ui_mode_violation_total
+    ),
+    latest_weekly_ops_runtime_ui_mode_violation_rate_percent: toNumber(
+      source.latest_weekly_ops_runtime_ui_mode_violation_rate_percent
+    ),
+    weekly_ops_runtime_block_rate_max_percent: toNumber(
+      source.weekly_ops_runtime_block_rate_max_percent
+    ),
+    weekly_ops_runtime_ui_mode_violation_total: toNumber(
+      source.weekly_ops_runtime_ui_mode_violation_total
+    ),
+    weekly_ops_runtime_ui_mode_violation_run_rate_percent: toNumber(
+      source.weekly_ops_runtime_ui_mode_violation_run_rate_percent
+    ),
+    weekly_ops_runtime_ui_mode_violation_rate_max_percent: toNumber(
+      source.weekly_ops_runtime_ui_mode_violation_rate_max_percent
+    ),
     parse_error: normalizeHandoffText(source.parse_error),
     blocked: blockState.blocked === true,
     reasons: Array.isArray(blockState.reasons) ? blockState.reasons : []
   };
 }
 
-function buildAutoHandoffRunFailureSummary(result = {}) {
-  const phases = Array.isArray(result && result.phases) ? result.phases : [];
-  const failedPhase = phases.find(item => item && item.status === 'failed') || null;
-  const gates = result && result.gates && typeof result.gates === 'object'
-    ? result.gates
+function buildAutoHandoffPreflightCheckRecommendations(projectPath, result = {}) {
+  const recommendations = [];
+  const seen = new Set();
+  const push = value => {
+    const text = `${value || ''}`.trim();
+    if (!text || seen.has(text)) {
+      return;
+    }
+    seen.add(text);
+    recommendations.push(text);
+  };
+
+  const policy = result && result.policy && typeof result.policy === 'object'
+    ? result.policy
     : {};
-  const gateReasons = Array.isArray(gates.reasons) ? gates.reasons : [];
-  const releaseGatePreflight = result && result.release_gate_preflight && typeof result.release_gate_preflight === 'object'
+  const preflight = result && result.release_gate_preflight && typeof result.release_gate_preflight === 'object'
     ? result.release_gate_preflight
-    : null;
-  const releaseGateReasons = releaseGatePreflight && Array.isArray(releaseGatePreflight.reasons)
-    ? releaseGatePreflight.reasons
-    : [];
-  const moquiBaseline = result && result.moqui_baseline && typeof result.moqui_baseline === 'object'
-    ? result.moqui_baseline
-    : null;
-  const moquiCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
-    ? moquiBaseline.compare
     : {};
-  const moquiMatrixRegressions = buildAutoHandoffMoquiCoverageRegressions(moquiCompare);
-  const highlights = [];
-  if (typeof result.error === 'string' && result.error.trim()) {
-    highlights.push(`error: ${result.error.trim()}`);
+  const reasons = Array.isArray(result.reasons) ? result.reasons : [];
+  const windowSize = Number.isInteger(policy.release_evidence_window)
+    ? policy.release_evidence_window
+    : 5;
+
+  if (preflight.available !== true || preflight.parse_error) {
+    push(
+      'sce auto handoff gate-index ' +
+      '--dir .kiro/reports/release-evidence ' +
+      '--out .kiro/reports/release-evidence/release-gate-history.json --json'
+    );
   }
-  if (gateReasons.length > 0) {
-    highlights.push(`gate: ${gateReasons.join('; ')}`);
+  if (result.status !== 'pass' || preflight.blocked === true) {
+    push(`sce auto handoff evidence --window ${windowSize} --json`);
   }
-  if (releaseGatePreflight && releaseGatePreflight.blocked === true) {
-    highlights.push(
-      `release_gate_preflight: ${releaseGateReasons.length > 0 ? releaseGateReasons.join('; ') : 'blocked'}`
+
+  if (preflight.blocked === true) {
+    const governanceRecommendations = buildGovernanceCloseLoopRecommendations(
+      {
+        health: {
+          recommendations: []
+        }
+      },
+      'release-gate-blocked',
+      {
+        reasons: Array.isArray(preflight.reasons) ? preflight.reasons : []
+      }
     );
+    for (const item of governanceRecommendations) {
+      push(item);
+    }
   }
-  if (failedPhase && failedPhase.id) {
-    highlights.push(`phase: ${failedPhase.id}${failedPhase.error ? ` (${failedPhase.error})` : ''}`);
+
+  if (reasons.some(item => `${item}`.includes('parse error'))) {
+    push(
+      'Review and repair release gate history JSON, then rerun `sce auto handoff preflight-check --json`.'
+    );
   }
-  if (moquiMatrixRegressions.length > 0) {
-    highlights.push(
-      `moqui_matrix_regression: ${moquiMatrixRegressions.slice(0, 3).map(item => `${item.label}:${item.delta_rate_percent}%`).join(' | ')}`
+  if (
+    reasons.some(item => `${item}`.includes('unavailable') || `${item}`.includes('snapshot missing'))
+  ) {
+    push(
+      'Ensure release workflow publishes `release-gate-history.json` and rerun preflight check.'
     );
   }
-  return {
-    status: normalizeHandoffText(result && result.status),
-    failed_phase: failedPhase
-      ? {
-        id: normalizeHandoffText(failedPhase.id),
-        title: normalizeHandoffText(failedPhase.title),
-        error: normalizeHandoffText(failedPhase.error)
-      }
-      : null,
-    gate_failed: gates.passed === false,
-    gate_reasons: gateReasons,
-    moqui_matrix_regressions: moquiMatrixRegressions,
-    release_gate_preflight_blocked: Boolean(releaseGatePreflight && releaseGatePreflight.blocked === true),
-    release_gate_preflight_reasons: releaseGateReasons,
-    highlights
-  };
+
+  return recommendations;
 }
 
-function collectHandoffBlockers(resultItem) {
-  const blockers = [];
-  if (!resultItem) {
+async function buildAutoHandoffPreflightCheck(projectPath, options = {}) {
+  const policy = buildAutoHandoffRunPolicy(options);
+  const releaseGateSignals = await loadGovernanceReleaseGateSignals(projectPath, {
+    historyFile: options.historyFile
+  });
+  const releaseGatePreflight = buildAutoHandoffReleaseGatePreflight(releaseGateSignals);
+  const hardGateReasons = evaluateAutoHandoffReleaseGatePreflightGateReasons(
+    policy,
+    releaseGatePreflight
+  );
+
+  const advisoryReasons = [];
+  if (hardGateReasons.length === 0) {
+    if (releaseGatePreflight.parse_error) {
+      advisoryReasons.push(`release gate preflight parse error: ${releaseGatePreflight.parse_error}`);
+    } else if (releaseGatePreflight.available !== true) {
+      advisoryReasons.push('release gate preflight unavailable (advisory mode)');
+    } else if (releaseGatePreflight.blocked === true) {
+      const reasonText = Array.isArray(releaseGatePreflight.reasons) && releaseGatePreflight.reasons.length > 0
+        ? releaseGatePreflight.reasons.join('; ')
+        : 'release gate blocked';
+      advisoryReasons.push(`release gate preflight blocked (advisory mode): ${reasonText}`);
+    }
+  }
+
+  const status = hardGateReasons.length > 0
+    ? 'blocked'
+    : (advisoryReasons.length > 0 ? 'warning' : 'pass');
+  const reasons = hardGateReasons.length > 0 ? hardGateReasons : advisoryReasons;
+  const result = {
+    mode: 'auto-handoff-preflight-check',
+    generated_at: new Date().toISOString(),
+    status,
+    reasons,
+    hard_gate_reasons: hardGateReasons,
+    policy: {
+      profile: policy.profile,
+      require_release_gate_preflight: policy.require_release_gate_preflight === true,
+      release_evidence_window: policy.release_evidence_window
+    },
+    release_gate_preflight: releaseGatePreflight,
+    signals: {
+      history_file: releaseGateSignals.file || releaseGatePreflight.file || null,
+      total_entries: releaseGateSignals.total_entries,
+      latest: {
+        tag: releaseGatePreflight.latest_tag,
+        gate_passed: releaseGatePreflight.latest_gate_passed,
+        risk_level: releaseGatePreflight.latest_risk_level,
+        weekly_ops_runtime_block_rate_percent:
+          releaseGatePreflight.latest_weekly_ops_runtime_block_rate_percent,
+        weekly_ops_runtime_ui_mode_violation_total:
+          releaseGatePreflight.latest_weekly_ops_runtime_ui_mode_violation_total,
+        weekly_ops_runtime_ui_mode_violation_rate_percent:
+          releaseGatePreflight.latest_weekly_ops_runtime_ui_mode_violation_rate_percent
+      },
+      aggregates: {
+        pass_rate_percent: releaseGatePreflight.pass_rate_percent,
+        scene_package_batch_pass_rate_percent: releaseGatePreflight.scene_package_batch_pass_rate_percent,
+        drift_alert_rate_percent: releaseGatePreflight.drift_alert_rate_percent,
+        drift_blocked_runs: releaseGatePreflight.drift_blocked_runs,
+        weekly_ops_runtime_block_rate_max_percent:
+          releaseGatePreflight.weekly_ops_runtime_block_rate_max_percent,
+        weekly_ops_runtime_ui_mode_violation_total:
+          releaseGatePreflight.weekly_ops_runtime_ui_mode_violation_total,
+        weekly_ops_runtime_ui_mode_violation_run_rate_percent:
+          releaseGatePreflight.weekly_ops_runtime_ui_mode_violation_run_rate_percent,
+        weekly_ops_runtime_ui_mode_violation_rate_max_percent:
+          releaseGatePreflight.weekly_ops_runtime_ui_mode_violation_rate_max_percent
+      }
+    },
+    recommended_commands: []
+  };
+  result.recommended_commands = buildAutoHandoffPreflightCheckRecommendations(projectPath, result);
+  return result;
+}
+
+function extractAutoObservabilityWeeklyOpsStopTelemetry(observabilitySnapshotCandidate) {
+  const observabilitySnapshot = observabilitySnapshotCandidate &&
+    typeof observabilitySnapshotCandidate === 'object' &&
+    !Array.isArray(observabilitySnapshotCandidate)
+    ? observabilitySnapshotCandidate
+    : null;
+  if (!observabilitySnapshot) {
+    return null;
+  }
+  const highlights = observabilitySnapshot.highlights && typeof observabilitySnapshot.highlights === 'object'
+    ? observabilitySnapshot.highlights
+    : {};
+  const snapshots = observabilitySnapshot.snapshots && typeof observabilitySnapshot.snapshots === 'object'
+    ? observabilitySnapshot.snapshots
+    : {};
+  const weeklyOpsStop = snapshots.governance_weekly_ops_stop && typeof snapshots.governance_weekly_ops_stop === 'object'
+    ? snapshots.governance_weekly_ops_stop
+    : {};
+  const toNumber = value => {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  };
+  const pickNumber = (primary, fallback) => (
+    Number.isFinite(primary) ? primary : (Number.isFinite(fallback) ? fallback : null)
+  );
+
+  const sessions = pickNumber(
+    toNumber(highlights.governance_weekly_ops_stop_sessions),
+    toNumber(weeklyOpsStop.sessions)
+  );
+  const sessionRatePercent = pickNumber(
+    toNumber(highlights.governance_weekly_ops_stop_session_rate_percent),
+    toNumber(weeklyOpsStop.session_rate_percent)
+  );
+  const highPressureSessions = pickNumber(
+    toNumber(highlights.governance_weekly_ops_high_pressure_sessions),
+    toNumber(weeklyOpsStop.high_pressure_sessions)
+  );
+  const highPressureRatePercent = pickNumber(
+    toNumber(highlights.governance_weekly_ops_high_pressure_rate_percent),
+    toNumber(weeklyOpsStop.high_pressure_session_rate_percent)
+  );
+  const configWarningPositiveSessions = pickNumber(
+    toNumber(highlights.governance_weekly_ops_config_warning_positive_sessions),
+    toNumber(weeklyOpsStop.config_warning_positive_sessions)
+  );
+  const authTierPressureSessions = pickNumber(
+    toNumber(highlights.governance_weekly_ops_auth_tier_pressure_sessions),
+    toNumber(weeklyOpsStop.auth_tier_pressure_sessions)
+  );
+  const dialogueAuthorizationPressureSessions = pickNumber(
+    toNumber(highlights.governance_weekly_ops_dialogue_authorization_pressure_sessions),
+    toNumber(weeklyOpsStop.dialogue_authorization_pressure_sessions)
+  );
+  const runtimeBlockRateHighSessions = pickNumber(
+    toNumber(highlights.governance_weekly_ops_runtime_block_rate_high_sessions),
+    toNumber(weeklyOpsStop.runtime_block_rate_high_sessions)
+  );
+  const runtimeUiModeViolationHighSessions = pickNumber(
+    toNumber(highlights.governance_weekly_ops_runtime_ui_mode_violation_high_sessions),
+    toNumber(weeklyOpsStop.runtime_ui_mode_violation_high_sessions)
+  );
+  const runtimeUiModeViolationTotalSum = pickNumber(
+    toNumber(highlights.governance_weekly_ops_runtime_ui_mode_violation_total_sum),
+    toNumber(weeklyOpsStop.runtime_ui_mode_violation_total_sum)
+  );
+  const hasSignal = (
+    Number.isFinite(sessions) ||
+    Number.isFinite(sessionRatePercent) ||
+    Number.isFinite(highPressureSessions) ||
+    Number.isFinite(highPressureRatePercent) ||
+    Number.isFinite(configWarningPositiveSessions) ||
+    Number.isFinite(authTierPressureSessions) ||
+    Number.isFinite(dialogueAuthorizationPressureSessions) ||
+    Number.isFinite(runtimeBlockRateHighSessions) ||
+    Number.isFinite(runtimeUiModeViolationHighSessions) ||
+    Number.isFinite(runtimeUiModeViolationTotalSum)
+  );
+  if (!hasSignal) {
+    return null;
+  }
+  return {
+    sessions,
+    session_rate_percent: sessionRatePercent,
+    high_pressure_sessions: highPressureSessions,
+    high_pressure_rate_percent: highPressureRatePercent,
+    config_warning_positive_sessions: configWarningPositiveSessions,
+    auth_tier_pressure_sessions: authTierPressureSessions,
+    dialogue_authorization_pressure_sessions: dialogueAuthorizationPressureSessions,
+    runtime_block_rate_high_sessions: runtimeBlockRateHighSessions,
+    runtime_ui_mode_violation_high_sessions: runtimeUiModeViolationHighSessions,
+    runtime_ui_mode_violation_total_sum: runtimeUiModeViolationTotalSum
+  };
+}
+
+function buildAutoHandoffRunFailureSummary(result = {}) {
+  const phases = Array.isArray(result && result.phases) ? result.phases : [];
+  const failedPhase = phases.find(item => item && item.status === 'failed') || null;
+  const gates = result && result.gates && typeof result.gates === 'object'
+    ? result.gates
+    : {};
+  const gateReasons = Array.isArray(gates.reasons) ? gates.reasons : [];
+  const releaseGatePreflight = result && result.release_gate_preflight && typeof result.release_gate_preflight === 'object'
+    ? result.release_gate_preflight
+    : null;
+  const releaseGateReasons = releaseGatePreflight && Array.isArray(releaseGatePreflight.reasons)
+    ? releaseGatePreflight.reasons
+    : [];
+  const moquiBaseline = result && result.moqui_baseline && typeof result.moqui_baseline === 'object'
+    ? result.moqui_baseline
+    : null;
+  const moquiCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
+    ? moquiBaseline.compare
+    : {};
+  const moquiMatrixRegressions = buildAutoHandoffMoquiCoverageRegressions(moquiCompare);
+  const observabilityWeeklyOps = extractAutoObservabilityWeeklyOpsStopTelemetry(
+    result && result.observability_snapshot
+  );
+  const highlights = [];
+  if (typeof result.error === 'string' && result.error.trim()) {
+    highlights.push(`error: ${result.error.trim()}`);
+  }
+  if (gateReasons.length > 0) {
+    highlights.push(`gate: ${gateReasons.join('; ')}`);
+  }
+  if (releaseGatePreflight && releaseGatePreflight.blocked === true) {
+    highlights.push(
+      `release_gate_preflight: ${releaseGateReasons.length > 0 ? releaseGateReasons.join('; ') : 'blocked'}`
+    );
+  }
+  if (failedPhase && failedPhase.id) {
+    highlights.push(`phase: ${failedPhase.id}${failedPhase.error ? ` (${failedPhase.error})` : ''}`);
+  }
+  if (moquiMatrixRegressions.length > 0) {
+    highlights.push(
+      `moqui_matrix_regression: ${moquiMatrixRegressions.slice(0, 3).map(item => `${item.label}:${item.delta_rate_percent}%`).join(' | ')}`
+    );
+  }
+  if (
+    observabilityWeeklyOps &&
+    Number.isFinite(observabilityWeeklyOps.sessions) &&
+    observabilityWeeklyOps.sessions > 0
+  ) {
+    highlights.push(
+      `observability_weekly_ops_stop: sessions=${observabilityWeeklyOps.sessions}, ` +
+      `high_pressure=${Number.isFinite(observabilityWeeklyOps.high_pressure_sessions) ? observabilityWeeklyOps.high_pressure_sessions : 0}, ` +
+      `config_warning=${Number.isFinite(observabilityWeeklyOps.config_warning_positive_sessions) ? observabilityWeeklyOps.config_warning_positive_sessions : 0}, ` +
+      `auth_tier=${Number.isFinite(observabilityWeeklyOps.auth_tier_pressure_sessions) ? observabilityWeeklyOps.auth_tier_pressure_sessions : 0}, ` +
+      `dialogue=${Number.isFinite(observabilityWeeklyOps.dialogue_authorization_pressure_sessions) ? observabilityWeeklyOps.dialogue_authorization_pressure_sessions : 0}, ` +
+      `runtime_block=${Number.isFinite(observabilityWeeklyOps.runtime_block_rate_high_sessions) ? observabilityWeeklyOps.runtime_block_rate_high_sessions : 0}, ` +
+      `runtime_ui_mode=${Number.isFinite(observabilityWeeklyOps.runtime_ui_mode_violation_high_sessions) ? observabilityWeeklyOps.runtime_ui_mode_violation_high_sessions : 0}, ` +
+      `runtime_ui_mode_total=${Number.isFinite(observabilityWeeklyOps.runtime_ui_mode_violation_total_sum) ? observabilityWeeklyOps.runtime_ui_mode_violation_total_sum : 0}`
+    );
+  }
+  return {
+    status: normalizeHandoffText(result && result.status),
+    failed_phase: failedPhase
+      ? {
+        id: normalizeHandoffText(failedPhase.id),
+        title: normalizeHandoffText(failedPhase.title),
+        error: normalizeHandoffText(failedPhase.error)
+      }
+      : null,
+    gate_failed: gates.passed === false,
+    gate_reasons: gateReasons,
+    moqui_matrix_regressions: moquiMatrixRegressions,
+    release_gate_preflight_blocked: Boolean(releaseGatePreflight && releaseGatePreflight.blocked === true),
+    release_gate_preflight_reasons: releaseGateReasons,
+    highlights
+  };
+}
+
+function collectHandoffBlockers(resultItem) {
+  const blockers = [];
+  if (!resultItem) {
     return blockers;
   }
   if (typeof resultItem.error === 'string' && resultItem.error.trim().length > 0) {
@@ -11937,6 +12840,9 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
     ? moquiBaseline.compare
     : {};
   const moquiCoverageRegressions = buildAutoHandoffMoquiCoverageRegressions(moquiCompare);
+  const observabilityWeeklyOps = extractAutoObservabilityWeeklyOpsStopTelemetry(
+    result && result.observability_snapshot
+  );
   const pushMoquiClusterFirstRecoverySequence = () => {
     const lines = buildMoquiRegressionRecoverySequenceLines({
       clusterGoalsArg: quoteCliArg(AUTO_HANDOFF_MOQUI_CLUSTER_REMEDIATION_FILE),
@@ -12034,6 +12940,61 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
   if (riskLevel === 'high') {
     push('sce auto governance stats --days 14 --json');
   }
+  if (
+    observabilityWeeklyOps &&
+    Number.isFinite(observabilityWeeklyOps.sessions) &&
+    observabilityWeeklyOps.sessions > 0
+  ) {
+    push('node scripts/release-ops-weekly-summary.js --json');
+    push('node scripts/release-weekly-ops-gate.js');
+    if (
+      Number.isFinite(observabilityWeeklyOps.config_warning_positive_sessions) &&
+      observabilityWeeklyOps.config_warning_positive_sessions > 0
+    ) {
+      push(
+        'Fix invalid weekly ops threshold variables (`KSE_RELEASE_WEEKLY_OPS_*`) and rerun release gates ' +
+        'to clear config warnings.'
+      );
+    }
+    if (
+      Number.isFinite(observabilityWeeklyOps.auth_tier_pressure_sessions) &&
+      observabilityWeeklyOps.auth_tier_pressure_sessions > 0
+    ) {
+      push(
+        'node scripts/interactive-authorization-tier-evaluate.js ' +
+        '--policy docs/interactive-customization/authorization-tier-policy-baseline.json --json'
+      );
+    }
+    if (
+      Number.isFinite(observabilityWeeklyOps.dialogue_authorization_pressure_sessions) &&
+      observabilityWeeklyOps.dialogue_authorization_pressure_sessions > 0
+    ) {
+      push(
+        'node scripts/interactive-dialogue-governance.js ' +
+        '--policy docs/interactive-customization/dialogue-governance-policy-baseline.json ' +
+        '--authorization-dialogue-policy docs/interactive-customization/authorization-dialogue-policy-baseline.json --json'
+      );
+    }
+    if (
+      Number.isFinite(observabilityWeeklyOps.runtime_ui_mode_violation_high_sessions) &&
+      observabilityWeeklyOps.runtime_ui_mode_violation_high_sessions > 0
+    ) {
+      push('node scripts/interactive-governance-report.js --period weekly --fail-on-alert --json');
+      push(
+        'Review runtime ui-mode contract in docs/interactive-customization/runtime-mode-policy-baseline.json ' +
+        'to keep user-app suggestion-only and route apply actions to ops-console.'
+      );
+    }
+    if (
+      Number.isFinite(observabilityWeeklyOps.runtime_block_rate_high_sessions) &&
+      observabilityWeeklyOps.runtime_block_rate_high_sessions > 0
+    ) {
+      push(
+        'Tune runtime deny/review pressure and rerun ' +
+        'node scripts/interactive-governance-report.js --period weekly --json'
+      );
+    }
+  }
 
   if (result && result.remediation_queue && result.remediation_queue.file) {
     push(
@@ -14193,7 +15154,21 @@ async function runAutoHandoff(projectPath, options = {}) {
           available: result.release_gate_preflight.available,
           blocked: result.release_gate_preflight.blocked,
           latest_tag: result.release_gate_preflight.latest_tag,
-          latest_gate_passed: result.release_gate_preflight.latest_gate_passed
+          latest_gate_passed: result.release_gate_preflight.latest_gate_passed,
+          latest_weekly_ops_runtime_block_rate_percent:
+            result.release_gate_preflight.latest_weekly_ops_runtime_block_rate_percent,
+          latest_weekly_ops_runtime_ui_mode_violation_total:
+            result.release_gate_preflight.latest_weekly_ops_runtime_ui_mode_violation_total,
+          latest_weekly_ops_runtime_ui_mode_violation_rate_percent:
+            result.release_gate_preflight.latest_weekly_ops_runtime_ui_mode_violation_rate_percent,
+          weekly_ops_runtime_block_rate_max_percent:
+            result.release_gate_preflight.weekly_ops_runtime_block_rate_max_percent,
+          weekly_ops_runtime_ui_mode_violation_total:
+            result.release_gate_preflight.weekly_ops_runtime_ui_mode_violation_total,
+          weekly_ops_runtime_ui_mode_violation_run_rate_percent:
+            result.release_gate_preflight.weekly_ops_runtime_ui_mode_violation_run_rate_percent,
+          weekly_ops_runtime_ui_mode_violation_rate_max_percent:
+            result.release_gate_preflight.weekly_ops_runtime_ui_mode_violation_rate_max_percent
         }
       });
       const ontologyGateReasons = evaluateAutoHandoffOntologyGateReasons(
@@ -14452,10 +15427,35 @@ async function runAutoHandoff(projectPath, options = {}) {
     const observabilityPhase = beginAutoHandoffRunPhase(result, 'observability', 'Observability snapshot');
     try {
       result.observability_snapshot = await buildAutoObservabilitySnapshot(projectPath, options);
+      const observabilityWeeklyOps = extractAutoObservabilityWeeklyOpsStopTelemetry(result.observability_snapshot);
       completeAutoHandoffRunPhase(observabilityPhase, {
         risk_level: result.observability_snapshot && result.observability_snapshot.highlights
           ? result.observability_snapshot.highlights.governance_risk_level
-          : null
+          : null,
+        weekly_ops_stop_sessions: Number(
+          observabilityWeeklyOps && observabilityWeeklyOps.sessions
+        ) || 0,
+        weekly_ops_high_pressure_sessions: Number(
+          observabilityWeeklyOps && observabilityWeeklyOps.high_pressure_sessions
+        ) || 0,
+        weekly_ops_config_warning_positive_sessions: Number(
+          observabilityWeeklyOps && observabilityWeeklyOps.config_warning_positive_sessions
+        ) || 0,
+        weekly_ops_auth_tier_pressure_sessions: Number(
+          observabilityWeeklyOps && observabilityWeeklyOps.auth_tier_pressure_sessions
+        ) || 0,
+        weekly_ops_dialogue_authorization_pressure_sessions: Number(
+          observabilityWeeklyOps && observabilityWeeklyOps.dialogue_authorization_pressure_sessions
+        ) || 0,
+        weekly_ops_runtime_block_rate_high_sessions: Number(
+          observabilityWeeklyOps && observabilityWeeklyOps.runtime_block_rate_high_sessions
+        ) || 0,
+        weekly_ops_runtime_ui_mode_violation_high_sessions: Number(
+          observabilityWeeklyOps && observabilityWeeklyOps.runtime_ui_mode_violation_high_sessions
+        ) || 0,
+        weekly_ops_runtime_ui_mode_violation_total_sum: Number(
+          observabilityWeeklyOps && observabilityWeeklyOps.runtime_ui_mode_violation_total_sum
+        ) || 0
       });
     } catch (error) {
       failAutoHandoffRunPhase(observabilityPhase, error);
@@ -15634,6 +16634,178 @@ function normalizeGovernanceReleaseGateSnapshot(snapshotCandidate) {
   };
 }
 
+function normalizeGovernanceWeeklyOpsStopDetail(detailCandidate) {
+  if (!detailCandidate || typeof detailCandidate !== 'object' || Array.isArray(detailCandidate)) {
+    return null;
+  }
+  const latestCandidate = detailCandidate.latest && typeof detailCandidate.latest === 'object'
+    ? detailCandidate.latest
+    : {};
+  const aggregatesCandidate = detailCandidate.aggregates && typeof detailCandidate.aggregates === 'object'
+    ? detailCandidate.aggregates
+    : {};
+  const pressureCandidate = detailCandidate.pressure && typeof detailCandidate.pressure === 'object'
+    ? detailCandidate.pressure
+    : {};
+
+  const latestRiskLevelRaw = normalizeHandoffText(latestCandidate.risk_level);
+  const latestRiskLevel = latestRiskLevelRaw
+    ? normalizeAutoHandoffGateRiskLevel(latestRiskLevelRaw)
+    : null;
+  const normalized = {
+    latest: {
+      blocked: parseAutoHandoffGateBoolean(latestCandidate.blocked, null),
+      risk_level: latestRiskLevel,
+      governance_status: normalizeHandoffText(latestCandidate.governance_status),
+      authorization_tier_block_rate_percent: toGovernanceReleaseGateNumber(
+        latestCandidate.authorization_tier_block_rate_percent
+      ),
+      dialogue_authorization_block_rate_percent: toGovernanceReleaseGateNumber(
+        latestCandidate.dialogue_authorization_block_rate_percent
+      ),
+      config_warning_count: toGovernanceReleaseGateNumber(latestCandidate.config_warning_count),
+      runtime_block_rate_percent: toGovernanceReleaseGateNumber(
+        latestCandidate.runtime_block_rate_percent
+      ),
+      runtime_ui_mode_violation_total: toGovernanceReleaseGateNumber(
+        latestCandidate.runtime_ui_mode_violation_total
+      ),
+      runtime_ui_mode_violation_rate_percent: toGovernanceReleaseGateNumber(
+        latestCandidate.runtime_ui_mode_violation_rate_percent
+      )
+    },
+    aggregates: {
+      blocked_runs: toGovernanceReleaseGateNumber(aggregatesCandidate.blocked_runs),
+      block_rate_percent: toGovernanceReleaseGateNumber(aggregatesCandidate.block_rate_percent),
+      violations_total: toGovernanceReleaseGateNumber(aggregatesCandidate.violations_total),
+      warnings_total: toGovernanceReleaseGateNumber(aggregatesCandidate.warnings_total),
+      config_warnings_total: toGovernanceReleaseGateNumber(aggregatesCandidate.config_warnings_total),
+      authorization_tier_block_rate_max_percent: toGovernanceReleaseGateNumber(
+        aggregatesCandidate.authorization_tier_block_rate_max_percent
+      ),
+      dialogue_authorization_block_rate_max_percent: toGovernanceReleaseGateNumber(
+        aggregatesCandidate.dialogue_authorization_block_rate_max_percent
+      ),
+      runtime_block_rate_max_percent: toGovernanceReleaseGateNumber(
+        aggregatesCandidate.runtime_block_rate_max_percent
+      ),
+      runtime_ui_mode_violation_total: toGovernanceReleaseGateNumber(
+        aggregatesCandidate.runtime_ui_mode_violation_total
+      ),
+      runtime_ui_mode_violation_run_rate_percent: toGovernanceReleaseGateNumber(
+        aggregatesCandidate.runtime_ui_mode_violation_run_rate_percent
+      ),
+      runtime_ui_mode_violation_rate_max_percent: toGovernanceReleaseGateNumber(
+        aggregatesCandidate.runtime_ui_mode_violation_rate_max_percent
+      )
+    },
+    pressure: {
+      blocked: parseAutoHandoffGateBoolean(pressureCandidate.blocked, null),
+      high: parseAutoHandoffGateBoolean(pressureCandidate.high, null),
+      config_warning_positive: parseAutoHandoffGateBoolean(pressureCandidate.config_warning_positive, null),
+      auth_tier_block_rate_high: parseAutoHandoffGateBoolean(pressureCandidate.auth_tier_block_rate_high, null),
+      dialogue_authorization_block_rate_high: parseAutoHandoffGateBoolean(
+        pressureCandidate.dialogue_authorization_block_rate_high,
+        null
+      ),
+      runtime_block_rate_high: parseAutoHandoffGateBoolean(pressureCandidate.runtime_block_rate_high, null),
+      runtime_ui_mode_violation_high: parseAutoHandoffGateBoolean(
+        pressureCandidate.runtime_ui_mode_violation_high,
+        null
+      )
+    }
+  };
+  const hasSignal = (
+    typeof normalized.latest.blocked === 'boolean' ||
+    !!normalized.latest.risk_level ||
+    !!normalized.latest.governance_status ||
+    Number.isFinite(normalized.latest.authorization_tier_block_rate_percent) ||
+    Number.isFinite(normalized.latest.dialogue_authorization_block_rate_percent) ||
+    Number.isFinite(normalized.latest.config_warning_count) ||
+    Number.isFinite(normalized.latest.runtime_block_rate_percent) ||
+    Number.isFinite(normalized.latest.runtime_ui_mode_violation_total) ||
+    Number.isFinite(normalized.latest.runtime_ui_mode_violation_rate_percent) ||
+    Number.isFinite(normalized.aggregates.blocked_runs) ||
+    Number.isFinite(normalized.aggregates.block_rate_percent) ||
+    Number.isFinite(normalized.aggregates.violations_total) ||
+    Number.isFinite(normalized.aggregates.warnings_total) ||
+    Number.isFinite(normalized.aggregates.config_warnings_total) ||
+    Number.isFinite(normalized.aggregates.authorization_tier_block_rate_max_percent) ||
+    Number.isFinite(normalized.aggregates.dialogue_authorization_block_rate_max_percent) ||
+    Number.isFinite(normalized.aggregates.runtime_block_rate_max_percent) ||
+    Number.isFinite(normalized.aggregates.runtime_ui_mode_violation_total) ||
+    Number.isFinite(normalized.aggregates.runtime_ui_mode_violation_run_rate_percent) ||
+    Number.isFinite(normalized.aggregates.runtime_ui_mode_violation_rate_max_percent) ||
+    typeof normalized.pressure.blocked === 'boolean' ||
+    typeof normalized.pressure.high === 'boolean' ||
+    typeof normalized.pressure.config_warning_positive === 'boolean' ||
+    typeof normalized.pressure.auth_tier_block_rate_high === 'boolean' ||
+    typeof normalized.pressure.dialogue_authorization_block_rate_high === 'boolean' ||
+    typeof normalized.pressure.runtime_block_rate_high === 'boolean' ||
+    typeof normalized.pressure.runtime_ui_mode_violation_high === 'boolean'
+  );
+  return hasSignal ? normalized : null;
+}
+
+function deriveGovernanceWeeklyOpsReasonFlags(reasonsCandidate) {
+  const reasons = Array.isArray(reasonsCandidate)
+    ? reasonsCandidate.map(item => `${item || ''}`.trim().toLowerCase()).filter(Boolean)
+    : [];
+  const hasWeeklyOpsReason = reasons.some(reason => reason.startsWith('weekly-ops-'));
+  const hasBlockedReason = reasons.some(reason => (
+    reason === 'weekly-ops-latest-blocked' ||
+    reason.startsWith('weekly-ops-blocked-runs-positive:') ||
+    reason.startsWith('weekly-ops-block-rate-positive:')
+  ));
+  const hasHighReason = reasons.some(reason => (
+    reason === 'weekly-ops-latest-risk-high' ||
+    reason.startsWith('weekly-ops-auth-tier-block-rate-high:') ||
+    reason.startsWith('weekly-ops-dialogue-authorization-block-rate-high:') ||
+    reason.startsWith('weekly-ops-latest-auth-tier-block-rate-high:') ||
+    reason.startsWith('weekly-ops-latest-dialogue-authorization-block-rate-high:') ||
+    reason.startsWith('weekly-ops-latest-runtime-block-rate-high:') ||
+    reason.startsWith('weekly-ops-runtime-block-rate-high:') ||
+    reason.startsWith('weekly-ops-latest-runtime-ui-mode-violations-positive:') ||
+    reason.startsWith('weekly-ops-runtime-ui-mode-violations-positive:') ||
+    reason.startsWith('weekly-ops-latest-runtime-ui-mode-violation-rate-positive:') ||
+    reason.startsWith('weekly-ops-runtime-ui-mode-violation-run-rate-positive:') ||
+    reason.startsWith('weekly-ops-runtime-ui-mode-violation-rate-high:')
+  ));
+  const hasConfigWarningReason = reasons.some(reason => (
+    reason.startsWith('weekly-ops-config-warnings-positive:') ||
+    reason.startsWith('weekly-ops-latest-config-warnings-positive:')
+  ));
+  const hasAuthTierHighReason = reasons.some(reason => (
+    reason.startsWith('weekly-ops-auth-tier-block-rate-high:') ||
+    reason.startsWith('weekly-ops-latest-auth-tier-block-rate-high:')
+  ));
+  const hasDialogueHighReason = reasons.some(reason => (
+    reason.startsWith('weekly-ops-dialogue-authorization-block-rate-high:') ||
+    reason.startsWith('weekly-ops-latest-dialogue-authorization-block-rate-high:')
+  ));
+  const hasRuntimeBlockRateHighReason = reasons.some(reason => (
+    reason.startsWith('weekly-ops-latest-runtime-block-rate-high:') ||
+    reason.startsWith('weekly-ops-runtime-block-rate-high:')
+  ));
+  const hasRuntimeUiModeViolationReason = reasons.some(reason => (
+    reason.startsWith('weekly-ops-latest-runtime-ui-mode-violations-positive:') ||
+    reason.startsWith('weekly-ops-runtime-ui-mode-violations-positive:') ||
+    reason.startsWith('weekly-ops-latest-runtime-ui-mode-violation-rate-positive:') ||
+    reason.startsWith('weekly-ops-runtime-ui-mode-violation-run-rate-positive:') ||
+    reason.startsWith('weekly-ops-runtime-ui-mode-violation-rate-high:')
+  ));
+  return {
+    has_weekly_ops_reason: hasWeeklyOpsReason,
+    blocked: hasBlockedReason,
+    high: hasHighReason,
+    config_warning_positive: hasConfigWarningReason,
+    auth_tier_block_rate_high: hasAuthTierHighReason,
+    dialogue_authorization_block_rate_high: hasDialogueHighReason,
+    runtime_block_rate_high: hasRuntimeBlockRateHighReason,
+    runtime_ui_mode_violation_high: hasRuntimeUiModeViolationReason
+  };
+}
+
 function normalizeGovernanceHandoffQualitySnapshot(snapshotCandidate) {
   if (!snapshotCandidate || typeof snapshotCandidate !== 'object' || Array.isArray(snapshotCandidate)) {
     return null;
@@ -15754,6 +16926,91 @@ async function readGovernanceCloseLoopSessionEntries(projectPath) {
         : null
     );
     const roundReleaseGateTelemetry = summarizeGovernanceRoundReleaseGateTelemetry(payload && payload.rounds);
+    const stopDetail = payload && payload.stop_detail && typeof payload.stop_detail === 'object'
+      ? payload.stop_detail
+      : null;
+    const stopDetailReasons = Array.isArray(stopDetail && stopDetail.reasons)
+      ? stopDetail.reasons
+      : [];
+    const stopDetailWeeklyOps = normalizeGovernanceWeeklyOpsStopDetail(
+      stopDetail && stopDetail.weekly_ops
+    );
+    const stopDetailWeeklyOpsReasonFlags = deriveGovernanceWeeklyOpsReasonFlags(stopDetailReasons);
+    const stopDetailWeeklyOpsAuthTierBlockRatePercent = (
+      stopDetailWeeklyOps &&
+      stopDetailWeeklyOps.latest &&
+      Number.isFinite(stopDetailWeeklyOps.latest.authorization_tier_block_rate_percent)
+    )
+      ? stopDetailWeeklyOps.latest.authorization_tier_block_rate_percent
+      : (
+        stopDetailWeeklyOps &&
+        stopDetailWeeklyOps.aggregates &&
+        Number.isFinite(stopDetailWeeklyOps.aggregates.authorization_tier_block_rate_max_percent)
+      )
+        ? stopDetailWeeklyOps.aggregates.authorization_tier_block_rate_max_percent
+        : null;
+    const stopDetailWeeklyOpsDialogueAuthorizationBlockRatePercent = (
+      stopDetailWeeklyOps &&
+      stopDetailWeeklyOps.latest &&
+      Number.isFinite(stopDetailWeeklyOps.latest.dialogue_authorization_block_rate_percent)
+    )
+      ? stopDetailWeeklyOps.latest.dialogue_authorization_block_rate_percent
+      : (
+        stopDetailWeeklyOps &&
+        stopDetailWeeklyOps.aggregates &&
+        Number.isFinite(stopDetailWeeklyOps.aggregates.dialogue_authorization_block_rate_max_percent)
+      )
+        ? stopDetailWeeklyOps.aggregates.dialogue_authorization_block_rate_max_percent
+        : null;
+    const stopDetailWeeklyOpsRuntimeBlockRatePercent = (
+      stopDetailWeeklyOps &&
+      stopDetailWeeklyOps.latest &&
+      Number.isFinite(stopDetailWeeklyOps.latest.runtime_block_rate_percent)
+    )
+      ? stopDetailWeeklyOps.latest.runtime_block_rate_percent
+      : (
+        stopDetailWeeklyOps &&
+        stopDetailWeeklyOps.aggregates &&
+        Number.isFinite(stopDetailWeeklyOps.aggregates.runtime_block_rate_max_percent)
+      )
+        ? stopDetailWeeklyOps.aggregates.runtime_block_rate_max_percent
+        : null;
+    const stopDetailWeeklyOpsRuntimeUiModeViolationTotal = (
+      stopDetailWeeklyOps &&
+      stopDetailWeeklyOps.latest &&
+      Number.isFinite(stopDetailWeeklyOps.latest.runtime_ui_mode_violation_total)
+    )
+      ? stopDetailWeeklyOps.latest.runtime_ui_mode_violation_total
+      : (
+        stopDetailWeeklyOps &&
+        stopDetailWeeklyOps.aggregates &&
+        Number.isFinite(stopDetailWeeklyOps.aggregates.runtime_ui_mode_violation_total)
+      )
+        ? stopDetailWeeklyOps.aggregates.runtime_ui_mode_violation_total
+        : null;
+    const stopDetailWeeklyOpsRuntimeUiModeViolationRatePercent = (
+      stopDetailWeeklyOps &&
+      stopDetailWeeklyOps.latest &&
+      Number.isFinite(stopDetailWeeklyOps.latest.runtime_ui_mode_violation_rate_percent)
+    )
+      ? stopDetailWeeklyOps.latest.runtime_ui_mode_violation_rate_percent
+      : (
+        stopDetailWeeklyOps &&
+        stopDetailWeeklyOps.aggregates &&
+        Number.isFinite(stopDetailWeeklyOps.aggregates.runtime_ui_mode_violation_rate_max_percent)
+      )
+        ? stopDetailWeeklyOps.aggregates.runtime_ui_mode_violation_rate_max_percent
+        : (
+          stopDetailWeeklyOps &&
+          stopDetailWeeklyOps.aggregates &&
+          Number.isFinite(stopDetailWeeklyOps.aggregates.runtime_ui_mode_violation_run_rate_percent)
+        )
+          ? stopDetailWeeklyOps.aggregates.runtime_ui_mode_violation_run_rate_percent
+          : null;
+    const stopDetailWeeklyOpsAvailable = Boolean(
+      stopDetailWeeklyOps ||
+      stopDetailWeeklyOpsReasonFlags.has_weekly_ops_reason
+    );
 
     sessions.push({
       id: payload && payload.governance_session && payload.governance_session.id
@@ -15801,6 +17058,44 @@ async function readGovernanceCloseLoopSessionEntries(projectPath) {
       release_gate_drift_blocked_runs: finalReleaseGate ? finalReleaseGate.drift_blocked_runs : null,
       round_release_gate_observed: roundReleaseGateTelemetry.observed_rounds,
       round_release_gate_changed: roundReleaseGateTelemetry.changed_rounds,
+      stop_detail_weekly_ops_available: stopDetailWeeklyOpsAvailable,
+      stop_detail_weekly_ops_blocked: stopDetailWeeklyOps
+        ? stopDetailWeeklyOps.pressure.blocked
+        : (stopDetailWeeklyOpsReasonFlags.blocked ? true : null),
+      stop_detail_weekly_ops_high_pressure: stopDetailWeeklyOps
+        ? stopDetailWeeklyOps.pressure.high
+        : (stopDetailWeeklyOpsReasonFlags.high ? true : null),
+      stop_detail_weekly_ops_config_warning_positive: stopDetailWeeklyOps
+        ? stopDetailWeeklyOps.pressure.config_warning_positive
+        : (stopDetailWeeklyOpsReasonFlags.config_warning_positive ? true : null),
+      stop_detail_weekly_ops_auth_tier_block_rate_high: stopDetailWeeklyOps
+        ? stopDetailWeeklyOps.pressure.auth_tier_block_rate_high
+        : (stopDetailWeeklyOpsReasonFlags.auth_tier_block_rate_high ? true : null),
+      stop_detail_weekly_ops_dialogue_authorization_block_rate_high: stopDetailWeeklyOps
+        ? stopDetailWeeklyOps.pressure.dialogue_authorization_block_rate_high
+        : (stopDetailWeeklyOpsReasonFlags.dialogue_authorization_block_rate_high ? true : null),
+      stop_detail_weekly_ops_runtime_block_rate_high: stopDetailWeeklyOps
+        ? stopDetailWeeklyOps.pressure.runtime_block_rate_high
+        : (stopDetailWeeklyOpsReasonFlags.runtime_block_rate_high ? true : null),
+      stop_detail_weekly_ops_runtime_ui_mode_violation_high: stopDetailWeeklyOps
+        ? stopDetailWeeklyOps.pressure.runtime_ui_mode_violation_high
+        : (stopDetailWeeklyOpsReasonFlags.runtime_ui_mode_violation_high ? true : null),
+      stop_detail_weekly_ops_blocked_runs: stopDetailWeeklyOps && stopDetailWeeklyOps.aggregates
+        ? stopDetailWeeklyOps.aggregates.blocked_runs
+        : null,
+      stop_detail_weekly_ops_block_rate_percent: stopDetailWeeklyOps && stopDetailWeeklyOps.aggregates
+        ? stopDetailWeeklyOps.aggregates.block_rate_percent
+        : null,
+      stop_detail_weekly_ops_config_warnings_total: stopDetailWeeklyOps && stopDetailWeeklyOps.aggregates
+        ? stopDetailWeeklyOps.aggregates.config_warnings_total
+        : null,
+      stop_detail_weekly_ops_auth_tier_block_rate_percent: stopDetailWeeklyOpsAuthTierBlockRatePercent,
+      stop_detail_weekly_ops_dialogue_authorization_block_rate_percent:
+        stopDetailWeeklyOpsDialogueAuthorizationBlockRatePercent,
+      stop_detail_weekly_ops_runtime_block_rate_percent: stopDetailWeeklyOpsRuntimeBlockRatePercent,
+      stop_detail_weekly_ops_runtime_ui_mode_violation_total: stopDetailWeeklyOpsRuntimeUiModeViolationTotal,
+      stop_detail_weekly_ops_runtime_ui_mode_violation_rate_percent:
+        stopDetailWeeklyOpsRuntimeUiModeViolationRatePercent,
       stop_reason: payload && typeof payload.stop_reason === 'string'
         ? payload.stop_reason
         : null,
@@ -17277,6 +18572,27 @@ async function listGovernanceCloseLoopSessions(projectPath, options = {}) {
       release_gate_drift_alert_rate_percent: item.release_gate_drift_alert_rate_percent,
       round_release_gate_observed: item.round_release_gate_observed,
       round_release_gate_changed: item.round_release_gate_changed,
+      stop_detail_weekly_ops_available: item.stop_detail_weekly_ops_available,
+      stop_detail_weekly_ops_blocked: item.stop_detail_weekly_ops_blocked,
+      stop_detail_weekly_ops_high_pressure: item.stop_detail_weekly_ops_high_pressure,
+      stop_detail_weekly_ops_config_warning_positive: item.stop_detail_weekly_ops_config_warning_positive,
+      stop_detail_weekly_ops_auth_tier_block_rate_high: item.stop_detail_weekly_ops_auth_tier_block_rate_high,
+      stop_detail_weekly_ops_dialogue_authorization_block_rate_high:
+        item.stop_detail_weekly_ops_dialogue_authorization_block_rate_high,
+      stop_detail_weekly_ops_runtime_block_rate_high: item.stop_detail_weekly_ops_runtime_block_rate_high,
+      stop_detail_weekly_ops_runtime_ui_mode_violation_high:
+        item.stop_detail_weekly_ops_runtime_ui_mode_violation_high,
+      stop_detail_weekly_ops_blocked_runs: item.stop_detail_weekly_ops_blocked_runs,
+      stop_detail_weekly_ops_block_rate_percent: item.stop_detail_weekly_ops_block_rate_percent,
+      stop_detail_weekly_ops_config_warnings_total: item.stop_detail_weekly_ops_config_warnings_total,
+      stop_detail_weekly_ops_auth_tier_block_rate_percent: item.stop_detail_weekly_ops_auth_tier_block_rate_percent,
+      stop_detail_weekly_ops_dialogue_authorization_block_rate_percent:
+        item.stop_detail_weekly_ops_dialogue_authorization_block_rate_percent,
+      stop_detail_weekly_ops_runtime_block_rate_percent: item.stop_detail_weekly_ops_runtime_block_rate_percent,
+      stop_detail_weekly_ops_runtime_ui_mode_violation_total:
+        item.stop_detail_weekly_ops_runtime_ui_mode_violation_total,
+      stop_detail_weekly_ops_runtime_ui_mode_violation_rate_percent:
+        item.stop_detail_weekly_ops_runtime_ui_mode_violation_rate_percent,
       stop_reason: item.stop_reason,
       resumed_from_governance_session_id: item.resumed_from_governance_session_id,
       updated_at: item.updated_at,
@@ -17321,6 +18637,30 @@ async function statsGovernanceCloseLoopSessions(projectPath, options = {}) {
   let releaseGateDriftAlertRateCount = 0;
   let roundReleaseGateObservedSum = 0;
   let roundReleaseGateChangedSum = 0;
+  let weeklyOpsStopSessions = 0;
+  let weeklyOpsBlockedStopSessions = 0;
+  let weeklyOpsHighPressureStopSessions = 0;
+  let weeklyOpsConfigWarningPositiveStopSessions = 0;
+  let weeklyOpsAuthTierPressureStopSessions = 0;
+  let weeklyOpsDialoguePressureStopSessions = 0;
+  let weeklyOpsRuntimeBlockRateHighStopSessions = 0;
+  let weeklyOpsRuntimeUiModeViolationHighStopSessions = 0;
+  let weeklyOpsBlockedRunsSum = 0;
+  let weeklyOpsBlockedRunsCount = 0;
+  let weeklyOpsBlockRateSum = 0;
+  let weeklyOpsBlockRateCount = 0;
+  let weeklyOpsConfigWarningsTotalSum = 0;
+  let weeklyOpsConfigWarningsTotalCount = 0;
+  let weeklyOpsAuthTierBlockRateSum = 0;
+  let weeklyOpsAuthTierBlockRateCount = 0;
+  let weeklyOpsDialogueBlockRateSum = 0;
+  let weeklyOpsDialogueBlockRateCount = 0;
+  let weeklyOpsRuntimeBlockRateSum = 0;
+  let weeklyOpsRuntimeBlockRateCount = 0;
+  let weeklyOpsRuntimeUiModeViolationTotalSum = 0;
+  let weeklyOpsRuntimeUiModeViolationTotalCount = 0;
+  let weeklyOpsRuntimeUiModeViolationRateSum = 0;
+  let weeklyOpsRuntimeUiModeViolationRateCount = 0;
   const stopReasonCounts = {};
   const finalRiskCounts = {};
   const resumedFromCounts = {};
@@ -17390,6 +18730,86 @@ async function statsGovernanceCloseLoopSessions(projectPath, options = {}) {
         roundReleaseGateChangedSum += roundReleaseGateChanged;
       }
     }
+    if (session && session.stop_detail_weekly_ops_available === true) {
+      weeklyOpsStopSessions += 1;
+    }
+    if (session && session.stop_detail_weekly_ops_blocked === true) {
+      weeklyOpsBlockedStopSessions += 1;
+    }
+    if (session && session.stop_detail_weekly_ops_high_pressure === true) {
+      weeklyOpsHighPressureStopSessions += 1;
+    }
+    if (session && session.stop_detail_weekly_ops_config_warning_positive === true) {
+      weeklyOpsConfigWarningPositiveStopSessions += 1;
+    }
+    if (session && session.stop_detail_weekly_ops_auth_tier_block_rate_high === true) {
+      weeklyOpsAuthTierPressureStopSessions += 1;
+    }
+    if (session && session.stop_detail_weekly_ops_dialogue_authorization_block_rate_high === true) {
+      weeklyOpsDialoguePressureStopSessions += 1;
+    }
+    if (session && session.stop_detail_weekly_ops_runtime_block_rate_high === true) {
+      weeklyOpsRuntimeBlockRateHighStopSessions += 1;
+    }
+    if (session && session.stop_detail_weekly_ops_runtime_ui_mode_violation_high === true) {
+      weeklyOpsRuntimeUiModeViolationHighStopSessions += 1;
+    }
+    const weeklyOpsBlockedRuns = toGovernanceReleaseGateNumber(
+      session && session.stop_detail_weekly_ops_blocked_runs
+    );
+    if (Number.isFinite(weeklyOpsBlockedRuns)) {
+      weeklyOpsBlockedRunsSum += weeklyOpsBlockedRuns;
+      weeklyOpsBlockedRunsCount += 1;
+    }
+    const weeklyOpsBlockRate = toGovernanceReleaseGateNumber(
+      session && session.stop_detail_weekly_ops_block_rate_percent
+    );
+    if (Number.isFinite(weeklyOpsBlockRate)) {
+      weeklyOpsBlockRateSum += weeklyOpsBlockRate;
+      weeklyOpsBlockRateCount += 1;
+    }
+    const weeklyOpsConfigWarningsTotal = toGovernanceReleaseGateNumber(
+      session && session.stop_detail_weekly_ops_config_warnings_total
+    );
+    if (Number.isFinite(weeklyOpsConfigWarningsTotal)) {
+      weeklyOpsConfigWarningsTotalSum += weeklyOpsConfigWarningsTotal;
+      weeklyOpsConfigWarningsTotalCount += 1;
+    }
+    const weeklyOpsAuthTierBlockRate = toGovernanceReleaseGateNumber(
+      session && session.stop_detail_weekly_ops_auth_tier_block_rate_percent
+    );
+    if (Number.isFinite(weeklyOpsAuthTierBlockRate)) {
+      weeklyOpsAuthTierBlockRateSum += weeklyOpsAuthTierBlockRate;
+      weeklyOpsAuthTierBlockRateCount += 1;
+    }
+    const weeklyOpsDialogueBlockRate = toGovernanceReleaseGateNumber(
+      session && session.stop_detail_weekly_ops_dialogue_authorization_block_rate_percent
+    );
+    if (Number.isFinite(weeklyOpsDialogueBlockRate)) {
+      weeklyOpsDialogueBlockRateSum += weeklyOpsDialogueBlockRate;
+      weeklyOpsDialogueBlockRateCount += 1;
+    }
+    const weeklyOpsRuntimeBlockRate = toGovernanceReleaseGateNumber(
+      session && session.stop_detail_weekly_ops_runtime_block_rate_percent
+    );
+    if (Number.isFinite(weeklyOpsRuntimeBlockRate)) {
+      weeklyOpsRuntimeBlockRateSum += weeklyOpsRuntimeBlockRate;
+      weeklyOpsRuntimeBlockRateCount += 1;
+    }
+    const weeklyOpsRuntimeUiModeViolationTotal = toGovernanceReleaseGateNumber(
+      session && session.stop_detail_weekly_ops_runtime_ui_mode_violation_total
+    );
+    if (Number.isFinite(weeklyOpsRuntimeUiModeViolationTotal)) {
+      weeklyOpsRuntimeUiModeViolationTotalSum += weeklyOpsRuntimeUiModeViolationTotal;
+      weeklyOpsRuntimeUiModeViolationTotalCount += 1;
+    }
+    const weeklyOpsRuntimeUiModeViolationRate = toGovernanceReleaseGateNumber(
+      session && session.stop_detail_weekly_ops_runtime_ui_mode_violation_rate_percent
+    );
+    if (Number.isFinite(weeklyOpsRuntimeUiModeViolationRate)) {
+      weeklyOpsRuntimeUiModeViolationRateSum += weeklyOpsRuntimeUiModeViolationRate;
+      weeklyOpsRuntimeUiModeViolationRateCount += 1;
+    }
 
     const stopReason = `${session && session.stop_reason ? session.stop_reason : ''}`.trim().toLowerCase() || 'unknown';
     stopReasonCounts[stopReason] = (stopReasonCounts[stopReason] || 0) + 1;
@@ -17454,7 +18874,64 @@ async function statsGovernanceCloseLoopSessions(projectPath, options = {}) {
         : null,
       round_telemetry_observed: roundReleaseGateObservedSum,
       round_telemetry_changed: roundReleaseGateChangedSum,
-      round_telemetry_change_rate_percent: calculatePercent(roundReleaseGateChangedSum, roundReleaseGateObservedSum)
+      round_telemetry_change_rate_percent: calculatePercent(roundReleaseGateChangedSum, roundReleaseGateObservedSum),
+      weekly_ops_stop: {
+        sessions: weeklyOpsStopSessions,
+        session_rate_percent: calculatePercent(weeklyOpsStopSessions, totalSessions),
+        blocked_sessions: weeklyOpsBlockedStopSessions,
+        blocked_session_rate_percent: calculatePercent(weeklyOpsBlockedStopSessions, weeklyOpsStopSessions),
+        high_pressure_sessions: weeklyOpsHighPressureStopSessions,
+        high_pressure_session_rate_percent: calculatePercent(weeklyOpsHighPressureStopSessions, weeklyOpsStopSessions),
+        config_warning_positive_sessions: weeklyOpsConfigWarningPositiveStopSessions,
+        config_warning_positive_rate_percent: calculatePercent(
+          weeklyOpsConfigWarningPositiveStopSessions,
+          weeklyOpsStopSessions
+        ),
+        auth_tier_pressure_sessions: weeklyOpsAuthTierPressureStopSessions,
+        auth_tier_pressure_rate_percent: calculatePercent(weeklyOpsAuthTierPressureStopSessions, weeklyOpsStopSessions),
+        dialogue_authorization_pressure_sessions: weeklyOpsDialoguePressureStopSessions,
+        dialogue_authorization_pressure_rate_percent: calculatePercent(
+          weeklyOpsDialoguePressureStopSessions,
+          weeklyOpsStopSessions
+        ),
+        runtime_block_rate_high_sessions: weeklyOpsRuntimeBlockRateHighStopSessions,
+        runtime_block_rate_high_rate_percent: calculatePercent(
+          weeklyOpsRuntimeBlockRateHighStopSessions,
+          weeklyOpsStopSessions
+        ),
+        runtime_ui_mode_violation_high_sessions: weeklyOpsRuntimeUiModeViolationHighStopSessions,
+        runtime_ui_mode_violation_high_rate_percent: calculatePercent(
+          weeklyOpsRuntimeUiModeViolationHighStopSessions,
+          weeklyOpsStopSessions
+        ),
+        blocked_runs_sum: weeklyOpsBlockedRunsSum,
+        average_blocked_runs: weeklyOpsBlockedRunsCount > 0
+          ? Number((weeklyOpsBlockedRunsSum / weeklyOpsBlockedRunsCount).toFixed(2))
+          : null,
+        average_block_rate_percent: weeklyOpsBlockRateCount > 0
+          ? Number((weeklyOpsBlockRateSum / weeklyOpsBlockRateCount).toFixed(2))
+          : null,
+        config_warnings_total_sum: weeklyOpsConfigWarningsTotalSum,
+        average_config_warnings_total: weeklyOpsConfigWarningsTotalCount > 0
+          ? Number((weeklyOpsConfigWarningsTotalSum / weeklyOpsConfigWarningsTotalCount).toFixed(2))
+          : null,
+        average_auth_tier_block_rate_percent: weeklyOpsAuthTierBlockRateCount > 0
+          ? Number((weeklyOpsAuthTierBlockRateSum / weeklyOpsAuthTierBlockRateCount).toFixed(2))
+          : null,
+        average_dialogue_authorization_block_rate_percent: weeklyOpsDialogueBlockRateCount > 0
+          ? Number((weeklyOpsDialogueBlockRateSum / weeklyOpsDialogueBlockRateCount).toFixed(2))
+          : null,
+        average_runtime_block_rate_percent: weeklyOpsRuntimeBlockRateCount > 0
+          ? Number((weeklyOpsRuntimeBlockRateSum / weeklyOpsRuntimeBlockRateCount).toFixed(2))
+          : null,
+        runtime_ui_mode_violation_total_sum: weeklyOpsRuntimeUiModeViolationTotalSum,
+        average_runtime_ui_mode_violation_total: weeklyOpsRuntimeUiModeViolationTotalCount > 0
+          ? Number((weeklyOpsRuntimeUiModeViolationTotalSum / weeklyOpsRuntimeUiModeViolationTotalCount).toFixed(2))
+          : null,
+        average_runtime_ui_mode_violation_rate_percent: weeklyOpsRuntimeUiModeViolationRateCount > 0
+          ? Number((weeklyOpsRuntimeUiModeViolationRateSum / weeklyOpsRuntimeUiModeViolationRateCount).toFixed(2))
+          : null
+      }
     },
     status_counts: buildStatusCounts(filteredSessions),
     stop_reason_counts: stopReasonCounts,
@@ -17478,6 +18955,27 @@ async function statsGovernanceCloseLoopSessions(projectPath, options = {}) {
       release_gate_drift_alert_rate_percent: item.release_gate_drift_alert_rate_percent,
       round_release_gate_observed: item.round_release_gate_observed,
       round_release_gate_changed: item.round_release_gate_changed,
+      stop_detail_weekly_ops_available: item.stop_detail_weekly_ops_available,
+      stop_detail_weekly_ops_blocked: item.stop_detail_weekly_ops_blocked,
+      stop_detail_weekly_ops_high_pressure: item.stop_detail_weekly_ops_high_pressure,
+      stop_detail_weekly_ops_config_warning_positive: item.stop_detail_weekly_ops_config_warning_positive,
+      stop_detail_weekly_ops_auth_tier_block_rate_high: item.stop_detail_weekly_ops_auth_tier_block_rate_high,
+      stop_detail_weekly_ops_dialogue_authorization_block_rate_high:
+        item.stop_detail_weekly_ops_dialogue_authorization_block_rate_high,
+      stop_detail_weekly_ops_runtime_block_rate_high: item.stop_detail_weekly_ops_runtime_block_rate_high,
+      stop_detail_weekly_ops_runtime_ui_mode_violation_high:
+        item.stop_detail_weekly_ops_runtime_ui_mode_violation_high,
+      stop_detail_weekly_ops_blocked_runs: item.stop_detail_weekly_ops_blocked_runs,
+      stop_detail_weekly_ops_block_rate_percent: item.stop_detail_weekly_ops_block_rate_percent,
+      stop_detail_weekly_ops_config_warnings_total: item.stop_detail_weekly_ops_config_warnings_total,
+      stop_detail_weekly_ops_auth_tier_block_rate_percent: item.stop_detail_weekly_ops_auth_tier_block_rate_percent,
+      stop_detail_weekly_ops_dialogue_authorization_block_rate_percent:
+        item.stop_detail_weekly_ops_dialogue_authorization_block_rate_percent,
+      stop_detail_weekly_ops_runtime_block_rate_percent: item.stop_detail_weekly_ops_runtime_block_rate_percent,
+      stop_detail_weekly_ops_runtime_ui_mode_violation_total:
+        item.stop_detail_weekly_ops_runtime_ui_mode_violation_total,
+      stop_detail_weekly_ops_runtime_ui_mode_violation_rate_percent:
+        item.stop_detail_weekly_ops_runtime_ui_mode_violation_rate_percent,
       stop_reason: item.stop_reason,
       resumed_from_governance_session_id: item.resumed_from_governance_session_id,
       updated_at: item.updated_at,
@@ -18251,8 +19749,15 @@ function buildTopCountEntries(counterMap, limit = 10) {
     .slice(0, maxItems);
 }
 
-async function loadGovernanceReleaseGateSignals(projectPath) {
-  const historyFile = resolveAutoHandoffReleaseGateHistoryFile(projectPath);
+async function loadGovernanceReleaseGateSignals(projectPath, options = {}) {
+  const historyFileCandidate = typeof options.historyFile === 'string' && options.historyFile.trim().length > 0
+    ? options.historyFile.trim()
+    : null;
+  const historyFile = historyFileCandidate
+    ? (path.isAbsolute(historyFileCandidate)
+      ? historyFileCandidate
+      : path.join(projectPath, historyFileCandidate))
+    : resolveAutoHandoffReleaseGateHistoryFile(projectPath);
   const toNumber = value => {
     if (value === null || value === undefined || value === '') {
       return null;
@@ -18273,6 +19778,31 @@ async function loadGovernanceReleaseGateSignals(projectPath) {
     drift_alert_rate_percent: null,
     drift_alert_runs: null,
     drift_blocked_runs: null,
+    latest_weekly_ops_blocked: null,
+    latest_weekly_ops_risk_level: null,
+    latest_weekly_ops_governance_status: null,
+    latest_weekly_ops_authorization_tier_block_rate_percent: null,
+    latest_weekly_ops_dialogue_authorization_block_rate_percent: null,
+    latest_weekly_ops_config_warning_count: null,
+    latest_weekly_ops_runtime_block_rate_percent: null,
+    latest_weekly_ops_runtime_ui_mode_violation_total: null,
+    latest_weekly_ops_runtime_ui_mode_violation_rate_percent: null,
+    weekly_ops_known_runs: null,
+    weekly_ops_blocked_runs: null,
+    weekly_ops_block_rate_percent: null,
+    weekly_ops_violations_total: null,
+    weekly_ops_warnings_total: null,
+    weekly_ops_config_warnings_total: null,
+    weekly_ops_authorization_tier_block_rate_max_percent: null,
+    weekly_ops_dialogue_authorization_block_rate_max_percent: null,
+    weekly_ops_runtime_block_rate_avg_percent: null,
+    weekly_ops_runtime_block_rate_max_percent: null,
+    weekly_ops_runtime_ui_mode_violation_known_runs: null,
+    weekly_ops_runtime_ui_mode_violation_runs: null,
+    weekly_ops_runtime_ui_mode_violation_run_rate_percent: null,
+    weekly_ops_runtime_ui_mode_violation_total: null,
+    weekly_ops_runtime_ui_mode_violation_rate_avg_percent: null,
+    weekly_ops_runtime_ui_mode_violation_rate_max_percent: null,
     parse_error: null
   };
   if (!(await fs.pathExists(historyFile))) {
@@ -18301,6 +19831,7 @@ async function loadGovernanceReleaseGateSignals(projectPath) {
     ? payload.aggregates
     : {};
   const latestRiskLevel = normalizeHandoffText(latest && latest.risk_level);
+  const latestWeeklyOpsRiskLevel = normalizeHandoffText(latest && latest.weekly_ops_risk_level);
   return {
     ...base,
     available: true,
@@ -18316,6 +19847,67 @@ async function loadGovernanceReleaseGateSignals(projectPath) {
     drift_alert_rate_percent: toNumber(aggregates.drift_alert_rate_percent),
     drift_alert_runs: toNumber(aggregates.drift_alert_runs),
     drift_blocked_runs: toNumber(aggregates.drift_blocked_runs),
+    latest_weekly_ops_blocked: parseAutoHandoffGateBoolean(latest && latest.weekly_ops_blocked, null),
+    latest_weekly_ops_risk_level: latestWeeklyOpsRiskLevel
+      ? normalizeAutoHandoffGateRiskLevel(latestWeeklyOpsRiskLevel)
+      : null,
+    latest_weekly_ops_governance_status: normalizeHandoffText(
+      latest && latest.weekly_ops_governance_status
+    ) || null,
+    latest_weekly_ops_authorization_tier_block_rate_percent: toNumber(
+      latest && latest.weekly_ops_authorization_tier_block_rate_percent
+    ),
+    latest_weekly_ops_dialogue_authorization_block_rate_percent: toNumber(
+      latest && latest.weekly_ops_dialogue_authorization_block_rate_percent
+    ),
+    latest_weekly_ops_config_warning_count: toNumber(
+      latest && latest.weekly_ops_config_warning_count
+    ),
+    latest_weekly_ops_runtime_block_rate_percent: toNumber(
+      latest && latest.weekly_ops_runtime_block_rate_percent
+    ),
+    latest_weekly_ops_runtime_ui_mode_violation_total: toNumber(
+      latest && latest.weekly_ops_runtime_ui_mode_violation_total
+    ),
+    latest_weekly_ops_runtime_ui_mode_violation_rate_percent: toNumber(
+      latest && latest.weekly_ops_runtime_ui_mode_violation_rate_percent
+    ),
+    weekly_ops_known_runs: toNumber(aggregates.weekly_ops_known_runs),
+    weekly_ops_blocked_runs: toNumber(aggregates.weekly_ops_blocked_runs),
+    weekly_ops_block_rate_percent: toNumber(aggregates.weekly_ops_block_rate_percent),
+    weekly_ops_violations_total: toNumber(aggregates.weekly_ops_violations_total),
+    weekly_ops_warnings_total: toNumber(aggregates.weekly_ops_warnings_total),
+    weekly_ops_config_warnings_total: toNumber(aggregates.weekly_ops_config_warnings_total),
+    weekly_ops_authorization_tier_block_rate_max_percent: toNumber(
+      aggregates.weekly_ops_authorization_tier_block_rate_max_percent
+    ),
+    weekly_ops_dialogue_authorization_block_rate_max_percent: toNumber(
+      aggregates.weekly_ops_dialogue_authorization_block_rate_max_percent
+    ),
+    weekly_ops_runtime_block_rate_avg_percent: toNumber(
+      aggregates.weekly_ops_runtime_block_rate_avg_percent
+    ),
+    weekly_ops_runtime_block_rate_max_percent: toNumber(
+      aggregates.weekly_ops_runtime_block_rate_max_percent
+    ),
+    weekly_ops_runtime_ui_mode_violation_known_runs: toNumber(
+      aggregates.weekly_ops_runtime_ui_mode_violation_known_runs
+    ),
+    weekly_ops_runtime_ui_mode_violation_runs: toNumber(
+      aggregates.weekly_ops_runtime_ui_mode_violation_runs
+    ),
+    weekly_ops_runtime_ui_mode_violation_run_rate_percent: toNumber(
+      aggregates.weekly_ops_runtime_ui_mode_violation_run_rate_percent
+    ),
+    weekly_ops_runtime_ui_mode_violation_total: toNumber(
+      aggregates.weekly_ops_runtime_ui_mode_violation_total
+    ),
+    weekly_ops_runtime_ui_mode_violation_rate_avg_percent: toNumber(
+      aggregates.weekly_ops_runtime_ui_mode_violation_rate_avg_percent
+    ),
+    weekly_ops_runtime_ui_mode_violation_rate_max_percent: toNumber(
+      aggregates.weekly_ops_runtime_ui_mode_violation_rate_max_percent
+    ),
     parse_error: null
   };
 }
@@ -18695,6 +20287,39 @@ function deriveGovernanceRiskLevel(summary) {
   const sceneBatchPassRate = Number(releaseGate.scene_package_batch_pass_rate_percent);
   const driftAlertRate = Number(releaseGate.drift_alert_rate_percent);
   const driftBlockedRuns = Number(releaseGate.drift_blocked_runs);
+  const weeklyOpsKnownRuns = Number(releaseGate.weekly_ops_known_runs);
+  const weeklyOpsBlockedRuns = Number(releaseGate.weekly_ops_blocked_runs);
+  const weeklyOpsBlockRate = Number(releaseGate.weekly_ops_block_rate_percent);
+  const weeklyOpsViolationsTotal = Number(releaseGate.weekly_ops_violations_total);
+  const weeklyOpsWarningsTotal = Number(releaseGate.weekly_ops_warnings_total);
+  const weeklyOpsConfigWarningsTotal = Number(releaseGate.weekly_ops_config_warnings_total);
+  const weeklyOpsAuthTierBlockRateMax = Number(
+    releaseGate.weekly_ops_authorization_tier_block_rate_max_percent
+  );
+  const weeklyOpsDialogueBlockRateMax = Number(
+    releaseGate.weekly_ops_dialogue_authorization_block_rate_max_percent
+  );
+  const weeklyOpsLatestRuntimeBlockRate = Number(
+    releaseGate.latest_weekly_ops_runtime_block_rate_percent
+  );
+  const weeklyOpsLatestRuntimeUiModeViolationTotal = Number(
+    releaseGate.latest_weekly_ops_runtime_ui_mode_violation_total
+  );
+  const weeklyOpsLatestRuntimeUiModeViolationRate = Number(
+    releaseGate.latest_weekly_ops_runtime_ui_mode_violation_rate_percent
+  );
+  const weeklyOpsRuntimeBlockRateMax = Number(
+    releaseGate.weekly_ops_runtime_block_rate_max_percent
+  );
+  const weeklyOpsRuntimeUiModeViolationTotal = Number(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_total
+  );
+  const weeklyOpsRuntimeUiModeViolationRunRate = Number(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_run_rate_percent
+  );
+  const weeklyOpsRuntimeUiModeViolationRateMax = Number(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_rate_max_percent
+  );
   const handoffQuality = summary && summary.handoff_quality && typeof summary.handoff_quality === 'object'
     ? summary.handoff_quality
     : {};
@@ -18762,14 +20387,42 @@ function deriveGovernanceRiskLevel(summary) {
       (Number.isFinite(releaseGatePassRate) && releaseGatePassRate < 60) ||
       (Number.isFinite(sceneBatchPassRate) && sceneBatchPassRate < 60)
     );
+    const hasHighWeeklyOpsPressure = (
+      (Number.isFinite(weeklyOpsBlockedRuns) && weeklyOpsBlockedRuns > 0) ||
+      (Number.isFinite(weeklyOpsBlockRate) && weeklyOpsBlockRate >= 40) ||
+      (Number.isFinite(weeklyOpsAuthTierBlockRateMax) && weeklyOpsAuthTierBlockRateMax >= 60) ||
+      (Number.isFinite(weeklyOpsDialogueBlockRateMax) && weeklyOpsDialogueBlockRateMax >= 60) ||
+      (Number.isFinite(weeklyOpsLatestRuntimeUiModeViolationTotal) && weeklyOpsLatestRuntimeUiModeViolationTotal > 0) ||
+      (Number.isFinite(weeklyOpsRuntimeUiModeViolationTotal) && weeklyOpsRuntimeUiModeViolationTotal > 0) ||
+      (Number.isFinite(weeklyOpsRuntimeUiModeViolationRunRate) && weeklyOpsRuntimeUiModeViolationRunRate > 0) ||
+      (Number.isFinite(weeklyOpsLatestRuntimeUiModeViolationRate) && weeklyOpsLatestRuntimeUiModeViolationRate > 0) ||
+      (Number.isFinite(weeklyOpsRuntimeUiModeViolationRateMax) && weeklyOpsRuntimeUiModeViolationRateMax > 0) ||
+      (Number.isFinite(weeklyOpsLatestRuntimeBlockRate) && weeklyOpsLatestRuntimeBlockRate >= 40) ||
+      (Number.isFinite(weeklyOpsRuntimeBlockRateMax) && weeklyOpsRuntimeBlockRateMax >= 40)
+    );
+    const hasMediumWeeklyOpsPressure = (
+      (Number.isFinite(weeklyOpsKnownRuns) && weeklyOpsKnownRuns > 0) && (
+        (Number.isFinite(weeklyOpsViolationsTotal) && weeklyOpsViolationsTotal > 0) ||
+        (Number.isFinite(weeklyOpsWarningsTotal) && weeklyOpsWarningsTotal > 0) ||
+        (Number.isFinite(weeklyOpsConfigWarningsTotal) && weeklyOpsConfigWarningsTotal > 0) ||
+        (Number.isFinite(weeklyOpsAuthTierBlockRateMax) && weeklyOpsAuthTierBlockRateMax > 40) ||
+        (Number.isFinite(weeklyOpsDialogueBlockRateMax) && weeklyOpsDialogueBlockRateMax > 40) ||
+        (Number.isFinite(weeklyOpsBlockRate) && weeklyOpsBlockRate > 0) ||
+        (Number.isFinite(weeklyOpsLatestRuntimeBlockRate) && weeklyOpsLatestRuntimeBlockRate > 0) ||
+        (Number.isFinite(weeklyOpsRuntimeBlockRateMax) && weeklyOpsRuntimeBlockRateMax > 0)
+      )
+    );
     if (releaseGatePassed === false && (hasHighDriftPressure || hasLowPassRate)) {
       riskLevel = 'high';
+    } else if (hasHighWeeklyOpsPressure) {
+      riskLevel = 'high';
     } else if (
       riskLevel !== 'high' && (
         releaseGatePassed === false ||
         (Number.isFinite(releaseGatePassRate) && releaseGatePassRate < 85) ||
         (Number.isFinite(sceneBatchPassRate) && sceneBatchPassRate < 85) ||
-        (Number.isFinite(driftAlertRate) && driftAlertRate > 0)
+        (Number.isFinite(driftAlertRate) && driftAlertRate > 0) ||
+        hasMediumWeeklyOpsPressure
       )
     ) {
       riskLevel = 'medium';
@@ -18828,6 +20481,39 @@ function buildGovernanceConcerns(summary) {
   const sceneBatchPassRate = Number(releaseGate.scene_package_batch_pass_rate_percent);
   const driftAlertRate = Number(releaseGate.drift_alert_rate_percent);
   const driftBlockedRuns = Number(releaseGate.drift_blocked_runs);
+  const weeklyOpsKnownRuns = Number(releaseGate.weekly_ops_known_runs);
+  const weeklyOpsBlockedRuns = Number(releaseGate.weekly_ops_blocked_runs);
+  const weeklyOpsBlockRate = Number(releaseGate.weekly_ops_block_rate_percent);
+  const weeklyOpsViolationsTotal = Number(releaseGate.weekly_ops_violations_total);
+  const weeklyOpsWarningsTotal = Number(releaseGate.weekly_ops_warnings_total);
+  const weeklyOpsConfigWarningsTotal = Number(releaseGate.weekly_ops_config_warnings_total);
+  const weeklyOpsAuthTierBlockRateMax = Number(
+    releaseGate.weekly_ops_authorization_tier_block_rate_max_percent
+  );
+  const weeklyOpsDialogueBlockRateMax = Number(
+    releaseGate.weekly_ops_dialogue_authorization_block_rate_max_percent
+  );
+  const weeklyOpsLatestRuntimeBlockRate = Number(
+    releaseGate.latest_weekly_ops_runtime_block_rate_percent
+  );
+  const weeklyOpsLatestRuntimeUiModeViolationTotal = Number(
+    releaseGate.latest_weekly_ops_runtime_ui_mode_violation_total
+  );
+  const weeklyOpsLatestRuntimeUiModeViolationRate = Number(
+    releaseGate.latest_weekly_ops_runtime_ui_mode_violation_rate_percent
+  );
+  const weeklyOpsRuntimeBlockRateMax = Number(
+    releaseGate.weekly_ops_runtime_block_rate_max_percent
+  );
+  const weeklyOpsRuntimeUiModeViolationTotal = Number(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_total
+  );
+  const weeklyOpsRuntimeUiModeViolationRunRate = Number(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_run_rate_percent
+  );
+  const weeklyOpsRuntimeUiModeViolationRateMax = Number(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_rate_max_percent
+  );
   const handoffQuality = summary && summary.handoff_quality && typeof summary.handoff_quality === 'object'
     ? summary.handoff_quality
     : {};
@@ -18892,6 +20578,65 @@ function buildGovernanceConcerns(summary) {
     if (Number.isFinite(driftBlockedRuns) && driftBlockedRuns > 0) {
       concerns.push(`${driftBlockedRuns} release(s) were blocked by drift alerts.`);
     }
+    if (Number.isFinite(weeklyOpsKnownRuns) && weeklyOpsKnownRuns > 0) {
+      concerns.push(`Weekly ops signals observed in ${weeklyOpsKnownRuns} release gate run(s).`);
+    }
+    if (Number.isFinite(weeklyOpsBlockedRuns) && weeklyOpsBlockedRuns > 0) {
+      concerns.push(`${weeklyOpsBlockedRuns} release run(s) were blocked by weekly ops gate.`);
+    }
+    if (Number.isFinite(weeklyOpsBlockRate) && weeklyOpsBlockRate > 0) {
+      concerns.push(`Weekly ops block rate is ${weeklyOpsBlockRate}%.`);
+    }
+    if (Number.isFinite(weeklyOpsViolationsTotal) && weeklyOpsViolationsTotal > 0) {
+      concerns.push(`Weekly ops violations total is ${weeklyOpsViolationsTotal}.`);
+    }
+    if (Number.isFinite(weeklyOpsWarningsTotal) && weeklyOpsWarningsTotal > 0) {
+      concerns.push(`Weekly ops warnings total is ${weeklyOpsWarningsTotal}.`);
+    }
+    if (Number.isFinite(weeklyOpsConfigWarningsTotal) && weeklyOpsConfigWarningsTotal > 0) {
+      concerns.push(`Weekly ops config warnings total is ${weeklyOpsConfigWarningsTotal}.`);
+    }
+    if (Number.isFinite(weeklyOpsAuthTierBlockRateMax) && weeklyOpsAuthTierBlockRateMax > 40) {
+      concerns.push(`Weekly ops authorization-tier block-rate max is ${weeklyOpsAuthTierBlockRateMax}%.`);
+    }
+    if (Number.isFinite(weeklyOpsDialogueBlockRateMax) && weeklyOpsDialogueBlockRateMax > 40) {
+      concerns.push(`Weekly ops dialogue-authorization block-rate max is ${weeklyOpsDialogueBlockRateMax}%.`);
+    }
+    if (Number.isFinite(weeklyOpsLatestRuntimeBlockRate) && weeklyOpsLatestRuntimeBlockRate > 0) {
+      concerns.push(`Weekly ops latest runtime block rate is ${weeklyOpsLatestRuntimeBlockRate}%.`);
+    }
+    if (Number.isFinite(weeklyOpsRuntimeBlockRateMax) && weeklyOpsRuntimeBlockRateMax > 0) {
+      concerns.push(`Weekly ops runtime block-rate max is ${weeklyOpsRuntimeBlockRateMax}%.`);
+    }
+    if (
+      Number.isFinite(weeklyOpsLatestRuntimeUiModeViolationTotal) &&
+      weeklyOpsLatestRuntimeUiModeViolationTotal > 0
+    ) {
+      concerns.push(
+        `Weekly ops latest runtime ui-mode violations total is ${weeklyOpsLatestRuntimeUiModeViolationTotal}.`
+      );
+    }
+    if (
+      Number.isFinite(weeklyOpsLatestRuntimeUiModeViolationRate) &&
+      weeklyOpsLatestRuntimeUiModeViolationRate > 0
+    ) {
+      concerns.push(
+        `Weekly ops latest runtime ui-mode violation rate is ${weeklyOpsLatestRuntimeUiModeViolationRate}%.`
+      );
+    }
+    if (Number.isFinite(weeklyOpsRuntimeUiModeViolationTotal) && weeklyOpsRuntimeUiModeViolationTotal > 0) {
+      concerns.push(`Weekly ops runtime ui-mode violations total is ${weeklyOpsRuntimeUiModeViolationTotal}.`);
+    }
+    if (Number.isFinite(weeklyOpsRuntimeUiModeViolationRunRate) && weeklyOpsRuntimeUiModeViolationRunRate > 0) {
+      concerns.push(
+        `Weekly ops runtime ui-mode violation run rate is ${weeklyOpsRuntimeUiModeViolationRunRate}%.`
+      );
+    }
+    if (Number.isFinite(weeklyOpsRuntimeUiModeViolationRateMax) && weeklyOpsRuntimeUiModeViolationRateMax > 0) {
+      concerns.push(
+        `Weekly ops runtime ui-mode violation rate max is ${weeklyOpsRuntimeUiModeViolationRateMax}%.`
+      );
+    }
   }
   if (!handoffAvailable) {
     concerns.push('Handoff release evidence is unavailable; governance lacks handoff quality context.');
@@ -18989,6 +20734,39 @@ function buildGovernanceRecommendations(summary) {
   const driftAlertRate = Number(releaseGate.drift_alert_rate_percent);
   const releaseGatePassRate = Number(releaseGate.pass_rate_percent);
   const sceneBatchPassRate = Number(releaseGate.scene_package_batch_pass_rate_percent);
+  const weeklyOpsKnownRuns = Number(releaseGate.weekly_ops_known_runs);
+  const weeklyOpsBlockedRuns = Number(releaseGate.weekly_ops_blocked_runs);
+  const weeklyOpsBlockRate = Number(releaseGate.weekly_ops_block_rate_percent);
+  const weeklyOpsViolationsTotal = Number(releaseGate.weekly_ops_violations_total);
+  const weeklyOpsWarningsTotal = Number(releaseGate.weekly_ops_warnings_total);
+  const weeklyOpsConfigWarningsTotal = Number(releaseGate.weekly_ops_config_warnings_total);
+  const weeklyOpsAuthTierBlockRateMax = Number(
+    releaseGate.weekly_ops_authorization_tier_block_rate_max_percent
+  );
+  const weeklyOpsDialogueBlockRateMax = Number(
+    releaseGate.weekly_ops_dialogue_authorization_block_rate_max_percent
+  );
+  const weeklyOpsLatestRuntimeBlockRate = Number(
+    releaseGate.latest_weekly_ops_runtime_block_rate_percent
+  );
+  const weeklyOpsLatestRuntimeUiModeViolationTotal = Number(
+    releaseGate.latest_weekly_ops_runtime_ui_mode_violation_total
+  );
+  const weeklyOpsLatestRuntimeUiModeViolationRate = Number(
+    releaseGate.latest_weekly_ops_runtime_ui_mode_violation_rate_percent
+  );
+  const weeklyOpsRuntimeBlockRateMax = Number(
+    releaseGate.weekly_ops_runtime_block_rate_max_percent
+  );
+  const weeklyOpsRuntimeUiModeViolationTotal = Number(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_total
+  );
+  const weeklyOpsRuntimeUiModeViolationRunRate = Number(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_run_rate_percent
+  );
+  const weeklyOpsRuntimeUiModeViolationRateMax = Number(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_rate_max_percent
+  );
   const handoffQuality = summary && summary.handoff_quality && typeof summary.handoff_quality === 'object'
     ? summary.handoff_quality
     : {};
@@ -19047,6 +20825,71 @@ function buildGovernanceRecommendations(summary) {
         '`sce scene package-publish-batch --manifest docs/handoffs/handoff-manifest.json --dry-run --json`.'
       );
     }
+    if (
+      (Number.isFinite(weeklyOpsKnownRuns) && weeklyOpsKnownRuns > 0) &&
+      (
+        (Number.isFinite(weeklyOpsBlockedRuns) && weeklyOpsBlockedRuns > 0) ||
+        (Number.isFinite(weeklyOpsBlockRate) && weeklyOpsBlockRate > 0) ||
+        (Number.isFinite(weeklyOpsViolationsTotal) && weeklyOpsViolationsTotal > 0) ||
+        (Number.isFinite(weeklyOpsWarningsTotal) && weeklyOpsWarningsTotal > 0) ||
+        (Number.isFinite(weeklyOpsRuntimeBlockRateMax) && weeklyOpsRuntimeBlockRateMax > 0) ||
+        (Number.isFinite(weeklyOpsRuntimeUiModeViolationTotal) && weeklyOpsRuntimeUiModeViolationTotal > 0) ||
+        (Number.isFinite(weeklyOpsRuntimeUiModeViolationRunRate) && weeklyOpsRuntimeUiModeViolationRunRate > 0)
+      )
+    ) {
+      recommendations.push(
+        'Rebuild weekly ops summary and gate evidence with ' +
+        '`node scripts/release-ops-weekly-summary.js --json` + `node scripts/release-weekly-ops-gate.js`.'
+      );
+      recommendations.push(
+        'Export weekly/drift remediation pack with ' +
+        '`node scripts/release-risk-remediation-bundle.js --gate-report .kiro/reports/release-evidence/release-gate.json --json`.'
+      );
+    }
+    if (Number.isFinite(weeklyOpsConfigWarningsTotal) && weeklyOpsConfigWarningsTotal > 0) {
+      recommendations.push(
+        'Fix invalid weekly ops threshold variables (`KSE_RELEASE_WEEKLY_OPS_*`) and rerun release gates ' +
+        'to clear config warnings.'
+      );
+    }
+    if (
+      (Number.isFinite(weeklyOpsLatestRuntimeUiModeViolationTotal) && weeklyOpsLatestRuntimeUiModeViolationTotal > 0) ||
+      (Number.isFinite(weeklyOpsRuntimeUiModeViolationTotal) && weeklyOpsRuntimeUiModeViolationTotal > 0) ||
+      (Number.isFinite(weeklyOpsLatestRuntimeUiModeViolationRate) && weeklyOpsLatestRuntimeUiModeViolationRate > 0) ||
+      (Number.isFinite(weeklyOpsRuntimeUiModeViolationRateMax) && weeklyOpsRuntimeUiModeViolationRateMax > 0) ||
+      (Number.isFinite(weeklyOpsRuntimeUiModeViolationRunRate) && weeklyOpsRuntimeUiModeViolationRunRate > 0)
+    ) {
+      recommendations.push(
+        'Rebuild interactive runtime governance evidence with ' +
+        '`node scripts/interactive-governance-report.js --period weekly --fail-on-alert --json`.'
+      );
+      recommendations.push(
+        'Review runtime ui-mode policy baseline (`docs/interactive-customization/runtime-mode-policy-baseline.json`) ' +
+        'to keep `user-app` suggestion-only and route apply traffic to `ops-console`.'
+      );
+    }
+    if (
+      (Number.isFinite(weeklyOpsLatestRuntimeBlockRate) && weeklyOpsLatestRuntimeBlockRate > 40) ||
+      (Number.isFinite(weeklyOpsRuntimeBlockRateMax) && weeklyOpsRuntimeBlockRateMax > 40)
+    ) {
+      recommendations.push(
+        'Reduce runtime deny/review pressure by tuning authorization and runtime mode policy, then rerun ' +
+        '`node scripts/interactive-governance-report.js --period weekly --json`.'
+      );
+    }
+    if (
+      (Number.isFinite(weeklyOpsAuthTierBlockRateMax) && weeklyOpsAuthTierBlockRateMax > 40) ||
+      (Number.isFinite(weeklyOpsDialogueBlockRateMax) && weeklyOpsDialogueBlockRateMax > 40)
+    ) {
+      recommendations.push(
+        'Tune authorization-tier policy pressure with ' +
+        '`node scripts/interactive-authorization-tier-evaluate.js --policy docs/interactive-customization/authorization-tier-policy-baseline.json --json`.'
+      );
+      recommendations.push(
+        'Tune dialogue authorization policy pressure with ' +
+        '`node scripts/interactive-dialogue-governance.js --policy docs/interactive-customization/dialogue-governance-policy-baseline.json --authorization-dialogue-policy docs/interactive-customization/authorization-dialogue-policy-baseline.json --json`.'
+      );
+    }
   }
   if (!handoffAvailable) {
     recommendations.push(
@@ -19263,6 +21106,12 @@ async function buildAutoObservabilitySnapshot(projectPath, options = {}) {
     (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',
@@ -19284,6 +21133,36 @@ async function buildAutoObservabilitySnapshot(projectPath, options = {}) {
       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: {
@@ -19291,6 +21170,7 @@ async function buildAutoObservabilitySnapshot(projectPath, options = {}) {
       batch_session: batchStats,
       controller_session: controllerStats,
       governance_session: governanceSessionStats,
+      governance_weekly_ops_stop: governanceWeeklyOpsStop,
       governance_health: governanceHealth,
       kpi_trend: trend
     }
@@ -20400,8 +22280,12 @@ function resolveGovernanceCloseLoopRunStatus(stopReason, converged) {
 }
 
 function evaluateGovernanceReleaseGateBlockState(assessment) {
+  const releaseGate = assessment && assessment.health && assessment.health.release_gate &&
+    typeof assessment.health.release_gate === 'object'
+    ? assessment.health.release_gate
+    : {};
   const snapshot = normalizeGovernanceReleaseGateSnapshot(
-    assessment && assessment.health ? assessment.health.release_gate : null
+    releaseGate
   );
   const handoffSnapshot = normalizeGovernanceHandoffQualitySnapshot(
     assessment && assessment.health ? assessment.health.handoff_quality : null
@@ -20424,6 +22308,49 @@ function evaluateGovernanceReleaseGateBlockState(assessment) {
 
   const reasons = [];
   if (snapshot && snapshot.available === true) {
+    const weeklyOpsLatestBlocked = parseAutoHandoffGateBoolean(releaseGate.latest_weekly_ops_blocked, null);
+    const weeklyOpsLatestRiskLevel = `${releaseGate.latest_weekly_ops_risk_level || ''}`.trim().toLowerCase();
+    const weeklyOpsLatestGovernanceStatus = `${releaseGate.latest_weekly_ops_governance_status || ''}`.trim().toLowerCase();
+    const weeklyOpsLatestConfigWarningCount = Number(releaseGate.latest_weekly_ops_config_warning_count);
+    const weeklyOpsLatestAuthorizationTierBlockRate = Number(
+      releaseGate.latest_weekly_ops_authorization_tier_block_rate_percent
+    );
+    const weeklyOpsLatestDialogueAuthorizationBlockRate = Number(
+      releaseGate.latest_weekly_ops_dialogue_authorization_block_rate_percent
+    );
+    const weeklyOpsLatestRuntimeBlockRate = Number(
+      releaseGate.latest_weekly_ops_runtime_block_rate_percent
+    );
+    const weeklyOpsLatestRuntimeUiModeViolationTotal = Number(
+      releaseGate.latest_weekly_ops_runtime_ui_mode_violation_total
+    );
+    const weeklyOpsLatestRuntimeUiModeViolationRate = Number(
+      releaseGate.latest_weekly_ops_runtime_ui_mode_violation_rate_percent
+    );
+    const weeklyOpsBlockedRuns = Number(releaseGate.weekly_ops_blocked_runs);
+    const weeklyOpsBlockRate = Number(releaseGate.weekly_ops_block_rate_percent);
+    const weeklyOpsViolationsTotal = Number(releaseGate.weekly_ops_violations_total);
+    const weeklyOpsWarningsTotal = Number(releaseGate.weekly_ops_warnings_total);
+    const weeklyOpsConfigWarningsTotal = Number(releaseGate.weekly_ops_config_warnings_total);
+    const weeklyOpsAuthorizationTierBlockRateMax = Number(
+      releaseGate.weekly_ops_authorization_tier_block_rate_max_percent
+    );
+    const weeklyOpsDialogueAuthorizationBlockRateMax = Number(
+      releaseGate.weekly_ops_dialogue_authorization_block_rate_max_percent
+    );
+    const weeklyOpsRuntimeBlockRateMax = Number(
+      releaseGate.weekly_ops_runtime_block_rate_max_percent
+    );
+    const weeklyOpsRuntimeUiModeViolationTotal = Number(
+      releaseGate.weekly_ops_runtime_ui_mode_violation_total
+    );
+    const weeklyOpsRuntimeUiModeViolationRunRate = Number(
+      releaseGate.weekly_ops_runtime_ui_mode_violation_run_rate_percent
+    );
+    const weeklyOpsRuntimeUiModeViolationRateMax = Number(
+      releaseGate.weekly_ops_runtime_ui_mode_violation_rate_max_percent
+    );
+
     if (snapshot.latest_gate_passed === false) {
       reasons.push('latest-release-gate-failed');
     }
@@ -20442,6 +22369,107 @@ function evaluateGovernanceReleaseGateBlockState(assessment) {
     if (Number.isFinite(snapshot.drift_blocked_runs) && snapshot.drift_blocked_runs > 0) {
       reasons.push(`drift-blocked-runs-positive:${snapshot.drift_blocked_runs}`);
     }
+    if (weeklyOpsLatestBlocked === true) {
+      reasons.push('weekly-ops-latest-blocked');
+    }
+    if (weeklyOpsLatestRiskLevel === 'high') {
+      reasons.push('weekly-ops-latest-risk-high');
+    }
+    if (weeklyOpsLatestGovernanceStatus && ['alert', 'blocked', 'degraded'].includes(weeklyOpsLatestGovernanceStatus)) {
+      reasons.push(`weekly-ops-governance-status:${weeklyOpsLatestGovernanceStatus}`);
+    }
+    if (Number.isFinite(weeklyOpsLatestConfigWarningCount) && weeklyOpsLatestConfigWarningCount > 0) {
+      reasons.push(`weekly-ops-latest-config-warnings-positive:${weeklyOpsLatestConfigWarningCount}`);
+    }
+    if (
+      Number.isFinite(weeklyOpsLatestAuthorizationTierBlockRate) &&
+      weeklyOpsLatestAuthorizationTierBlockRate > 40
+    ) {
+      reasons.push(
+        `weekly-ops-latest-auth-tier-block-rate-high:${weeklyOpsLatestAuthorizationTierBlockRate}`
+      );
+    }
+    if (
+      Number.isFinite(weeklyOpsLatestDialogueAuthorizationBlockRate) &&
+      weeklyOpsLatestDialogueAuthorizationBlockRate > 40
+    ) {
+      reasons.push(
+        `weekly-ops-latest-dialogue-authorization-block-rate-high:` +
+        `${weeklyOpsLatestDialogueAuthorizationBlockRate}`
+      );
+    }
+    if (Number.isFinite(weeklyOpsLatestRuntimeBlockRate) && weeklyOpsLatestRuntimeBlockRate > 40) {
+      reasons.push(`weekly-ops-latest-runtime-block-rate-high:${weeklyOpsLatestRuntimeBlockRate}`);
+    }
+    if (
+      Number.isFinite(weeklyOpsLatestRuntimeUiModeViolationTotal) &&
+      weeklyOpsLatestRuntimeUiModeViolationTotal > 0
+    ) {
+      reasons.push(
+        `weekly-ops-latest-runtime-ui-mode-violations-positive:${weeklyOpsLatestRuntimeUiModeViolationTotal}`
+      );
+    }
+    if (
+      Number.isFinite(weeklyOpsLatestRuntimeUiModeViolationRate) &&
+      weeklyOpsLatestRuntimeUiModeViolationRate > 0
+    ) {
+      reasons.push(
+        `weekly-ops-latest-runtime-ui-mode-violation-rate-positive:${weeklyOpsLatestRuntimeUiModeViolationRate}`
+      );
+    }
+    if (Number.isFinite(weeklyOpsBlockedRuns) && weeklyOpsBlockedRuns > 0) {
+      reasons.push(`weekly-ops-blocked-runs-positive:${weeklyOpsBlockedRuns}`);
+    }
+    if (Number.isFinite(weeklyOpsBlockRate) && weeklyOpsBlockRate > 0) {
+      reasons.push(`weekly-ops-block-rate-positive:${weeklyOpsBlockRate}`);
+    }
+    if (Number.isFinite(weeklyOpsViolationsTotal) && weeklyOpsViolationsTotal > 0) {
+      reasons.push(`weekly-ops-violations-positive:${weeklyOpsViolationsTotal}`);
+    }
+    if (Number.isFinite(weeklyOpsWarningsTotal) && weeklyOpsWarningsTotal > 0) {
+      reasons.push(`weekly-ops-warnings-positive:${weeklyOpsWarningsTotal}`);
+    }
+    if (Number.isFinite(weeklyOpsConfigWarningsTotal) && weeklyOpsConfigWarningsTotal > 0) {
+      reasons.push(`weekly-ops-config-warnings-positive:${weeklyOpsConfigWarningsTotal}`);
+    }
+    if (
+      Number.isFinite(weeklyOpsAuthorizationTierBlockRateMax) &&
+      weeklyOpsAuthorizationTierBlockRateMax > 40
+    ) {
+      reasons.push(
+        `weekly-ops-auth-tier-block-rate-high:${weeklyOpsAuthorizationTierBlockRateMax}`
+      );
+    }
+    if (
+      Number.isFinite(weeklyOpsDialogueAuthorizationBlockRateMax) &&
+      weeklyOpsDialogueAuthorizationBlockRateMax > 40
+    ) {
+      reasons.push(
+        `weekly-ops-dialogue-authorization-block-rate-high:${weeklyOpsDialogueAuthorizationBlockRateMax}`
+      );
+    }
+    if (Number.isFinite(weeklyOpsRuntimeBlockRateMax) && weeklyOpsRuntimeBlockRateMax > 40) {
+      reasons.push(`weekly-ops-runtime-block-rate-high:${weeklyOpsRuntimeBlockRateMax}`);
+    }
+    if (Number.isFinite(weeklyOpsRuntimeUiModeViolationTotal) && weeklyOpsRuntimeUiModeViolationTotal > 0) {
+      reasons.push(`weekly-ops-runtime-ui-mode-violations-positive:${weeklyOpsRuntimeUiModeViolationTotal}`);
+    }
+    if (
+      Number.isFinite(weeklyOpsRuntimeUiModeViolationRunRate) &&
+      weeklyOpsRuntimeUiModeViolationRunRate > 0
+    ) {
+      reasons.push(
+        `weekly-ops-runtime-ui-mode-violation-run-rate-positive:${weeklyOpsRuntimeUiModeViolationRunRate}`
+      );
+    }
+    if (
+      Number.isFinite(weeklyOpsRuntimeUiModeViolationRateMax) &&
+      weeklyOpsRuntimeUiModeViolationRateMax > 0
+    ) {
+      reasons.push(
+        `weekly-ops-runtime-ui-mode-violation-rate-high:${weeklyOpsRuntimeUiModeViolationRateMax}`
+      );
+    }
   }
 
   if (
@@ -20535,6 +22563,26 @@ function evaluateGovernanceReleaseGateBlockState(assessment) {
       (Number.isFinite(snapshot.drift_blocked_runs) && snapshot.drift_blocked_runs > 0)
     )
   );
+  const blockedByWeeklyOps = reasons.some(item => (
+    `${item}` === 'weekly-ops-latest-blocked'
+    || `${item}` === 'weekly-ops-latest-risk-high'
+    || `${item}`.startsWith('weekly-ops-governance-status:')
+    || `${item}`.startsWith('weekly-ops-latest-config-warnings-positive:')
+    || `${item}`.startsWith('weekly-ops-config-warnings-positive:')
+    || `${item}`.startsWith('weekly-ops-blocked-runs-positive:')
+    || `${item}`.startsWith('weekly-ops-block-rate-positive:')
+    || `${item}`.startsWith('weekly-ops-latest-auth-tier-block-rate-high:')
+    || `${item}`.startsWith('weekly-ops-auth-tier-block-rate-high:')
+    || `${item}`.startsWith('weekly-ops-latest-dialogue-authorization-block-rate-high:')
+    || `${item}`.startsWith('weekly-ops-dialogue-authorization-block-rate-high:')
+    || `${item}`.startsWith('weekly-ops-latest-runtime-block-rate-high:')
+    || `${item}`.startsWith('weekly-ops-runtime-block-rate-high:')
+    || `${item}`.startsWith('weekly-ops-latest-runtime-ui-mode-violations-positive:')
+    || `${item}`.startsWith('weekly-ops-runtime-ui-mode-violations-positive:')
+    || `${item}`.startsWith('weekly-ops-latest-runtime-ui-mode-violation-rate-positive:')
+    || `${item}`.startsWith('weekly-ops-runtime-ui-mode-violation-run-rate-positive:')
+    || `${item}`.startsWith('weekly-ops-runtime-ui-mode-violation-rate-high:')
+  ));
   const blockedByHandoffQuality = reasons.some(item => (
     `${item}`.startsWith('handoff-latest-status:')
     || `${item}` === 'handoff-latest-gate-failed'
@@ -20548,7 +22596,7 @@ function evaluateGovernanceReleaseGateBlockState(assessment) {
     || `${item}`.startsWith('handoff-moqui-matrix-regressions-positive:')
     || `${item}`.startsWith('handoff-moqui-matrix-regressions-over-gate:')
   ));
-  const blocked = reasons.length > 0 && (blockedByReleaseGate || blockedByHandoffQuality);
+  const blocked = reasons.length > 0 && (blockedByReleaseGate || blockedByWeeklyOps || blockedByHandoffQuality);
   return {
     blocked,
     reasons,
@@ -20581,6 +22629,46 @@ function buildGovernanceCloseLoopRecommendations(finalAssessment, stopReason, st
       'Rerun and stabilize scene batch quality: `sce scene package-publish-batch --manifest docs/handoffs/handoff-manifest.json --dry-run --json`.'
     );
   }
+  if (reasons.some(item => `${item}`.startsWith('weekly-ops-'))) {
+    base.push(
+      'Rebuild weekly release pressure signals with `node scripts/release-ops-weekly-summary.js --json` + ' +
+      '`node scripts/release-weekly-ops-gate.js`.'
+    );
+  }
+  if (reasons.some(item => `${item}`.includes('weekly-ops-config-warnings'))) {
+    base.push(
+      'Fix invalid weekly ops threshold variables (`KSE_RELEASE_WEEKLY_OPS_*`) and rerun release gates ' +
+      'to clear config warnings.'
+    );
+  }
+  if (reasons.some(item => `${item}`.includes('weekly-ops-auth-tier-block-rate'))) {
+    base.push(
+      'Tune authorization-tier policy pressure with ' +
+      '`node scripts/interactive-authorization-tier-evaluate.js --policy docs/interactive-customization/authorization-tier-policy-baseline.json --json`.'
+    );
+  }
+  if (reasons.some(item => `${item}`.includes('weekly-ops-dialogue-authorization-block-rate'))) {
+    base.push(
+      'Tune dialogue authorization policy pressure with ' +
+      '`node scripts/interactive-dialogue-governance.js --policy docs/interactive-customization/dialogue-governance-policy-baseline.json --authorization-dialogue-policy docs/interactive-customization/authorization-dialogue-policy-baseline.json --json`.'
+    );
+  }
+  if (reasons.some(item => `${item}`.includes('runtime-ui-mode'))) {
+    base.push(
+      'Regenerate runtime governance evidence with ' +
+      '`node scripts/interactive-governance-report.js --period weekly --fail-on-alert --json`.'
+    );
+    base.push(
+      'Review runtime ui-mode contract in `docs/interactive-customization/runtime-mode-policy-baseline.json` ' +
+      'to keep `user-app` suggestion-only and route apply actions to `ops-console`.'
+    );
+  }
+  if (reasons.some(item => `${item}`.includes('runtime-block-rate'))) {
+    base.push(
+      'Reduce runtime deny/review pressure by tuning runtime mode policy and rerunning ' +
+      '`node scripts/interactive-governance-report.js --period weekly --json`.'
+    );
+  }
   if (reasons.some(item => `${item}`.startsWith('handoff-'))) {
     base.push('Review handoff quality with `sce auto handoff evidence --window 5 --json`.');
     base.push(
@@ -20631,6 +22719,161 @@ function extractGovernanceReleaseGateSnapshot(assessment) {
   };
 }
 
+function extractGovernanceWeeklyOpsStopDetail(releaseGateCandidate) {
+  const releaseGate = releaseGateCandidate && typeof releaseGateCandidate === 'object' && !Array.isArray(releaseGateCandidate)
+    ? releaseGateCandidate
+    : null;
+  if (!releaseGate) {
+    return null;
+  }
+
+  const latestRiskLevelRaw = normalizeHandoffText(releaseGate.latest_weekly_ops_risk_level);
+  const latestRiskLevel = latestRiskLevelRaw
+    ? normalizeAutoHandoffGateRiskLevel(latestRiskLevelRaw)
+    : null;
+  const latestGovernanceStatus = normalizeHandoffText(releaseGate.latest_weekly_ops_governance_status);
+  const latestBlocked = parseAutoHandoffGateBoolean(releaseGate.latest_weekly_ops_blocked, null);
+  const latestAuthorizationTierBlockRatePercent = toGovernanceReleaseGateNumber(
+    releaseGate.latest_weekly_ops_authorization_tier_block_rate_percent
+  );
+  const latestDialogueAuthorizationBlockRatePercent = toGovernanceReleaseGateNumber(
+    releaseGate.latest_weekly_ops_dialogue_authorization_block_rate_percent
+  );
+  const latestConfigWarningCount = toGovernanceReleaseGateNumber(
+    releaseGate.latest_weekly_ops_config_warning_count
+  );
+  const latestRuntimeBlockRatePercent = toGovernanceReleaseGateNumber(
+    releaseGate.latest_weekly_ops_runtime_block_rate_percent
+  );
+  const latestRuntimeUiModeViolationTotal = toGovernanceReleaseGateNumber(
+    releaseGate.latest_weekly_ops_runtime_ui_mode_violation_total
+  );
+  const latestRuntimeUiModeViolationRatePercent = toGovernanceReleaseGateNumber(
+    releaseGate.latest_weekly_ops_runtime_ui_mode_violation_rate_percent
+  );
+  const blockedRuns = toGovernanceReleaseGateNumber(releaseGate.weekly_ops_blocked_runs);
+  const blockRatePercent = toGovernanceReleaseGateNumber(releaseGate.weekly_ops_block_rate_percent);
+  const violationsTotal = toGovernanceReleaseGateNumber(releaseGate.weekly_ops_violations_total);
+  const warningsTotal = toGovernanceReleaseGateNumber(releaseGate.weekly_ops_warnings_total);
+  const configWarningsTotal = toGovernanceReleaseGateNumber(releaseGate.weekly_ops_config_warnings_total);
+  const authorizationTierBlockRateMaxPercent = toGovernanceReleaseGateNumber(
+    releaseGate.weekly_ops_authorization_tier_block_rate_max_percent
+  );
+  const dialogueAuthorizationBlockRateMaxPercent = toGovernanceReleaseGateNumber(
+    releaseGate.weekly_ops_dialogue_authorization_block_rate_max_percent
+  );
+  const runtimeBlockRateMaxPercent = toGovernanceReleaseGateNumber(
+    releaseGate.weekly_ops_runtime_block_rate_max_percent
+  );
+  const runtimeUiModeViolationTotal = toGovernanceReleaseGateNumber(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_total
+  );
+  const runtimeUiModeViolationRunRatePercent = toGovernanceReleaseGateNumber(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_run_rate_percent
+  );
+  const runtimeUiModeViolationRateMaxPercent = toGovernanceReleaseGateNumber(
+    releaseGate.weekly_ops_runtime_ui_mode_violation_rate_max_percent
+  );
+
+  const hasSignal = (
+    typeof latestBlocked === 'boolean' ||
+    !!latestRiskLevel ||
+    !!latestGovernanceStatus ||
+    Number.isFinite(latestAuthorizationTierBlockRatePercent) ||
+    Number.isFinite(latestDialogueAuthorizationBlockRatePercent) ||
+    Number.isFinite(latestConfigWarningCount) ||
+    Number.isFinite(latestRuntimeBlockRatePercent) ||
+    Number.isFinite(latestRuntimeUiModeViolationTotal) ||
+    Number.isFinite(latestRuntimeUiModeViolationRatePercent) ||
+    Number.isFinite(blockedRuns) ||
+    Number.isFinite(blockRatePercent) ||
+    Number.isFinite(violationsTotal) ||
+    Number.isFinite(warningsTotal) ||
+    Number.isFinite(configWarningsTotal) ||
+    Number.isFinite(authorizationTierBlockRateMaxPercent) ||
+    Number.isFinite(dialogueAuthorizationBlockRateMaxPercent) ||
+    Number.isFinite(runtimeBlockRateMaxPercent) ||
+    Number.isFinite(runtimeUiModeViolationTotal) ||
+    Number.isFinite(runtimeUiModeViolationRunRatePercent) ||
+    Number.isFinite(runtimeUiModeViolationRateMaxPercent)
+  );
+  if (!hasSignal) {
+    return null;
+  }
+
+  const latestAuthTierPressureRate = Number.isFinite(latestAuthorizationTierBlockRatePercent)
+    ? latestAuthorizationTierBlockRatePercent
+    : authorizationTierBlockRateMaxPercent;
+  const latestDialoguePressureRate = Number.isFinite(latestDialogueAuthorizationBlockRatePercent)
+    ? latestDialogueAuthorizationBlockRatePercent
+    : dialogueAuthorizationBlockRateMaxPercent;
+  const highPressure = (
+    latestBlocked === true ||
+    latestRiskLevel === 'high' ||
+    (Number.isFinite(blockedRuns) && blockedRuns > 0) ||
+    (Number.isFinite(blockRatePercent) && blockRatePercent >= 40) ||
+    (Number.isFinite(latestAuthTierPressureRate) && latestAuthTierPressureRate >= 60) ||
+    (Number.isFinite(latestDialoguePressureRate) && latestDialoguePressureRate >= 60) ||
+    (Number.isFinite(latestRuntimeUiModeViolationTotal) && latestRuntimeUiModeViolationTotal > 0) ||
+    (Number.isFinite(runtimeUiModeViolationTotal) && runtimeUiModeViolationTotal > 0) ||
+    (Number.isFinite(latestRuntimeUiModeViolationRatePercent) && latestRuntimeUiModeViolationRatePercent > 0) ||
+    (Number.isFinite(runtimeUiModeViolationRunRatePercent) && runtimeUiModeViolationRunRatePercent > 0) ||
+    (Number.isFinite(runtimeUiModeViolationRateMaxPercent) && runtimeUiModeViolationRateMaxPercent > 0) ||
+    (Number.isFinite(latestRuntimeBlockRatePercent) && latestRuntimeBlockRatePercent >= 40) ||
+    (Number.isFinite(runtimeBlockRateMaxPercent) && runtimeBlockRateMaxPercent >= 40)
+  );
+
+  return {
+    latest: {
+      blocked: latestBlocked,
+      risk_level: latestRiskLevel,
+      governance_status: latestGovernanceStatus || null,
+      authorization_tier_block_rate_percent: latestAuthorizationTierBlockRatePercent,
+      dialogue_authorization_block_rate_percent: latestDialogueAuthorizationBlockRatePercent,
+      config_warning_count: latestConfigWarningCount,
+      runtime_block_rate_percent: latestRuntimeBlockRatePercent,
+      runtime_ui_mode_violation_total: latestRuntimeUiModeViolationTotal,
+      runtime_ui_mode_violation_rate_percent: latestRuntimeUiModeViolationRatePercent
+    },
+    aggregates: {
+      blocked_runs: blockedRuns,
+      block_rate_percent: blockRatePercent,
+      violations_total: violationsTotal,
+      warnings_total: warningsTotal,
+      config_warnings_total: configWarningsTotal,
+      authorization_tier_block_rate_max_percent: authorizationTierBlockRateMaxPercent,
+      dialogue_authorization_block_rate_max_percent: dialogueAuthorizationBlockRateMaxPercent,
+      runtime_block_rate_max_percent: runtimeBlockRateMaxPercent,
+      runtime_ui_mode_violation_total: runtimeUiModeViolationTotal,
+      runtime_ui_mode_violation_run_rate_percent: runtimeUiModeViolationRunRatePercent,
+      runtime_ui_mode_violation_rate_max_percent: runtimeUiModeViolationRateMaxPercent
+    },
+    pressure: {
+      blocked: latestBlocked === true || (Number.isFinite(blockedRuns) && blockedRuns > 0),
+      high: highPressure,
+      config_warning_positive: (
+        (Number.isFinite(latestConfigWarningCount) && latestConfigWarningCount > 0) ||
+        (Number.isFinite(configWarningsTotal) && configWarningsTotal > 0)
+      ),
+      auth_tier_block_rate_high: Number.isFinite(latestAuthTierPressureRate) && latestAuthTierPressureRate > 40,
+      dialogue_authorization_block_rate_high: (
+        Number.isFinite(latestDialoguePressureRate) && latestDialoguePressureRate > 40
+      ),
+      runtime_block_rate_high: (
+        (Number.isFinite(latestRuntimeBlockRatePercent) && latestRuntimeBlockRatePercent > 40) ||
+        (Number.isFinite(runtimeBlockRateMaxPercent) && runtimeBlockRateMaxPercent > 40)
+      ),
+      runtime_ui_mode_violation_high: (
+        (Number.isFinite(latestRuntimeUiModeViolationTotal) && latestRuntimeUiModeViolationTotal > 0) ||
+        (Number.isFinite(runtimeUiModeViolationTotal) && runtimeUiModeViolationTotal > 0) ||
+        (Number.isFinite(latestRuntimeUiModeViolationRatePercent) && latestRuntimeUiModeViolationRatePercent > 0) ||
+        (Number.isFinite(runtimeUiModeViolationRunRatePercent) && runtimeUiModeViolationRunRatePercent > 0) ||
+        (Number.isFinite(runtimeUiModeViolationRateMaxPercent) && runtimeUiModeViolationRateMaxPercent > 0)
+      )
+    }
+  };
+}
+
 async function runAutoGovernanceCloseLoop(projectPath, options = {}) {
   let resumedGovernanceSession = null;
   if (options.governanceResume) {
@@ -20949,11 +23192,17 @@ async function runAutoGovernanceCloseLoop(projectPath, options = {}) {
     }
     const releaseGateBlockState = evaluateGovernanceReleaseGateBlockState(effectiveAfterAssessment);
     if (releaseGateBlockState.blocked) {
+      const weeklyOpsStopDetail = extractGovernanceWeeklyOpsStopDetail(
+        effectiveAfterAssessment &&
+        effectiveAfterAssessment.health &&
+        effectiveAfterAssessment.health.release_gate
+      );
       stopReason = 'release-gate-blocked';
       stopDetail = {
         type: 'release-gate-block',
         reasons: releaseGateBlockState.reasons,
-        release_gate: releaseGateBlockState.snapshot
+        release_gate: releaseGateBlockState.snapshot,
+        weekly_ops: weeklyOpsStopDetail
       };
       break;
     }