kiro-spec-engine 1.47.32 → 1.47.33

package/docs/command-reference.md

@@ -765,16 +765,18 @@ Dual-track handoff integration:
 - `kse auto handoff plan --manifest <path> [--out <path>] [--strict] [--strict-warnings] [--json]`: parse handoff manifest (source project, specs, templates, known gaps) and generate an executable KSE integration phase plan.
 - `kse auto handoff queue --manifest <path> [--out <path>] [--append] [--no-include-known-gaps] [--dry-run] [--json]`: generate close-loop batch goal queue from handoff manifest and optionally persist line-based queue file (default `.kiro/auto/handoff-goals.lines`).
 - `kse auto handoff template-diff --manifest <path> [--json]`: compare manifest templates against local template exports/registry and report `missing_in_local` and `extra_in_local`.
-- `kse auto handoff run --manifest <path> [--out <path>] [--queue-out <path>] [--append] [--no-include-known-gaps] [--continue-from <session|latest|file>] [--continue-strategy <auto|pending|failed-only>] [--dry-run] [--strict] [--strict-warnings] [--no-dependency-batching] [--min-spec-success-rate <n>] [--max-risk-level <level>] [--no-require-ontology-validation] [--release-evidence-window <n>] [--json]`: execute handoff end-to-end (`plan -> queue -> close-loop-batch -> observability`) with automatic report archive to `.kiro/reports/handoff-runs/<session>.json`.
+- `kse auto handoff run --manifest <path> [--out <path>] [--queue-out <path>] [--append] [--no-include-known-gaps] [--continue-from <session|latest|file>] [--continue-strategy <auto|pending|failed-only>] [--dry-run] [--strict] [--strict-warnings] [--no-dependency-batching] [--min-spec-success-rate <n>] [--max-risk-level <level>] [--no-require-ontology-validation] [--no-require-moqui-baseline] [--min-capability-coverage <n>] [--no-require-capability-coverage] [--release-evidence-window <n>] [--json]`: execute handoff end-to-end (`plan -> queue -> close-loop-batch -> observability`) with automatic report archive to `.kiro/reports/handoff-runs/<session>.json`.
   - Default mode is dependency-aware: spec integration goals are grouped into dependency batches and executed in topological order.
   - `--continue-from` resumes pending goals from an existing handoff run report (`latest`, session id, or JSON file path). For safety, KSE enforces manifest-path consistency between the previous report and current run.
   - `--continue-strategy auto|pending|failed-only` controls resumed scope. `auto` (default) derives the best strategy from prior run state (`pending` when unprocessed/planned goals exist, otherwise `failed-only` for pure failure replay).
-  - Non-dry runs auto-merge release evidence into `.kiro/reports/release-evidence/handoff-runs.json` with session-level gate/ontology/regression/moqui-baseline snapshots. Merge failures are recorded as warnings without aborting the run.
+  - Non-dry runs auto-merge release evidence into `.kiro/reports/release-evidence/handoff-runs.json` with session-level gate/ontology/regression/moqui-baseline/capability-coverage snapshots. Merge failures are recorded as warnings without aborting the run.
   - `--release-evidence-window` controls trend snapshot window size (2-50, default `5`) used in merged release evidence (`latest_trend_window` and per-session `trend_window`).
   - Run output includes `moqui_baseline` snapshot by default, with artifacts at `.kiro/reports/release-evidence/moqui-template-baseline.json` and `.kiro/reports/release-evidence/moqui-template-baseline.md`.
+  - Run output includes `moqui_capability_coverage` snapshot by default (when manifest `capabilities` is declared), with artifacts at `.kiro/reports/release-evidence/moqui-capability-coverage.json` and `.kiro/reports/release-evidence/moqui-capability-coverage.md`.
+  - When Moqui baseline/capability gates fail, KSE auto-generates remediation queue lines at `.kiro/auto/moqui-remediation.lines`.
   - Run result includes `recommendations` with executable follow-up commands (for example, auto-generated `--continue-from <session>` on failed/incomplete batches).
-  - Gate defaults: `--min-spec-success-rate` defaults to `100`, `--max-risk-level` defaults to `high`, and ontology validation requirement is enabled by default.
-  - Use `--no-require-ontology-validation` only for emergency bypass; default behavior fails fast at precheck if manifest ontology evidence is missing or not passed.
+  - Gate defaults: `--min-spec-success-rate` defaults to `100`, `--max-risk-level` defaults to `high`, ontology validation requirement is enabled by default, Moqui baseline requirement is enabled by default, and capability coverage minimum defaults to `100` when manifest `capabilities` is declared.
+  - Use `--no-require-ontology-validation`, `--no-require-moqui-baseline`, or `--no-require-capability-coverage` only for emergency bypass.
 - `kse auto handoff regression [--session-id <id|latest>] [--window <n>] [--format <json|markdown>] [--out <path>] [--json]`: compare one handoff run report with its previous run and output trend deltas (success-rate/risk/failed-goals/elapsed time).
   - `--window` (2-50, default `2`) returns multi-run `series`, `window_trend`, and `aggregates` for broader regression visibility.
   - Regression JSON now includes `risk_layers` (low/medium/high/unknown buckets with per-layer session list and quality aggregates).
@@ -782,11 +784,11 @@ Dual-track handoff integration:
   - Markdown report includes `Trend Series` (ASCII success/ontology bars per session) and `Risk Layer View`.
   - `--out` writes the generated regression report using the selected format.
   - Output includes `recommendations` to guide next action when trend degrades or risk escalates.
-- `kse auto handoff evidence [--file <path>] [--session-id <id|latest>] [--window <n>] [--format <json|markdown>] [--out <path>] [--json]`: quick-review merged release evidence and render current-batch gate/ontology/regression/moqui-baseline/risk-layer overview.
+- `kse auto handoff evidence [--file <path>] [--session-id <id|latest>] [--window <n>] [--format <json|markdown>] [--out <path>] [--json]`: quick-review merged release evidence and render current-batch gate/ontology/regression/moqui-baseline/capability-coverage/risk-layer overview.
   - Default evidence file is `.kiro/reports/release-evidence/handoff-runs.json`.
   - `--window` (1-50, default `5`) controls how many recent sessions are aggregated in review.
   - JSON output includes `current_overview`, `aggregates.status_counts`, `aggregates.gate_pass_rate_percent`, and `risk_layers`.
-  - Markdown output includes `Current Gate`, `Current Ontology`, `Current Regression`, `Current Moqui Baseline`, `Trend Series`, and `Risk Layer View`.
+  - Markdown output includes `Current Gate`, `Current Ontology`, `Current Regression`, `Current Moqui Baseline`, `Current Capability Coverage`, `Trend Series`, and `Risk Layer View`.
   - Add `--release-draft <path>` to auto-generate a release notes draft and evidence review markdown in one run.
   - `--release-version` sets draft version tag (defaults to `v<package.json version>`), and `--release-date` accepts `YYYY-MM-DD` (default: current UTC date).
   - Use `--review-out <path>` to override the generated evidence review markdown path (default `.kiro/reports/release-evidence/handoff-evidence-review.md`).

package/docs/moqui-template-core-library-playbook.md

@@ -14,6 +14,8 @@ KSE defaults already enforce the baseline below:
 
 - `kse auto handoff run`: ontology validation is required by default.
 - `kse auto handoff run`: generates Moqui baseline snapshot by default and appends it to release-evidence sessions.
+- `kse auto handoff run`: requires Moqui baseline portfolio pass by default.
+- `kse auto handoff run`: evaluates capability coverage matrix by default when manifest `capabilities` is declared (default minimum `100%`).
 - `kse scene package-publish-batch`:
   - ontology validation required by default
   - batch ontology gate defaults:
@@ -23,6 +25,8 @@ KSE defaults already enforce the baseline below:
 Emergency bypass exists but is not recommended:
 
 - `--no-require-ontology-validation`
+- `--no-require-moqui-baseline`
+- `--no-require-capability-coverage`
 
 ## One-Shot Intake Flow
 
@@ -65,8 +69,11 @@ Required artifacts for each intake batch:
 - `.kiro/reports/moqui-template-baseline.md`
 - `.kiro/reports/release-evidence/moqui-template-baseline.json`
 - `.kiro/reports/release-evidence/moqui-template-baseline.md`
+- `.kiro/reports/release-evidence/moqui-capability-coverage.json`
+- `.kiro/reports/release-evidence/moqui-capability-coverage.md`
 - `.kiro/reports/handoff-runs/<session>.json`
 - `.kiro/reports/scene-package-ontology-batch.json`
+- `.kiro/auto/moqui-remediation.lines` (when baseline/coverage gaps exist)
 - `.kiro/templates/scene-packages/registry.json`
 - gate output/evidence linked from release notes or handoff summary
 

package/lib/commands/auto.js

@@ -21,6 +21,9 @@ const AUTO_HANDOFF_RELEASE_EVIDENCE_DIR = '.kiro/reports/release-evidence';
 const AUTO_HANDOFF_RELEASE_GATE_HISTORY_FILE = '.kiro/reports/release-evidence/release-gate-history.json';
 const AUTO_HANDOFF_MOQUI_BASELINE_JSON_FILE = '.kiro/reports/release-evidence/moqui-template-baseline.json';
 const AUTO_HANDOFF_MOQUI_BASELINE_MARKDOWN_FILE = '.kiro/reports/release-evidence/moqui-template-baseline.md';
+const AUTO_HANDOFF_MOQUI_CAPABILITY_COVERAGE_JSON_FILE = '.kiro/reports/release-evidence/moqui-capability-coverage.json';
+const AUTO_HANDOFF_MOQUI_CAPABILITY_COVERAGE_MARKDOWN_FILE = '.kiro/reports/release-evidence/moqui-capability-coverage.md';
+const AUTO_HANDOFF_MOQUI_REMEDIATION_QUEUE_FILE = '.kiro/auto/moqui-remediation.lines';
 
 /**
  * Register auto commands
@@ -1664,6 +1667,22 @@ function registerAutoCommands(program) {
             console.log(chalk.gray(`    Portfolio: ${moquiSummary.portfolio_passed === true ? 'pass' : 'fail'} | avg=${scoreText} | valid-rate=${validRateText}`));
           }
         }
+        if (result.current_overview && result.current_overview.capability_coverage) {
+          const capabilityCoverage = result.current_overview.capability_coverage;
+          const capabilitySummary = capabilityCoverage && capabilityCoverage.summary ? capabilityCoverage.summary : null;
+          console.log(chalk.gray(`  Capability coverage: ${capabilityCoverage.status || 'n/a'}`));
+          if (capabilitySummary) {
+            const coverageText = Number.isFinite(Number(capabilitySummary.coverage_percent))
+              ? `${capabilitySummary.coverage_percent}%`
+              : 'n/a';
+            console.log(
+              chalk.gray(
+                `    Passed: ${capabilitySummary.passed === true ? 'yes' : 'no'} | ` +
+                `coverage=${coverageText} | min=${capabilitySummary.min_required_percent}%`
+              )
+            );
+          }
+        }
         if (result.output_file) {
           console.log(chalk.gray(`  Output: ${result.output_file}`));
         }
@@ -1765,6 +1784,11 @@ function registerAutoCommands(program) {
     .option('--max-undecided-decisions <n>', 'Gate: maximum allowed undecided decisions (optional)', parseInt)
     .option('--require-ontology-validation', 'Gate: require manifest ontology_validation to be present and passed (default: enabled)')
     .option('--no-require-ontology-validation', 'Gate: disable manifest ontology_validation requirement (not recommended)')
+    .option('--require-moqui-baseline', 'Gate: require Moqui baseline portfolio to pass (default: enabled)')
+    .option('--no-require-moqui-baseline', 'Gate: disable Moqui baseline portfolio requirement (not recommended)')
+    .option('--min-capability-coverage <n>', 'Gate: minimum Moqui capability coverage percent (default: 100)', parseFloat)
+    .option('--require-capability-coverage', 'Gate: require capability coverage threshold when capabilities are declared (default: enabled)')
+    .option('--no-require-capability-coverage', 'Gate: disable capability coverage 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) => {
@@ -1804,6 +1828,24 @@ function registerAutoCommands(program) {
               console.log(chalk.gray(`    Baseline report: ${result.moqui_baseline.output.json}`));
             }
           }
+          if (result.moqui_capability_coverage) {
+            console.log(chalk.gray(`  Capability coverage: ${result.moqui_capability_coverage.status || 'unknown'}`));
+            if (result.moqui_capability_coverage.summary) {
+              const coverageSummary = result.moqui_capability_coverage.summary;
+              const coverageText = Number.isFinite(Number(coverageSummary.coverage_percent))
+                ? `${coverageSummary.coverage_percent}%`
+                : 'n/a';
+              console.log(
+                chalk.gray(
+                  `    Passed: ${coverageSummary.passed === true ? 'yes' : 'no'} | ` +
+                  `coverage=${coverageText} | min=${coverageSummary.min_required_percent}%`
+                )
+              );
+            }
+          }
+          if (result.remediation_queue && result.remediation_queue.file) {
+            console.log(chalk.gray(`  Remediation queue: ${toAutoHandoffCliPath(process.cwd(), result.remediation_queue.file)} (${result.remediation_queue.goal_count})`));
+          }
           if (result.output_file) {
             console.log(chalk.gray(`  Report: ${result.output_file}`));
           }
@@ -6911,6 +6953,16 @@ function normalizeAutoHandoffManifest(payload = {}) {
     validationWarnings.push('templates is empty');
   }
 
+  const capabilitiesCollected = collectUniqueIdentifiers(
+    payload.capabilities,
+    ['name', 'capability', 'capability_name', 'id', 'capability.id', 'capability.name'],
+    'capabilities'
+  );
+  validationWarnings.push(...capabilitiesCollected.warnings);
+  if (capabilitiesCollected.values.length === 0) {
+    validationWarnings.push('capabilities is empty; capability coverage gate will be skipped unless capabilities are declared');
+  }
+
   const knownGapCollected = collectKnownGaps(payload.known_gaps);
   validationWarnings.push(...knownGapCollected.warnings);
 
@@ -6932,6 +6984,7 @@ function normalizeAutoHandoffManifest(payload = {}) {
     spec_descriptors: specsCollected.descriptors,
     dependency_batches: dependencyBatches,
     templates: templatesCollected.values,
+    capabilities: capabilitiesCollected.values,
     known_gaps: knownGapCollected.gaps,
     ontology_validation: ontologyValidation,
     next_batch: nextBatch,
@@ -7039,11 +7092,13 @@ async function buildAutoHandoffPlan(projectPath, options = {}) {
       timestamp: handoff.timestamp,
       spec_count: handoff.specs.length,
       template_count: handoff.templates.length,
+      capability_count: Array.isArray(handoff.capabilities) ? handoff.capabilities.length : 0,
       known_gap_count: handoff.known_gaps.length,
       specs: handoff.specs,
       spec_descriptors: handoff.spec_descriptors,
       dependency_batches: handoff.dependency_batches,
       templates: handoff.templates,
+      capabilities: handoff.capabilities,
       known_gaps: handoff.known_gaps,
       ontology_validation: handoff.ontology_validation,
       next_batch: handoff.next_batch
@@ -8923,6 +8978,19 @@ function buildAutoHandoffEvidenceSnapshot(entry = {}) {
     ),
     ontology_business_rule_pass_rate_percent: toNumber(ontologyMetrics.business_rule_pass_rate_percent),
     ontology_decision_resolved_rate_percent: toNumber(ontologyMetrics.decision_resolved_rate_percent),
+    capability_coverage_percent: toNumber(
+      entry &&
+      entry.capability_coverage &&
+      entry.capability_coverage.summary
+        ? entry.capability_coverage.summary.coverage_percent
+        : null
+    ),
+    capability_coverage_passed: Boolean(
+      entry &&
+      entry.capability_coverage &&
+      entry.capability_coverage.summary &&
+      entry.capability_coverage.summary.passed === true
+    ),
     generated_at: normalizeHandoffText(entry.merged_at)
   };
 }
@@ -8985,6 +9053,18 @@ function renderAutoHandoffEvidenceReviewMarkdown(payload = {}) {
   const moquiFailedTemplates = moquiCompare && moquiCompare.failed_templates && typeof moquiCompare.failed_templates === 'object'
     ? moquiCompare.failed_templates
     : {};
+  const capabilityCoverage = currentOverview.capability_coverage && typeof currentOverview.capability_coverage === 'object'
+    ? currentOverview.capability_coverage
+    : {};
+  const capabilitySummary = capabilityCoverage && capabilityCoverage.summary && typeof capabilityCoverage.summary === 'object'
+    ? capabilityCoverage.summary
+    : {};
+  const capabilityCompare = capabilityCoverage && capabilityCoverage.compare && typeof capabilityCoverage.compare === 'object'
+    ? capabilityCoverage.compare
+    : {};
+  const capabilityGaps = Array.isArray(capabilityCoverage && capabilityCoverage.gaps)
+    ? capabilityCoverage.gaps
+    : [];
   const window = payload.window || { requested: 5, actual: 0 };
   const series = Array.isArray(payload.series) ? payload.series : [];
   const riskLayers = payload.risk_layers && typeof payload.risk_layers === 'object'
@@ -8999,7 +9079,11 @@ function renderAutoHandoffEvidenceReviewMarkdown(payload = {}) {
       const failedGoals = formatAutoHandoffRegressionValue(item.failed_goals);
       const successBar = renderAutoHandoffRegressionAsciiBar(item.spec_success_rate_percent, 100, 20);
       const ontologyBar = renderAutoHandoffRegressionAsciiBar(item.ontology_quality_score, 100, 20);
-      return `- ${sessionId} | ${mergedAt} | risk=${riskLevel} | failed=${failedGoals} | success=${successBar} | ontology=${ontologyBar}`;
+      const capabilityBar = renderAutoHandoffRegressionAsciiBar(item.capability_coverage_percent, 100, 20);
+      return (
+        `- ${sessionId} | ${mergedAt} | risk=${riskLevel} | failed=${failedGoals} | ` +
+        `success=${successBar} | ontology=${ontologyBar} | capability=${capabilityBar}`
+      );
     })
     : ['- None'];
   const riskLayerLines = ['low', 'medium', 'high', 'unknown'].map(level => {
@@ -9062,6 +9146,21 @@ function renderAutoHandoffEvidenceReviewMarkdown(payload = {}) {
     `- Recovered templates: ${Array.isArray(moquiFailedTemplates.recovered) && moquiFailedTemplates.recovered.length > 0 ? moquiFailedTemplates.recovered.join(', ') : 'none'}`,
     `- Baseline JSON: ${formatAutoHandoffRegressionValue(moquiBaseline.output && moquiBaseline.output.json)}`,
     '',
+    '## Current Capability Coverage',
+    '',
+    `- Status: ${formatAutoHandoffRegressionValue(capabilityCoverage.status)}`,
+    `- Passed: ${capabilitySummary.passed === true ? 'yes' : (capabilitySummary.passed === false ? 'no' : 'n/a')}`,
+    `- Coverage: ${formatAutoHandoffRegressionValue(capabilitySummary.coverage_percent)}%`,
+    `- Min required: ${formatAutoHandoffRegressionValue(capabilitySummary.min_required_percent)}%`,
+    `- Covered capabilities: ${formatAutoHandoffRegressionValue(capabilitySummary.covered_capabilities)}`,
+    `- Uncovered capabilities: ${formatAutoHandoffRegressionValue(capabilitySummary.uncovered_capabilities)}`,
+    `- Delta coverage: ${formatAutoHandoffRegressionValue(capabilityCompare.delta_coverage_percent)}%`,
+    `- Delta covered capabilities: ${formatAutoHandoffRegressionValue(capabilityCompare.delta_covered_capabilities)}`,
+    `- Newly covered: ${Array.isArray(capabilityCompare.newly_covered) && capabilityCompare.newly_covered.length > 0 ? capabilityCompare.newly_covered.join(', ') : 'none'}`,
+    `- Newly uncovered: ${Array.isArray(capabilityCompare.newly_uncovered) && capabilityCompare.newly_uncovered.length > 0 ? capabilityCompare.newly_uncovered.join(', ') : 'none'}`,
+    `- Capability gaps: ${capabilityGaps.length > 0 ? capabilityGaps.join(', ') : 'none'}`,
+    `- Coverage JSON: ${formatAutoHandoffRegressionValue(capabilityCoverage.output && capabilityCoverage.output.json)}`,
+    '',
     '## Trend Series',
     '',
     ...trendSeriesLines,
@@ -9168,6 +9267,18 @@ function renderAutoHandoffReleaseNotesDraft(payload = {}, context = {}) {
   const moquiFailedTemplates = moquiCompare && moquiCompare.failed_templates && typeof moquiCompare.failed_templates === 'object'
     ? moquiCompare.failed_templates
     : {};
+  const capabilityCoverage = currentOverview.capability_coverage && typeof currentOverview.capability_coverage === 'object'
+    ? currentOverview.capability_coverage
+    : {};
+  const capabilitySummary = capabilityCoverage && capabilityCoverage.summary && typeof capabilityCoverage.summary === 'object'
+    ? capabilityCoverage.summary
+    : {};
+  const capabilityCompare = capabilityCoverage && capabilityCoverage.compare && typeof capabilityCoverage.compare === 'object'
+    ? capabilityCoverage.compare
+    : {};
+  const capabilityGaps = Array.isArray(capabilityCoverage && capabilityCoverage.gaps)
+    ? capabilityCoverage.gaps
+    : [];
   const riskLayers = payload.risk_layers && typeof payload.risk_layers === 'object'
     ? payload.risk_layers
     : {};
@@ -9219,6 +9330,13 @@ function renderAutoHandoffReleaseNotesDraft(payload = {}, context = {}) {
     `- Moqui baseline avg score delta: ${formatAutoHandoffRegressionValue(moquiDeltas.avg_score)}`,
     `- Moqui baseline valid-rate delta: ${formatAutoHandoffRegressionValue(moquiDeltas.valid_rate_percent)}%`,
     `- Moqui newly failed templates: ${Array.isArray(moquiFailedTemplates.newly_failed) && moquiFailedTemplates.newly_failed.length > 0 ? moquiFailedTemplates.newly_failed.join(', ') : 'none'}`,
+    `- Capability coverage status: ${formatAutoHandoffRegressionValue(capabilityCoverage.status)}`,
+    `- Capability coverage passed: ${capabilitySummary.passed === true ? 'yes' : (capabilitySummary.passed === false ? 'no' : 'n/a')}`,
+    `- Capability coverage: ${formatAutoHandoffRegressionValue(capabilitySummary.coverage_percent)}%`,
+    `- Capability min required: ${formatAutoHandoffRegressionValue(capabilitySummary.min_required_percent)}%`,
+    `- Capability coverage delta: ${formatAutoHandoffRegressionValue(capabilityCompare.delta_coverage_percent)}%`,
+    `- Capability newly uncovered: ${Array.isArray(capabilityCompare.newly_uncovered) && capabilityCompare.newly_uncovered.length > 0 ? capabilityCompare.newly_uncovered.join(', ') : 'none'}`,
+    `- Capability gaps: ${capabilityGaps.length > 0 ? capabilityGaps.join(', ') : 'none'}`,
     '',
     '## Status Breakdown',
     '',
@@ -9239,6 +9357,8 @@ function renderAutoHandoffReleaseNotesDraft(payload = {}, context = {}) {
     `- Release evidence JSON: ${formatAutoHandoffRegressionValue(payload.evidence_file)}`,
     `- Moqui baseline JSON: ${formatAutoHandoffRegressionValue(moquiBaseline.output && moquiBaseline.output.json)}`,
     `- Moqui baseline markdown: ${formatAutoHandoffRegressionValue(moquiBaseline.output && moquiBaseline.output.markdown)}`,
+    `- Capability coverage JSON: ${formatAutoHandoffRegressionValue(capabilityCoverage.output && capabilityCoverage.output.json)}`,
+    `- Capability coverage markdown: ${formatAutoHandoffRegressionValue(capabilityCoverage.output && capabilityCoverage.output.markdown)}`,
     '',
     '## Recommendations'
   ];
@@ -9454,6 +9574,17 @@ function normalizeHandoffMinOntologyScore(scoreCandidate) {
   return Number(parsed.toFixed(2));
 }
 
+function normalizeHandoffMinCapabilityCoverage(coverageCandidate) {
+  if (coverageCandidate === undefined || coverageCandidate === null) {
+    return 100;
+  }
+  const parsed = Number(coverageCandidate);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 100) {
+    throw new Error('--min-capability-coverage must be a number between 0 and 100.');
+  }
+  return Number(parsed.toFixed(2));
+}
+
 function normalizeHandoffOptionalNonNegativeInteger(valueCandidate, optionName) {
   if (valueCandidate === undefined || valueCandidate === null || valueCandidate === '') {
     return null;
@@ -9481,6 +9612,7 @@ function buildAutoHandoffRunPolicy(options = {}) {
     min_spec_success_rate: normalizeHandoffMinSpecSuccessRate(options.minSpecSuccessRate),
     max_risk_level: normalizeHandoffRiskLevel(options.maxRiskLevel),
     min_ontology_score: normalizeHandoffMinOntologyScore(options.minOntologyScore),
+    min_capability_coverage_percent: normalizeHandoffMinCapabilityCoverage(options.minCapabilityCoverage),
     max_unmapped_rules: normalizeHandoffOptionalNonNegativeInteger(
       options.maxUnmappedRules,
       '--max-unmapped-rules'
@@ -9490,6 +9622,8 @@ function buildAutoHandoffRunPolicy(options = {}) {
       '--max-undecided-decisions'
     ),
     require_ontology_validation: options.requireOntologyValidation !== false,
+    require_moqui_baseline: options.requireMoquiBaseline !== false,
+    require_capability_coverage: options.requireCapabilityCoverage !== false,
     dependency_batching: options.dependencyBatching !== false,
     release_evidence_window: normalizeHandoffReleaseEvidenceWindow(options.releaseEvidenceWindow)
   };
@@ -9793,6 +9927,84 @@ function evaluateAutoHandoffOntologyGateReasons(policy = {}, ontology = {}) {
   return reasons;
 }
 
+function evaluateAutoHandoffMoquiBaselineGateReasons(policy = {}, moquiBaseline = null) {
+  const reasons = [];
+  if (policy.require_moqui_baseline !== true) {
+    return reasons;
+  }
+
+  const baseline = moquiBaseline && typeof moquiBaseline === 'object'
+    ? moquiBaseline
+    : null;
+  const summary = baseline && baseline.summary && typeof baseline.summary === 'object'
+    ? baseline.summary
+    : {};
+  const status = `${baseline && baseline.status ? baseline.status : 'missing'}`.trim().toLowerCase();
+  if (!baseline || baseline.generated !== true) {
+    const reason = baseline && baseline.reason ? baseline.reason : 'moqui baseline snapshot missing';
+    reasons.push(`moqui baseline unavailable: ${reason}`);
+    return reasons;
+  }
+  if (status === 'error') {
+    reasons.push(`moqui baseline errored: ${baseline.error || 'unknown error'}`);
+    return reasons;
+  }
+  if (summary.portfolio_passed !== true) {
+    const avgScore = Number(summary.avg_score);
+    const validRate = Number(summary.valid_rate_percent);
+    reasons.push(
+      `moqui baseline portfolio not passed (avg_score=${Number.isFinite(avgScore) ? avgScore : 'n/a'}, ` +
+      `valid_rate=${Number.isFinite(validRate) ? `${validRate}%` : 'n/a'})`
+    );
+  }
+  return reasons;
+}
+
+function evaluateAutoHandoffCapabilityCoverageGateReasons(policy = {}, capabilityCoverage = null) {
+  const reasons = [];
+  if (policy.require_capability_coverage !== true) {
+    return reasons;
+  }
+
+  const coverage = capabilityCoverage && typeof capabilityCoverage === 'object'
+    ? capabilityCoverage
+    : null;
+  if (!coverage) {
+    reasons.push('capability coverage snapshot missing');
+    return reasons;
+  }
+  if (coverage.status === 'error') {
+    reasons.push(`capability coverage errored: ${coverage.error || 'unknown error'}`);
+    return reasons;
+  }
+  if (coverage.status === 'skipped') {
+    const totalCapabilities = Number(
+      coverage &&
+      coverage.summary &&
+      coverage.summary.total_capabilities !== undefined
+        ? coverage.summary.total_capabilities
+        : 0
+    );
+    if (Number.isFinite(totalCapabilities) && totalCapabilities <= 0) {
+      return reasons;
+    }
+    reasons.push(`capability coverage skipped: ${coverage.reason || 'unknown reason'}`);
+    return reasons;
+  }
+
+  const summary = coverage.summary && typeof coverage.summary === 'object'
+    ? coverage.summary
+    : {};
+  const coveragePercent = Number(summary.coverage_percent);
+  const minCoverage = Number(policy.min_capability_coverage_percent);
+  if (!Number.isFinite(coveragePercent)) {
+    reasons.push('capability_coverage_percent unavailable');
+  } else if (Number.isFinite(minCoverage) && coveragePercent < minCoverage) {
+    reasons.push(`capability_coverage_percent ${coveragePercent} < required ${minCoverage}`);
+  }
+  return reasons;
+}
+
 function collectHandoffBlockers(resultItem) {
   const blockers = [];
   if (!resultItem) {
@@ -9877,6 +10089,12 @@ function evaluateAutoHandoffRunGates(context = {}) {
     present: false,
     passed: false
   };
+  const moquiBaseline = context.moquiBaseline && typeof context.moquiBaseline === 'object'
+    ? context.moquiBaseline
+    : null;
+  const capabilityCoverage = context.capabilityCoverage && typeof context.capabilityCoverage === 'object'
+    ? context.capabilityCoverage
+    : null;
   const kpi = context.programKpi || {
     risk_level: 'high'
   };
@@ -9902,6 +10120,8 @@ function evaluateAutoHandoffRunGates(context = {}) {
   }
 
   reasons.push(...evaluateAutoHandoffOntologyGateReasons(policy, ontology));
+  reasons.push(...evaluateAutoHandoffMoquiBaselineGateReasons(policy, moquiBaseline));
+  reasons.push(...evaluateAutoHandoffCapabilityCoverageGateReasons(policy, capabilityCoverage));
 
   return {
     passed: reasons.length === 0,
@@ -9935,6 +10155,18 @@ function evaluateAutoHandoffRunGates(context = {}) {
         Number(ontology && ontology.metrics ? ontology.metrics.decision_resolved_rate_percent : null)
       )
         ? Number(ontology.metrics.decision_resolved_rate_percent)
+        : null,
+      moqui_baseline_status: normalizeHandoffText(moquiBaseline && moquiBaseline.status),
+      moqui_baseline_portfolio_passed: Boolean(
+        moquiBaseline &&
+        moquiBaseline.summary &&
+        moquiBaseline.summary.portfolio_passed === true
+      ),
+      capability_coverage_status: normalizeHandoffText(capabilityCoverage && capabilityCoverage.status),
+      capability_coverage_percent: Number.isFinite(
+        Number(capabilityCoverage && capabilityCoverage.summary ? capabilityCoverage.summary.coverage_percent : null)
+      )
+        ? Number(capabilityCoverage.summary.coverage_percent)
         : null
     },
     reasons
@@ -10024,6 +10256,14 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
     push('kse auto governance stats --days 14 --json');
   }
 
+  if (result && result.remediation_queue && result.remediation_queue.file) {
+    push(
+      `kse auto close-loop-batch ${quoteCliArg(
+        toAutoHandoffCliPath(projectPath, result.remediation_queue.file)
+      )} --format lines --json`
+    );
+  }
+
   const moquiBaseline = result && result.moqui_baseline && typeof result.moqui_baseline === 'object'
     ? result.moqui_baseline
     : null;
@@ -10043,6 +10283,20 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
     );
   }
 
+  const capabilityCoverage = result && result.moqui_capability_coverage && typeof result.moqui_capability_coverage === 'object'
+    ? result.moqui_capability_coverage
+    : null;
+  const capabilitySummary = capabilityCoverage && capabilityCoverage.summary && typeof capabilityCoverage.summary === 'object'
+    ? capabilityCoverage.summary
+    : null;
+  if (capabilityCoverage && capabilityCoverage.status === 'error') {
+    push('declare manifest capabilities and rerun `kse auto handoff run` to rebuild capability coverage evidence');
+  } else if (capabilitySummary && capabilitySummary.passed === false) {
+    push('complete uncovered moqui capabilities and rerun `kse auto handoff run --json`');
+  } else if (capabilityCoverage && capabilityCoverage.status === 'skipped') {
+    push('declare `capabilities` in handoff manifest to enable machine-checkable moqui capability coverage');
+  }
+
   return recommendations;
 }
 
@@ -10145,6 +10399,18 @@ function buildAutoHandoffReleaseEvidenceEntry(projectPath, result, reportFile =
   const moquiFailedTemplates = moquiCompare && moquiCompare.failed_templates && typeof moquiCompare.failed_templates === 'object'
     ? moquiCompare.failed_templates
     : {};
+  const capabilityCoverage = result && result.moqui_capability_coverage && typeof result.moqui_capability_coverage === 'object'
+    ? result.moqui_capability_coverage
+    : {};
+  const capabilitySummary = capabilityCoverage && capabilityCoverage.summary && typeof capabilityCoverage.summary === 'object'
+    ? capabilityCoverage.summary
+    : {};
+  const capabilityCompare = capabilityCoverage && capabilityCoverage.compare && typeof capabilityCoverage.compare === 'object'
+    ? capabilityCoverage.compare
+    : {};
+  const capabilityGaps = Array.isArray(capabilityCoverage && capabilityCoverage.gaps)
+    ? capabilityCoverage.gaps
+    : [];
   const batchSummary = result && result.batch_summary && typeof result.batch_summary === 'object'
     ? result.batch_summary
     : {};
@@ -10239,6 +10505,34 @@ function buildAutoHandoffReleaseEvidenceEntry(projectPath, result, reportFile =
         markdown: normalizeHandoffText(moquiBaseline && moquiBaseline.output ? moquiBaseline.output.markdown : null)
       }
     },
+    capability_coverage: {
+      status: normalizeHandoffText(capabilityCoverage.status),
+      generated: capabilityCoverage.generated === true,
+      reason: normalizeHandoffText(capabilityCoverage.reason),
+      error: normalizeHandoffText(capabilityCoverage.error),
+      summary: {
+        total_capabilities: toNumber(capabilitySummary.total_capabilities),
+        covered_capabilities: toNumber(capabilitySummary.covered_capabilities),
+        uncovered_capabilities: toNumber(capabilitySummary.uncovered_capabilities),
+        coverage_percent: toNumber(capabilitySummary.coverage_percent),
+        min_required_percent: toNumber(capabilitySummary.min_required_percent),
+        passed: capabilitySummary.passed === true
+      },
+      compare: Object.keys(capabilityCompare).length === 0
+        ? null
+        : {
+          previous_generated_at: normalizeHandoffText(capabilityCompare.previous_generated_at),
+          delta_coverage_percent: toNumber(capabilityCompare.delta_coverage_percent),
+          delta_covered_capabilities: toNumber(capabilityCompare.delta_covered_capabilities),
+          newly_covered: Array.isArray(capabilityCompare.newly_covered) ? capabilityCompare.newly_covered : [],
+          newly_uncovered: Array.isArray(capabilityCompare.newly_uncovered) ? capabilityCompare.newly_uncovered : []
+        },
+      gaps: capabilityGaps,
+      output: {
+        json: normalizeHandoffText(capabilityCoverage && capabilityCoverage.output ? capabilityCoverage.output.json : null),
+        markdown: normalizeHandoffText(capabilityCoverage && capabilityCoverage.output ? capabilityCoverage.output.markdown : null)
+      }
+    },
     batch_summary: {
       status: normalizeHandoffText(batchSummary.status),
       total_goals: toNumber(batchSummary.total_goals),
@@ -10478,6 +10772,8 @@ async function buildAutoHandoffMoquiBaselineSnapshot(projectPath) {
         previous_template_root: compare.previous_template_root || null,
         deltas: compare.deltas || null,
         failed_templates: {
+          previous: Array.isArray(failedTemplates.previous) ? failedTemplates.previous : [],
+          current: Array.isArray(failedTemplates.current) ? failedTemplates.current : [],
           newly_failed: Array.isArray(failedTemplates.newly_failed) ? failedTemplates.newly_failed : [],
           recovered: Array.isArray(failedTemplates.recovered) ? failedTemplates.recovered : []
         }
@@ -10491,6 +10787,377 @@ async function buildAutoHandoffMoquiBaselineSnapshot(projectPath) {
   };
 }
 
+function normalizeMoquiCapabilityToken(value) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  const normalized = `${value}`
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+  return normalized.length > 0 ? normalized : null;
+}
+
+function tokenizeMoquiCapability(value) {
+  const normalized = normalizeMoquiCapabilityToken(value);
+  if (!normalized) {
+    return [];
+  }
+  return normalized.split('-').map(item => item.trim()).filter(Boolean);
+}
+
+function moquiCapabilityMatch(expected, provided) {
+  const left = normalizeMoquiCapabilityToken(expected);
+  const right = normalizeMoquiCapabilityToken(provided);
+  if (!left || !right) {
+    return false;
+  }
+  if (left === right) {
+    return true;
+  }
+  if ((left.length >= 8 && left.includes(right)) || (right.length >= 8 && right.includes(left))) {
+    return true;
+  }
+  const leftTokens = tokenizeMoquiCapability(left);
+  const rightTokens = tokenizeMoquiCapability(right);
+  if (leftTokens.length === 0 || rightTokens.length === 0) {
+    return false;
+  }
+  const rightSet = new Set(rightTokens);
+  const overlap = leftTokens.filter(item => rightSet.has(item)).length;
+  return overlap >= 2;
+}
+
+function renderMoquiCapabilityCoverageMarkdown(report = {}) {
+  const summary = report.summary && typeof report.summary === 'object'
+    ? report.summary
+    : {};
+  const coverage = Array.isArray(report.coverage) ? report.coverage : [];
+  const compare = report.compare && typeof report.compare === 'object' ? report.compare : null;
+  const lines = [
+    '# Moqui Capability Coverage Report',
+    '',
+    `- Generated at: ${report.generated_at || 'n/a'}`,
+    `- Expected capabilities: ${summary.total_capabilities !== undefined ? summary.total_capabilities : 'n/a'}`,
+    `- Covered capabilities: ${summary.covered_capabilities !== undefined ? summary.covered_capabilities : 'n/a'}`,
+    `- Uncovered capabilities: ${summary.uncovered_capabilities !== undefined ? summary.uncovered_capabilities : 'n/a'}`,
+    `- Coverage: ${summary.coverage_percent !== undefined && summary.coverage_percent !== null ? `${summary.coverage_percent}%` : 'n/a'}`,
+    `- Min required: ${summary.min_required_percent !== undefined && summary.min_required_percent !== null ? `${summary.min_required_percent}%` : 'n/a'}`,
+    `- Passed: ${summary.passed === true ? 'yes' : 'no'}`,
+    '',
+    '## Capability Matrix',
+    '',
+    '| Capability | Covered | Matched Templates |',
+    '| --- | --- | --- |'
+  ];
+
+  for (const item of coverage) {
+    const matchedTemplates = Array.isArray(item.matched_templates) && item.matched_templates.length > 0
+      ? item.matched_templates.join(', ')
+      : 'none';
+    lines.push(`| ${item.capability} | ${item.covered ? 'yes' : 'no'} | ${matchedTemplates} |`);
+  }
+
+  if (compare) {
+    lines.push('');
+    lines.push('## Trend vs Previous');
+    lines.push('');
+    lines.push(`- Previous generated at: ${compare.previous_generated_at || 'n/a'}`);
+    lines.push(`- Delta coverage: ${compare.delta_coverage_percent !== null && compare.delta_coverage_percent !== undefined ? `${compare.delta_coverage_percent}%` : 'n/a'}`);
+    lines.push(`- Delta covered capabilities: ${compare.delta_covered_capabilities !== null && compare.delta_covered_capabilities !== undefined ? compare.delta_covered_capabilities : 'n/a'}`);
+    lines.push(`- Newly covered: ${Array.isArray(compare.newly_covered) && compare.newly_covered.length > 0 ? compare.newly_covered.join(', ') : 'none'}`);
+    lines.push(`- Newly uncovered: ${Array.isArray(compare.newly_uncovered) && compare.newly_uncovered.length > 0 ? compare.newly_uncovered.join(', ') : 'none'}`);
+  }
+
+  return `${lines.join('\n')}\n`;
+}
+
+function buildCapabilityCoverageComparison(currentPayload, previousPayload) {
+  const currentSummary = currentPayload && currentPayload.summary ? currentPayload.summary : {};
+  const previousSummary = previousPayload && previousPayload.summary ? previousPayload.summary : {};
+  const currentCoverage = Array.isArray(currentPayload && currentPayload.coverage) ? currentPayload.coverage : [];
+  const previousCoverage = Array.isArray(previousPayload && previousPayload.coverage) ? previousPayload.coverage : [];
+  const currentCovered = new Set(
+    currentCoverage.filter(item => item && item.covered === true).map(item => item.capability)
+  );
+  const previousCovered = new Set(
+    previousCoverage.filter(item => item && item.covered === true).map(item => item.capability)
+  );
+  const newlyCovered = Array.from(currentCovered).filter(item => !previousCovered.has(item)).sort();
+  const newlyUncovered = Array.from(previousCovered).filter(item => !currentCovered.has(item)).sort();
+  const toDelta = (current, previous) => {
+    if (!Number.isFinite(Number(current)) || !Number.isFinite(Number(previous))) {
+      return null;
+    }
+    return Number((Number(current) - Number(previous)).toFixed(2));
+  };
+  return {
+    previous_generated_at: previousPayload && previousPayload.generated_at ? previousPayload.generated_at : null,
+    delta_coverage_percent: toDelta(currentSummary.coverage_percent, previousSummary.coverage_percent),
+    delta_covered_capabilities: toDelta(currentSummary.covered_capabilities, previousSummary.covered_capabilities),
+    newly_covered: newlyCovered,
+    newly_uncovered: newlyUncovered
+  };
+}
+
+async function loadLatestMoquiCapabilityCoverageReport(projectPath) {
+  const reportPath = path.join(projectPath, AUTO_HANDOFF_MOQUI_CAPABILITY_COVERAGE_JSON_FILE);
+  if (!(await fs.pathExists(reportPath))) {
+    return null;
+  }
+  try {
+    const payload = await fs.readJson(reportPath);
+    return payload && typeof payload === 'object' ? payload : null;
+  } catch (_error) {
+    return null;
+  }
+}
+
+async function buildAutoHandoffCapabilityCoverageSnapshot(projectPath, handoff = null, policy = {}) {
+  const expectedRaw = Array.isArray(handoff && handoff.capabilities)
+    ? handoff.capabilities
+    : [];
+  const expected = Array.from(
+    new Set(
+      expectedRaw
+        .map(item => normalizeMoquiCapabilityToken(item))
+        .filter(Boolean)
+    )
+  );
+  if (expected.length === 0) {
+    return {
+      status: 'skipped',
+      generated: false,
+      reason: 'manifest capabilities not declared',
+      summary: {
+        total_capabilities: 0,
+        covered_capabilities: 0,
+        uncovered_capabilities: 0,
+        coverage_percent: null,
+        min_required_percent: Number(policy.min_capability_coverage_percent),
+        passed: true
+      },
+      coverage: [],
+      gaps: []
+    };
+  }
+
+  const templateRoot = path.join(projectPath, '.kiro', 'templates', 'scene-packages');
+  if (!(await fs.pathExists(templateRoot))) {
+    return {
+      status: 'skipped',
+      generated: false,
+      reason: `template library not found: ${toAutoHandoffCliPath(projectPath, templateRoot)}`,
+      summary: {
+        total_capabilities: expected.length,
+        covered_capabilities: 0,
+        uncovered_capabilities: expected.length,
+        coverage_percent: 0,
+        min_required_percent: Number(policy.min_capability_coverage_percent),
+        passed: false
+      },
+      coverage: expected.map(item => ({ capability: item, covered: false, matched_templates: [], matched_provides: [] })),
+      gaps: expected
+    };
+  }
+
+  const templateEntries = await fs.readdir(templateRoot);
+  const templates = [];
+  for (const entry of templateEntries) {
+    const templateDir = path.join(templateRoot, entry);
+    let stat = null;
+    try {
+      stat = await fs.stat(templateDir);
+    } catch (_error) {
+      stat = null;
+    }
+    if (!stat || !stat.isDirectory()) {
+      continue;
+    }
+    const contractFile = path.join(templateDir, 'scene-package.json');
+    if (!(await fs.pathExists(contractFile))) {
+      continue;
+    }
+    try {
+      const payload = await fs.readJson(contractFile);
+      const providesRaw = [];
+      const contractProvides = payload && payload.contract && payload.contract.capabilities && payload.contract.capabilities.provides;
+      const rootProvides = payload && payload.capabilities && payload.capabilities.provides;
+      if (Array.isArray(contractProvides)) {
+        providesRaw.push(...contractProvides);
+      }
+      if (Array.isArray(rootProvides)) {
+        providesRaw.push(...rootProvides);
+      }
+      const provides = Array.from(
+        new Set(
+          providesRaw
+            .map(item => normalizeMoquiCapabilityToken(item))
+            .filter(Boolean)
+        )
+      );
+      templates.push({
+        template_id: entry,
+        provides
+      });
+    } catch (_error) {
+      // Ignore malformed template package entries.
+    }
+  }
+
+  const coverage = expected.map(capability => {
+    const matchedTemplates = [];
+    const matchedProvides = [];
+    for (const template of templates) {
+      const providedMatched = template.provides.filter(item => moquiCapabilityMatch(capability, item));
+      if (providedMatched.length > 0) {
+        matchedTemplates.push(template.template_id);
+        matchedProvides.push(...providedMatched);
+      }
+    }
+    const uniqueProvides = Array.from(new Set(matchedProvides)).sort();
+    return {
+      capability,
+      covered: matchedTemplates.length > 0,
+      matched_templates: Array.from(new Set(matchedTemplates)).sort(),
+      matched_provides: uniqueProvides
+    };
+  });
+
+  const coveredCount = coverage.filter(item => item.covered).length;
+  const uncovered = coverage.filter(item => !item.covered).map(item => item.capability);
+  const coveragePercent = expected.length > 0
+    ? Number(((coveredCount / expected.length) * 100).toFixed(2))
+    : null;
+  const minRequiredPercent = Number(policy.min_capability_coverage_percent);
+  const passed = Number.isFinite(coveragePercent) && Number.isFinite(minRequiredPercent)
+    ? coveragePercent >= minRequiredPercent
+    : false;
+
+  const payload = {
+    mode: 'moqui-capability-coverage',
+    generated_at: new Date().toISOString(),
+    expected_capabilities: expected,
+    summary: {
+      total_capabilities: expected.length,
+      covered_capabilities: coveredCount,
+      uncovered_capabilities: expected.length - coveredCount,
+      coverage_percent: coveragePercent,
+      min_required_percent: Number.isFinite(minRequiredPercent) ? minRequiredPercent : 100,
+      passed
+    },
+    coverage,
+    gaps: uncovered
+  };
+
+  const previousPayload = await loadLatestMoquiCapabilityCoverageReport(projectPath);
+  if (previousPayload) {
+    payload.compare = buildCapabilityCoverageComparison(payload, previousPayload);
+  }
+
+  const outputJsonPath = path.join(projectPath, AUTO_HANDOFF_MOQUI_CAPABILITY_COVERAGE_JSON_FILE);
+  const outputMarkdownPath = path.join(projectPath, AUTO_HANDOFF_MOQUI_CAPABILITY_COVERAGE_MARKDOWN_FILE);
+  await fs.ensureDir(path.dirname(outputJsonPath));
+  await fs.writeJson(outputJsonPath, payload, { spaces: 2 });
+  await fs.writeFile(outputMarkdownPath, renderMoquiCapabilityCoverageMarkdown(payload), 'utf8');
+
+  return {
+    status: 'evaluated',
+    generated: true,
+    summary: payload.summary,
+    coverage: payload.coverage,
+    gaps: payload.gaps,
+    compare: payload.compare || null,
+    output: {
+      json: toAutoHandoffCliPath(projectPath, outputJsonPath),
+      markdown: toAutoHandoffCliPath(projectPath, outputMarkdownPath)
+    }
+  };
+}
+
+function collectAutoHandoffMoquiRemediationGoals(result) {
+  const goals = [];
+  const seen = new Set();
+  const pushGoal = value => {
+    const text = `${value || ''}`.trim();
+    if (!text || seen.has(text)) {
+      return;
+    }
+    seen.add(text);
+    goals.push(text);
+  };
+
+  const moquiBaseline = result && result.moqui_baseline && typeof result.moqui_baseline === 'object'
+    ? result.moqui_baseline
+    : null;
+  const baselineSummary = moquiBaseline && moquiBaseline.summary && typeof moquiBaseline.summary === 'object'
+    ? moquiBaseline.summary
+    : null;
+  const baselineCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
+    ? moquiBaseline.compare
+    : null;
+  const baselineFailedTemplates = baselineCompare && baselineCompare.failed_templates && typeof baselineCompare.failed_templates === 'object'
+    ? baselineCompare.failed_templates
+    : {};
+
+  if (moquiBaseline && moquiBaseline.status === 'error') {
+    pushGoal('repair moqui baseline generation pipeline and regenerate baseline evidence');
+  } else if (baselineSummary && baselineSummary.portfolio_passed === false) {
+    pushGoal(
+      `raise moqui baseline portfolio score (avg=${baselineSummary.avg_score || 'n/a'}, ` +
+      `valid-rate=${baselineSummary.valid_rate_percent || 'n/a'}%) to pass thresholds`
+    );
+    const targetTemplates = Array.isArray(baselineFailedTemplates.current)
+      ? baselineFailedTemplates.current
+      : [];
+    for (const templateId of targetTemplates) {
+      pushGoal(`remediate moqui template ${templateId} ontology semantics and close baseline gaps`);
+    }
+  }
+
+  const capabilityCoverage = result && result.moqui_capability_coverage && typeof result.moqui_capability_coverage === 'object'
+    ? result.moqui_capability_coverage
+    : null;
+  const capabilitySummary = capabilityCoverage && capabilityCoverage.summary && typeof capabilityCoverage.summary === 'object'
+    ? capabilityCoverage.summary
+    : null;
+  const capabilityGaps = capabilityCoverage && Array.isArray(capabilityCoverage.gaps)
+    ? capabilityCoverage.gaps
+    : [];
+  if (
+    capabilityCoverage &&
+    capabilityCoverage.status === 'evaluated' &&
+    capabilitySummary &&
+    capabilitySummary.passed === false
+  ) {
+    pushGoal(
+      `increase moqui capability coverage to >=${capabilitySummary.min_required_percent}% ` +
+      `(current=${capabilitySummary.coverage_percent || 0}%)`
+    );
+    for (const capability of capabilityGaps) {
+      pushGoal(`implement scene template or ontology mapping for moqui capability ${capability}`);
+    }
+  }
+
+  return goals;
+}
+
+async function maybeWriteAutoHandoffMoquiRemediationQueue(projectPath, result) {
+  const goals = collectAutoHandoffMoquiRemediationGoals(result);
+  if (goals.length === 0) {
+    return null;
+  }
+  const queuePath = path.join(projectPath, AUTO_HANDOFF_MOQUI_REMEDIATION_QUEUE_FILE);
+  await fs.ensureDir(path.dirname(queuePath));
+  await fs.writeFile(queuePath, `${goals.join('\n')}\n`, 'utf8');
+  return {
+    file: queuePath,
+    goal_count: goals.length,
+    goals
+  };
+}
+
 async function runAutoHandoff(projectPath, options = {}) {
   const startedAtMs = Date.now();
   const result = {
@@ -10513,6 +11180,8 @@ async function runAutoHandoff(projectPath, options = {}) {
     spec_status: null,
     ontology_validation: null,
     moqui_baseline: null,
+    moqui_capability_coverage: null,
+    remediation_queue: null,
     gates: null,
     regression: null,
     release_evidence: null,
@@ -10554,6 +11223,85 @@ async function runAutoHandoff(projectPath, options = {}) {
       throw error;
     }
 
+    const baselinePhase = beginAutoHandoffRunPhase(result, 'moqui-baseline', 'Moqui template baseline scorecard');
+    try {
+      result.moqui_baseline = await buildAutoHandoffMoquiBaselineSnapshot(projectPath);
+      completeAutoHandoffRunPhase(
+        baselinePhase,
+        buildAutoHandoffMoquiBaselinePhaseDetails(result.moqui_baseline)
+      );
+      if (result.moqui_baseline && result.moqui_baseline.status === 'error') {
+        result.warnings.push(`moqui baseline generation failed: ${result.moqui_baseline.error || 'unknown error'}`);
+      }
+      const moquiBaselineGateReasons = evaluateAutoHandoffMoquiBaselineGateReasons(
+        result.policy,
+        result.moqui_baseline
+      );
+      if (moquiBaselineGateReasons.length > 0) {
+        throw new Error(`handoff moqui baseline gate failed: ${moquiBaselineGateReasons.join('; ')}`);
+      }
+    } catch (baselineError) {
+      failAutoHandoffRunPhase(baselinePhase, baselineError);
+      if (!result.moqui_baseline) {
+        result.moqui_baseline = {
+          status: 'error',
+          generated: false,
+          error: baselineError && baselineError.message ? baselineError.message : `${baselineError}`
+        };
+      }
+      throw baselineError;
+    }
+
+    const capabilityCoveragePhase = beginAutoHandoffRunPhase(
+      result,
+      'moqui-capability-coverage',
+      'Moqui capability coverage matrix'
+    );
+    try {
+      result.moqui_capability_coverage = await buildAutoHandoffCapabilityCoverageSnapshot(
+        projectPath,
+        result.handoff,
+        result.policy
+      );
+      completeAutoHandoffRunPhase(capabilityCoveragePhase, {
+        status: result.moqui_capability_coverage.status || 'unknown',
+        coverage_percent: Number.isFinite(
+          Number(
+            result.moqui_capability_coverage &&
+            result.moqui_capability_coverage.summary
+              ? result.moqui_capability_coverage.summary.coverage_percent
+              : null
+          )
+        )
+          ? Number(result.moqui_capability_coverage.summary.coverage_percent)
+          : null,
+        passed: Boolean(
+          result.moqui_capability_coverage &&
+          result.moqui_capability_coverage.summary &&
+          result.moqui_capability_coverage.summary.passed === true
+        )
+      });
+      const capabilityCoverageGateReasons = evaluateAutoHandoffCapabilityCoverageGateReasons(
+        result.policy,
+        result.moqui_capability_coverage
+      );
+      if (capabilityCoverageGateReasons.length > 0) {
+        throw new Error(`handoff capability coverage gate failed: ${capabilityCoverageGateReasons.join('; ')}`);
+      }
+    } catch (capabilityCoverageError) {
+      failAutoHandoffRunPhase(capabilityCoveragePhase, capabilityCoverageError);
+      if (!result.moqui_capability_coverage) {
+        result.moqui_capability_coverage = {
+          status: 'error',
+          generated: false,
+          error: capabilityCoverageError && capabilityCoverageError.message
+            ? capabilityCoverageError.message
+            : `${capabilityCoverageError}`
+        };
+      }
+      throw capabilityCoverageError;
+    }
+
     const queuePhase = beginAutoHandoffRunPhase(result, 'queue', 'Queue generation');
     let queue = null;
     try {
@@ -10614,30 +11362,13 @@ async function runAutoHandoff(projectPath, options = {}) {
         null,
         continuationBaselineSummary
       );
-      const baselinePhase = beginAutoHandoffRunPhase(result, 'moqui-baseline', 'Moqui template baseline scorecard');
-      try {
-        result.moqui_baseline = await buildAutoHandoffMoquiBaselineSnapshot(projectPath);
-        completeAutoHandoffRunPhase(
-          baselinePhase,
-          buildAutoHandoffMoquiBaselinePhaseDetails(result.moqui_baseline)
-        );
-        if (result.moqui_baseline && result.moqui_baseline.status === 'error') {
-          result.warnings.push(`moqui baseline generation failed: ${result.moqui_baseline.error || 'unknown error'}`);
-        }
-      } catch (baselineError) {
-        failAutoHandoffRunPhase(baselinePhase, baselineError);
-        result.moqui_baseline = {
-          status: 'error',
-          generated: false,
-          error: baselineError && baselineError.message ? baselineError.message : `${baselineError}`
-        };
-        result.warnings.push(`moqui baseline generation failed: ${result.moqui_baseline.error}`);
-      }
       result.gates = evaluateAutoHandoffRunGates({
         policy: result.policy,
         dryRun: true,
         specStatus: result.spec_status,
         ontology: result.ontology_validation,
+        moquiBaseline: result.moqui_baseline,
+        capabilityCoverage: result.moqui_capability_coverage,
         programKpi: {
           risk_level: 'low'
         }
@@ -10693,31 +11424,13 @@ async function runAutoHandoff(projectPath, options = {}) {
       throw error;
     }
 
-    const baselinePhase = beginAutoHandoffRunPhase(result, 'moqui-baseline', 'Moqui template baseline scorecard');
-    try {
-      result.moqui_baseline = await buildAutoHandoffMoquiBaselineSnapshot(projectPath);
-      completeAutoHandoffRunPhase(
-        baselinePhase,
-        buildAutoHandoffMoquiBaselinePhaseDetails(result.moqui_baseline)
-      );
-      if (result.moqui_baseline && result.moqui_baseline.status === 'error') {
-        result.warnings.push(`moqui baseline generation failed: ${result.moqui_baseline.error || 'unknown error'}`);
-      }
-    } catch (baselineError) {
-      failAutoHandoffRunPhase(baselinePhase, baselineError);
-      result.moqui_baseline = {
-        status: 'error',
-        generated: false,
-        error: baselineError && baselineError.message ? baselineError.message : `${baselineError}`
-      };
-      result.warnings.push(`moqui baseline generation failed: ${result.moqui_baseline.error}`);
-    }
-
     result.gates = evaluateAutoHandoffRunGates({
       policy: result.policy,
       dryRun: false,
       specStatus: result.spec_status,
       ontology: result.ontology_validation,
+      moquiBaseline: result.moqui_baseline,
+      capabilityCoverage: result.moqui_capability_coverage,
       programKpi: buildProgramKpiSnapshot(result.batch_summary || {})
     });
     if (!result.gates.passed) {
@@ -10731,6 +11444,7 @@ async function runAutoHandoff(projectPath, options = {}) {
     result.completed_at = new Date().toISOString();
     result.elapsed_ms = Math.max(0, Date.now() - startedAtMs);
     result.regression = await buildAutoHandoffRegression(projectPath, result);
+    result.remediation_queue = await maybeWriteAutoHandoffMoquiRemediationQueue(projectPath, result);
     result.recommendations = buildAutoHandoffRunRecommendations(projectPath, result);
     await writeAutoHandoffRunReport(projectPath, result, options.out);
     if (result.dry_run) {

package/package.json

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