kiro-spec-engine 1.47.30 → 1.47.32

package/docs/command-reference.md

@@ -769,8 +769,9 @@ Dual-track handoff integration:
   - 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 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 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 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.
@@ -781,11 +782,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/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/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`, `Trend Series`, and `Risk Layer View`.
+  - Markdown output includes `Current Gate`, `Current Ontology`, `Current Regression`, `Current Moqui Baseline`, `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`).
@@ -893,14 +894,17 @@ kse scene package-ontology-backfill-batch --from-331 --dry-run --out-report .kir
 ### Moqui Template Baseline Scorecard
 
 ```bash
-# Score Moqui/ERP templates in the local template library (default filter: moqui|erp)
+# Preferred CLI entry: score Moqui/ERP templates in the local template library (default filter: moqui|erp)
+kse scene moqui-baseline --json
+
+# Script alias (same behavior)
 npm run report:moqui-baseline
 
 # Score all scene templates instead of Moqui/ERP subset
-node scripts/moqui-template-baseline-report.js --include-all --json
+kse scene moqui-baseline --include-all --json
 
 # Customize score thresholds and output paths
-node scripts/moqui-template-baseline-report.js \
+kse scene moqui-baseline \
   --min-score 75 \
   --min-valid-rate 100 \
   --out .kiro/reports/moqui-template-baseline.json \
@@ -908,7 +912,7 @@ node scripts/moqui-template-baseline-report.js \
   --json
 
 # Compare with a previous baseline and fail CI on portfolio gate fail
-node scripts/moqui-template-baseline-report.js \
+kse scene moqui-baseline \
   --compare-with .kiro/reports/release-evidence/moqui-template-baseline-prev.json \
   --fail-on-portfolio-fail \
   --json

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

@@ -13,6 +13,7 @@ This playbook defines a generic (project-agnostic) path to absorb Moqui capabili
 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 scene package-publish-batch`:
   - ontology validation required by default
   - batch ontology gate defaults:
@@ -27,10 +28,10 @@ Emergency bypass exists but is not recommended:
 
 ```bash
 # 0) Generate template baseline scoreboard (Moqui/ERP templates by default)
-node scripts/moqui-template-baseline-report.js --json
+kse scene moqui-baseline --json
 
 # 0.1) CI/release mode: compare against previous baseline and enforce portfolio gate
-node scripts/moqui-template-baseline-report.js \
+kse scene moqui-baseline \
   --compare-with .kiro/reports/release-evidence/moqui-template-baseline-prev.json \
   --fail-on-portfolio-fail \
   --json
@@ -62,6 +63,8 @@ Required artifacts for each intake batch:
 
 - `.kiro/reports/moqui-template-baseline.json`
 - `.kiro/reports/moqui-template-baseline.md`
+- `.kiro/reports/release-evidence/moqui-template-baseline.json`
+- `.kiro/reports/release-evidence/moqui-template-baseline.md`
 - `.kiro/reports/handoff-runs/<session>.json`
 - `.kiro/reports/scene-package-ontology-batch.json`
 - `.kiro/templates/scene-packages/registry.json`

package/lib/commands/auto.js

@@ -9,6 +9,7 @@ const { analyzeGoalSemantics } = require('../auto/semantic-decomposer');
 const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
+const { spawnSync } = require('child_process');
 
 const AUTO_ARCHIVE_SCHEMA_VERSION = '1.0';
 const AUTO_ARCHIVE_SCHEMA_SUPPORTED_VERSIONS = new Set([AUTO_ARCHIVE_SCHEMA_VERSION]);
@@ -18,6 +19,8 @@ const AUTO_HANDOFF_RELEASE_EVIDENCE_FILE = '.kiro/reports/release-evidence/hando
 const AUTO_HANDOFF_EVIDENCE_REVIEW_DEFAULT_FILE = '.kiro/reports/release-evidence/handoff-evidence-review.md';
 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';
 
 /**
  * Register auto commands
@@ -1647,6 +1650,20 @@ function registerAutoCommands(program) {
         if (result.current_overview && result.current_overview.gate) {
           console.log(chalk.gray(`  Gate passed: ${result.current_overview.gate.passed ? 'yes' : 'no'}`));
         }
+        if (result.current_overview && result.current_overview.moqui_baseline) {
+          const moquiBaseline = result.current_overview.moqui_baseline;
+          const moquiSummary = moquiBaseline && moquiBaseline.summary ? moquiBaseline.summary : null;
+          console.log(chalk.gray(`  Moqui baseline: ${moquiBaseline.status || 'n/a'}`));
+          if (moquiSummary) {
+            const scoreText = Number.isFinite(Number(moquiSummary.avg_score))
+              ? `${moquiSummary.avg_score}`
+              : 'n/a';
+            const validRateText = Number.isFinite(Number(moquiSummary.valid_rate_percent))
+              ? `${moquiSummary.valid_rate_percent}%`
+              : 'n/a';
+            console.log(chalk.gray(`    Portfolio: ${moquiSummary.portfolio_passed === true ? 'pass' : 'fail'} | avg=${scoreText} | valid-rate=${validRateText}`));
+          }
+        }
         if (result.output_file) {
           console.log(chalk.gray(`  Output: ${result.output_file}`));
         }
@@ -1771,6 +1788,22 @@ function registerAutoCommands(program) {
           if (result.gates) {
             console.log(chalk.gray(`  Gate passed: ${result.gates.passed ? 'yes' : 'no'}`));
           }
+          if (result.moqui_baseline) {
+            console.log(chalk.gray(`  Moqui baseline: ${result.moqui_baseline.status || 'unknown'}`));
+            if (result.moqui_baseline.summary) {
+              const baselineSummary = result.moqui_baseline.summary;
+              const scoreText = Number.isFinite(Number(baselineSummary.avg_score))
+                ? `${baselineSummary.avg_score}`
+                : 'n/a';
+              const validRateText = Number.isFinite(Number(baselineSummary.valid_rate_percent))
+                ? `${baselineSummary.valid_rate_percent}%`
+                : 'n/a';
+              console.log(chalk.gray(`    Portfolio: ${baselineSummary.portfolio_passed ? 'pass' : 'fail'} | avg=${scoreText} | valid-rate=${validRateText}`));
+            }
+            if (result.moqui_baseline.output && result.moqui_baseline.output.json) {
+              console.log(chalk.gray(`    Baseline report: ${result.moqui_baseline.output.json}`));
+            }
+          }
           if (result.output_file) {
             console.log(chalk.gray(`  Report: ${result.output_file}`));
           }
@@ -8937,6 +8970,21 @@ function renderAutoHandoffEvidenceReviewMarkdown(payload = {}) {
   const regression = currentOverview.regression && typeof currentOverview.regression === 'object'
     ? currentOverview.regression
     : {};
+  const moquiBaseline = currentOverview.moqui_baseline && typeof currentOverview.moqui_baseline === 'object'
+    ? currentOverview.moqui_baseline
+    : {};
+  const moquiSummary = moquiBaseline && moquiBaseline.summary && typeof moquiBaseline.summary === 'object'
+    ? moquiBaseline.summary
+    : {};
+  const moquiCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
+    ? moquiBaseline.compare
+    : {};
+  const moquiDeltas = moquiCompare && moquiCompare.deltas && typeof moquiCompare.deltas === 'object'
+    ? moquiCompare.deltas
+    : {};
+  const moquiFailedTemplates = moquiCompare && moquiCompare.failed_templates && typeof moquiCompare.failed_templates === 'object'
+    ? moquiCompare.failed_templates
+    : {};
   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'
@@ -9001,6 +9049,19 @@ function renderAutoHandoffEvidenceReviewMarkdown(payload = {}) {
     `- Delta risk rank: ${formatAutoHandoffRegressionValue(regression.delta && regression.delta.risk_level_rank)}`,
     `- Delta failed goals: ${formatAutoHandoffRegressionValue(regression.delta && regression.delta.failed_goals)}`,
     '',
+    '## Current Moqui Baseline',
+    '',
+    `- Status: ${formatAutoHandoffRegressionValue(moquiBaseline.status)}`,
+    `- Portfolio passed: ${moquiSummary.portfolio_passed === true ? 'yes' : (moquiSummary.portfolio_passed === false ? 'no' : 'n/a')}`,
+    `- Avg score: ${formatAutoHandoffRegressionValue(moquiSummary.avg_score)}`,
+    `- Valid-rate: ${formatAutoHandoffRegressionValue(moquiSummary.valid_rate_percent)}%`,
+    `- Baseline failed templates: ${formatAutoHandoffRegressionValue(moquiSummary.baseline_failed)}`,
+    `- Delta avg score: ${formatAutoHandoffRegressionValue(moquiDeltas.avg_score)}`,
+    `- Delta valid-rate: ${formatAutoHandoffRegressionValue(moquiDeltas.valid_rate_percent)}%`,
+    `- Newly failed templates: ${Array.isArray(moquiFailedTemplates.newly_failed) && moquiFailedTemplates.newly_failed.length > 0 ? moquiFailedTemplates.newly_failed.join(', ') : 'none'}`,
+    `- Recovered templates: ${Array.isArray(moquiFailedTemplates.recovered) && moquiFailedTemplates.recovered.length > 0 ? moquiFailedTemplates.recovered.join(', ') : 'none'}`,
+    `- Baseline JSON: ${formatAutoHandoffRegressionValue(moquiBaseline.output && moquiBaseline.output.json)}`,
+    '',
     '## Trend Series',
     '',
     ...trendSeriesLines,
@@ -9092,6 +9153,21 @@ function renderAutoHandoffReleaseNotesDraft(payload = {}, context = {}) {
   const regression = currentOverview.regression && typeof currentOverview.regression === 'object'
     ? currentOverview.regression
     : {};
+  const moquiBaseline = currentOverview.moqui_baseline && typeof currentOverview.moqui_baseline === 'object'
+    ? currentOverview.moqui_baseline
+    : {};
+  const moquiSummary = moquiBaseline && moquiBaseline.summary && typeof moquiBaseline.summary === 'object'
+    ? moquiBaseline.summary
+    : {};
+  const moquiCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
+    ? moquiBaseline.compare
+    : {};
+  const moquiDeltas = moquiCompare && moquiCompare.deltas && typeof moquiCompare.deltas === 'object'
+    ? moquiCompare.deltas
+    : {};
+  const moquiFailedTemplates = moquiCompare && moquiCompare.failed_templates && typeof moquiCompare.failed_templates === 'object'
+    ? moquiCompare.failed_templates
+    : {};
   const riskLayers = payload.risk_layers && typeof payload.risk_layers === 'object'
     ? payload.risk_layers
     : {};
@@ -9136,6 +9212,13 @@ function renderAutoHandoffReleaseNotesDraft(payload = {}, context = {}) {
     `- Regression trend: ${formatAutoHandoffRegressionValue(regression.trend, formatAutoHandoffRegressionValue(payload.trend))}`,
     `- Window trend: ${formatAutoHandoffRegressionValue(payload.window_trend && payload.window_trend.trend)}`,
     `- Gate pass rate (window): ${formatAutoHandoffRegressionValue(payload.aggregates && payload.aggregates.gate_pass_rate_percent)}%`,
+    `- Moqui baseline portfolio passed: ${moquiSummary.portfolio_passed === true ? 'yes' : (moquiSummary.portfolio_passed === false ? 'no' : 'n/a')}`,
+    `- Moqui baseline avg score: ${formatAutoHandoffRegressionValue(moquiSummary.avg_score)}`,
+    `- Moqui baseline valid-rate: ${formatAutoHandoffRegressionValue(moquiSummary.valid_rate_percent)}%`,
+    `- Moqui baseline failed templates: ${formatAutoHandoffRegressionValue(moquiSummary.baseline_failed)}`,
+    `- 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'}`,
     '',
     '## Status Breakdown',
     '',
@@ -9154,6 +9237,8 @@ function renderAutoHandoffReleaseNotesDraft(payload = {}, context = {}) {
     `- Evidence review report: ${reviewFile || 'n/a'}`,
     `- Handoff report: ${formatAutoHandoffRegressionValue(currentOverview.handoff_report_file)}`,
     `- 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)}`,
     '',
     '## Recommendations'
   ];
@@ -9939,6 +10024,25 @@ function buildAutoHandoffRunRecommendations(projectPath, result) {
     push('kse auto governance stats --days 14 --json');
   }
 
+  const moquiBaseline = result && result.moqui_baseline && typeof result.moqui_baseline === 'object'
+    ? result.moqui_baseline
+    : null;
+  const moquiSummary = moquiBaseline && moquiBaseline.summary && typeof moquiBaseline.summary === 'object'
+    ? moquiBaseline.summary
+    : null;
+  if (moquiBaseline && moquiBaseline.status === 'error') {
+    push('kse scene moqui-baseline --json');
+  } else if (moquiSummary && moquiSummary.portfolio_passed === false) {
+    push(
+      'kse scene moqui-baseline --include-all ' +
+      '--compare-with .kiro/reports/release-evidence/moqui-template-baseline.json --json'
+    );
+    push(
+      'kse scene package-publish-batch --manifest docs/handoffs/handoff-manifest.json ' +
+      '--dry-run --ontology-task-queue-out .kiro/auto/ontology-remediation.lines --json'
+    );
+  }
+
   return recommendations;
 }
 
@@ -10026,6 +10130,21 @@ function buildAutoHandoffReleaseEvidenceEntry(projectPath, result, reportFile =
   const regressionDelta = regression && regression.delta && typeof regression.delta === 'object'
     ? regression.delta
     : {};
+  const moquiBaseline = result && result.moqui_baseline && typeof result.moqui_baseline === 'object'
+    ? result.moqui_baseline
+    : {};
+  const moquiSummary = moquiBaseline && moquiBaseline.summary && typeof moquiBaseline.summary === 'object'
+    ? moquiBaseline.summary
+    : {};
+  const moquiCompare = moquiBaseline && moquiBaseline.compare && typeof moquiBaseline.compare === 'object'
+    ? moquiBaseline.compare
+    : {};
+  const moquiDeltas = moquiCompare && moquiCompare.deltas && typeof moquiCompare.deltas === 'object'
+    ? moquiCompare.deltas
+    : {};
+  const moquiFailedTemplates = moquiCompare && moquiCompare.failed_templates && typeof moquiCompare.failed_templates === 'object'
+    ? moquiCompare.failed_templates
+    : {};
   const batchSummary = result && result.batch_summary && typeof result.batch_summary === 'object'
     ? result.batch_summary
     : {};
@@ -10084,6 +10203,42 @@ function buildAutoHandoffReleaseEvidenceEntry(projectPath, result, reportFile =
         ontology_undecided_decisions: toNumber(regressionDelta.ontology_undecided_decisions)
       }
     },
+    moqui_baseline: {
+      status: normalizeHandoffText(moquiBaseline.status),
+      generated: moquiBaseline.generated === true,
+      reason: normalizeHandoffText(moquiBaseline.reason),
+      error: normalizeHandoffText(moquiBaseline.error),
+      summary: {
+        total_templates: toNumber(moquiSummary.total_templates),
+        scoped_templates: toNumber(moquiSummary.scoped_templates),
+        avg_score: toNumber(moquiSummary.avg_score),
+        valid_rate_percent: toNumber(moquiSummary.valid_rate_percent),
+        baseline_passed: toNumber(moquiSummary.baseline_passed),
+        baseline_failed: toNumber(moquiSummary.baseline_failed),
+        portfolio_passed: moquiSummary.portfolio_passed === true
+      },
+      compare: Object.keys(moquiCompare).length === 0
+        ? null
+        : {
+          previous_generated_at: normalizeHandoffText(moquiCompare.previous_generated_at),
+          previous_template_root: normalizeHandoffText(moquiCompare.previous_template_root),
+          deltas: {
+            scoped_templates: toNumber(moquiDeltas.scoped_templates),
+            avg_score: toNumber(moquiDeltas.avg_score),
+            valid_rate_percent: toNumber(moquiDeltas.valid_rate_percent),
+            baseline_passed: toNumber(moquiDeltas.baseline_passed),
+            baseline_failed: toNumber(moquiDeltas.baseline_failed)
+          },
+          failed_templates: {
+            newly_failed: Array.isArray(moquiFailedTemplates.newly_failed) ? moquiFailedTemplates.newly_failed : [],
+            recovered: Array.isArray(moquiFailedTemplates.recovered) ? moquiFailedTemplates.recovered : []
+          }
+        },
+      output: {
+        json: normalizeHandoffText(moquiBaseline && moquiBaseline.output ? moquiBaseline.output.json : null),
+        markdown: normalizeHandoffText(moquiBaseline && moquiBaseline.output ? moquiBaseline.output.markdown : null)
+      }
+    },
     batch_summary: {
       status: normalizeHandoffText(batchSummary.status),
       total_goals: toNumber(batchSummary.total_goals),
@@ -10218,6 +10373,124 @@ async function writeAutoHandoffRunReport(projectPath, result, outCandidate = nul
   await maybeWriteOutput(result, defaultFile, projectPath);
 }
 
+function buildAutoHandoffMoquiBaselinePhaseDetails(payload) {
+  const baseline = payload && typeof payload === 'object' ? payload : {};
+  const summary = baseline.summary && typeof baseline.summary === 'object' ? baseline.summary : null;
+  return {
+    status: baseline.status || 'unknown',
+    generated: baseline.generated === true,
+    output: baseline.output || null,
+    portfolio_passed: summary ? summary.portfolio_passed === true : null,
+    avg_score: summary && Number.isFinite(Number(summary.avg_score))
+      ? Number(summary.avg_score)
+      : null,
+    valid_rate_percent: summary && Number.isFinite(Number(summary.valid_rate_percent))
+      ? Number(summary.valid_rate_percent)
+      : null
+  };
+}
+
+async function buildAutoHandoffMoquiBaselineSnapshot(projectPath) {
+  const scriptPath = path.join(projectPath, 'scripts', 'moqui-template-baseline-report.js');
+  if (!(await fs.pathExists(scriptPath))) {
+    return {
+      status: 'skipped',
+      generated: false,
+      reason: `baseline script missing: ${toAutoHandoffCliPath(projectPath, scriptPath)}`
+    };
+  }
+
+  const outputJsonPath = path.join(projectPath, AUTO_HANDOFF_MOQUI_BASELINE_JSON_FILE);
+  const outputMarkdownPath = path.join(projectPath, AUTO_HANDOFF_MOQUI_BASELINE_MARKDOWN_FILE);
+  await fs.ensureDir(path.dirname(outputJsonPath));
+
+  const scriptArgs = [
+    scriptPath,
+    '--out', outputJsonPath,
+    '--markdown-out', outputMarkdownPath,
+    '--json'
+  ];
+
+  if (await fs.pathExists(outputJsonPath)) {
+    scriptArgs.push('--compare-with', outputJsonPath);
+  }
+
+  const execution = spawnSync(process.execPath, scriptArgs, {
+    cwd: projectPath,
+    encoding: 'utf8'
+  });
+
+  const stdout = typeof execution.stdout === 'string' ? execution.stdout.trim() : '';
+  const stderr = typeof execution.stderr === 'string' ? execution.stderr.trim() : '';
+
+  if (execution.error) {
+    return {
+      status: 'error',
+      generated: false,
+      error: execution.error.message
+    };
+  }
+
+  if (execution.status !== 0) {
+    return {
+      status: 'error',
+      generated: false,
+      error: stderr || stdout || `baseline script exited with code ${execution.status}`
+    };
+  }
+
+  let reportPayload = null;
+  try {
+    reportPayload = stdout ? JSON.parse(stdout) : await fs.readJson(outputJsonPath);
+  } catch (error) {
+    return {
+      status: 'error',
+      generated: false,
+      error: `failed to parse baseline payload: ${error.message}`
+    };
+  }
+
+  const summary = reportPayload && reportPayload.summary && typeof reportPayload.summary === 'object'
+    ? reportPayload.summary
+    : {};
+  const compare = reportPayload && reportPayload.compare && typeof reportPayload.compare === 'object'
+    ? reportPayload.compare
+    : null;
+  const failedTemplates = compare && compare.failed_templates && typeof compare.failed_templates === 'object'
+    ? compare.failed_templates
+    : {};
+
+  return {
+    status: summary.portfolio_passed === true ? 'passed' : 'failed',
+    generated: true,
+    summary: {
+      total_templates: Number(summary.total_templates) || 0,
+      scoped_templates: Number(summary.scoped_templates) || 0,
+      avg_score: Number.isFinite(Number(summary.avg_score)) ? Number(summary.avg_score) : null,
+      valid_rate_percent: Number.isFinite(Number(summary.valid_rate_percent)) ? Number(summary.valid_rate_percent) : null,
+      baseline_passed: Number(summary.baseline_passed) || 0,
+      baseline_failed: Number(summary.baseline_failed) || 0,
+      portfolio_passed: summary.portfolio_passed === true
+    },
+    compare: compare
+      ? {
+        previous_generated_at: compare.previous_generated_at || null,
+        previous_template_root: compare.previous_template_root || null,
+        deltas: compare.deltas || null,
+        failed_templates: {
+          newly_failed: Array.isArray(failedTemplates.newly_failed) ? failedTemplates.newly_failed : [],
+          recovered: Array.isArray(failedTemplates.recovered) ? failedTemplates.recovered : []
+        }
+      }
+      : null,
+    output: {
+      json: toAutoHandoffCliPath(projectPath, outputJsonPath),
+      markdown: toAutoHandoffCliPath(projectPath, outputMarkdownPath)
+    },
+    warnings: stderr ? [stderr] : []
+  };
+}
+
 async function runAutoHandoff(projectPath, options = {}) {
   const startedAtMs = Date.now();
   const result = {
@@ -10239,6 +10512,7 @@ async function runAutoHandoff(projectPath, options = {}) {
     observability_snapshot: null,
     spec_status: null,
     ontology_validation: null,
+    moqui_baseline: null,
     gates: null,
     regression: null,
     release_evidence: null,
@@ -10340,6 +10614,25 @@ 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,
@@ -10400,6 +10693,26 @@ 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,

package/lib/commands/scene.js

@@ -1,6 +1,7 @@
 const path = require('path');
 const zlib = require('zlib');
 const crypto = require('crypto');
+const { spawnSync } = require('child_process');
 const fs = require('fs-extra');
 const chalk = require('chalk');
 const yaml = require('js-yaml');
@@ -60,6 +61,9 @@ const SCENE_PACKAGE_KINDS = new Set([
 const SCENE_PACKAGE_RISK_LEVELS = new Set(['low', 'medium', 'high', 'critical']);
 const SCENE_PACKAGE_TEMPLATE_API_VERSION = 'kse.scene.template/v0.1';
 const SCENE_PACKAGE_TEMPLATE_DEFAULT_DIR = '.kiro/templates/scene-packages';
+const SCENE_MOQUI_BASELINE_DEFAULT_MATCH = '(moqui|erp)';
+const SCENE_MOQUI_BASELINE_DEFAULT_MIN_SCORE = 70;
+const SCENE_MOQUI_BASELINE_DEFAULT_MIN_VALID_RATE = 100;
 const SCENE_PACKAGE_BATCH_DEFAULT_ONTOLOGY_MIN_AVERAGE_SCORE = 70;
 const SCENE_PACKAGE_BATCH_DEFAULT_ONTOLOGY_MIN_VALID_RATE = 100;
 const SCENE_PACKAGE_GATE_API_VERSION = 'kse.scene.package-gate/v0.1';
@@ -536,6 +540,23 @@ function registerSceneCommands(program) {
       await runSceneTemplateRenderCommand(options);
     });
 
+  sceneCmd
+    .command('moqui-baseline')
+    .description('Generate Moqui template baseline scorecard from scene package library')
+    .option('--template-dir <path>', 'Template root directory', SCENE_PACKAGE_TEMPLATE_DEFAULT_DIR)
+    .option('--out <path>', 'JSON report output path', '.kiro/reports/moqui-template-baseline.json')
+    .option('--markdown-out <path>', 'Markdown report output path', '.kiro/reports/moqui-template-baseline.md')
+    .option('--match <regex>', 'Template selector regex', SCENE_MOQUI_BASELINE_DEFAULT_MATCH)
+    .option('--include-all', 'Disable selector filter and score all templates')
+    .option('--min-score <number>', 'Baseline minimum semantic score (0-100)', String(SCENE_MOQUI_BASELINE_DEFAULT_MIN_SCORE))
+    .option('--min-valid-rate <number>', 'Baseline minimum ontology valid-rate percent (0-100)', String(SCENE_MOQUI_BASELINE_DEFAULT_MIN_VALID_RATE))
+    .option('--compare-with <path>', 'Compare with previous baseline JSON report')
+    .option('--fail-on-portfolio-fail', 'Exit non-zero when portfolio baseline gate fails')
+    .option('--json', 'Print payload as JSON')
+    .action(async (options) => {
+      await runSceneMoquiBaselineCommand(options);
+    });
+
   sceneCmd
     .command('instantiate')
     .description('Instantiate scene template package with full pipeline (resolve, validate, render, manifest, log, hook)')
@@ -10960,6 +10981,48 @@ function validateSceneTemplateResolveOptions(options) {
   return null;
 }
 
+function normalizeSceneMoquiBaselineOptions(options = {}) {
+  const minScore = Number(options.minScore);
+  const minValidRate = Number(options.minValidRate);
+  return {
+    templateDir: options.templateDir ? String(options.templateDir).trim() : SCENE_PACKAGE_TEMPLATE_DEFAULT_DIR,
+    out: options.out ? String(options.out).trim() : '.kiro/reports/moqui-template-baseline.json',
+    markdownOut: options.markdownOut ? String(options.markdownOut).trim() : '.kiro/reports/moqui-template-baseline.md',
+    match: options.match ? String(options.match).trim() : SCENE_MOQUI_BASELINE_DEFAULT_MATCH,
+    includeAll: options.includeAll === true,
+    minScore: Number.isFinite(minScore) ? minScore : SCENE_MOQUI_BASELINE_DEFAULT_MIN_SCORE,
+    minValidRate: Number.isFinite(minValidRate) ? minValidRate : SCENE_MOQUI_BASELINE_DEFAULT_MIN_VALID_RATE,
+    compareWith: options.compareWith ? String(options.compareWith).trim() : undefined,
+    failOnPortfolioFail: options.failOnPortfolioFail === true,
+    json: options.json === true
+  };
+}
+
+function validateSceneMoquiBaselineOptions(options) {
+  if (!options.templateDir || typeof options.templateDir !== 'string' || options.templateDir.trim().length === 0) {
+    return '--template-dir is required';
+  }
+  if (!options.out || typeof options.out !== 'string' || options.out.trim().length === 0) {
+    return '--out is required';
+  }
+  if (!options.markdownOut || typeof options.markdownOut !== 'string' || options.markdownOut.trim().length === 0) {
+    return '--markdown-out is required';
+  }
+  if (!options.match || typeof options.match !== 'string' || options.match.trim().length === 0) {
+    return '--match is required';
+  }
+  if (!Number.isFinite(Number(options.minScore)) || Number(options.minScore) < 0 || Number(options.minScore) > 100) {
+    return '--min-score must be a number between 0 and 100';
+  }
+  if (!Number.isFinite(Number(options.minValidRate)) || Number(options.minValidRate) < 0 || Number(options.minValidRate) > 100) {
+    return '--min-valid-rate must be a number between 0 and 100';
+  }
+  if (options.compareWith !== undefined && (!options.compareWith || options.compareWith.length === 0)) {
+    return '--compare-with cannot be empty';
+  }
+  return null;
+}
+
 // --- Print functions for template commands ---
 
 function printSceneTemplateValidateSummary(options, payload, projectRoot = process.cwd()) {
@@ -11076,6 +11139,80 @@ function printSceneTemplateRenderSummary(options, payload, projectRoot = process
 
 // --- Command runners for template commands ---
 
+async function runSceneMoquiBaselineCommand(rawOptions = {}, dependencies = {}) {
+  const projectRoot = dependencies.projectRoot || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+
+  const options = normalizeSceneMoquiBaselineOptions(rawOptions);
+  const validationError = validateSceneMoquiBaselineOptions(options);
+  if (validationError) {
+    console.error(chalk.red(`Scene moqui-baseline failed: ${validationError}`));
+    process.exitCode = 1;
+    return null;
+  }
+
+  const scriptPath = path.join(projectRoot, 'scripts', 'moqui-template-baseline-report.js');
+  const scriptExists = await fileSystem.pathExists(scriptPath);
+  if (!scriptExists) {
+    console.error(chalk.red(`Scene moqui-baseline failed: script not found at ${scriptPath}`));
+    process.exitCode = 1;
+    return null;
+  }
+
+  const args = [scriptPath];
+  args.push('--template-dir', options.templateDir);
+  args.push('--out', options.out);
+  args.push('--markdown-out', options.markdownOut);
+  args.push('--match', options.match);
+  args.push('--min-score', String(options.minScore));
+  args.push('--min-valid-rate', String(options.minValidRate));
+  if (options.includeAll) {
+    args.push('--include-all');
+  }
+  if (options.compareWith) {
+    args.push('--compare-with', options.compareWith);
+  }
+  if (options.failOnPortfolioFail) {
+    args.push('--fail-on-portfolio-fail');
+  }
+  if (options.json) {
+    args.push('--json');
+  }
+
+  const result = spawnSync(process.execPath, args, {
+    cwd: projectRoot,
+    encoding: 'utf8'
+  });
+
+  if (typeof result.stdout === 'string' && result.stdout.length > 0) {
+    process.stdout.write(result.stdout);
+  }
+  if (typeof result.stderr === 'string' && result.stderr.length > 0) {
+    process.stderr.write(result.stderr);
+  }
+
+  if (result.error) {
+    console.error(chalk.red(`Scene moqui-baseline failed: ${result.error.message}`));
+    process.exitCode = 1;
+    return null;
+  }
+
+  const exitCode = Number.isInteger(result.status) ? result.status : 1;
+  if (exitCode !== 0) {
+    process.exitCode = exitCode;
+  }
+
+  if (options.json && typeof result.stdout === 'string' && result.stdout.trim().length > 0) {
+    try {
+      return JSON.parse(result.stdout);
+    } catch (_error) {
+      return null;
+    }
+  }
+
+  return null;
+}
+
 async function runSceneTemplateValidateCommand(rawOptions = {}, dependencies = {}) {
   const projectRoot = dependencies.projectRoot || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
@@ -15266,6 +15403,9 @@ module.exports = {
   validateSceneTemplateValidateOptions,
   normalizeSceneTemplateResolveOptions,
   validateSceneTemplateResolveOptions,
+  normalizeSceneMoquiBaselineOptions,
+  validateSceneMoquiBaselineOptions,
+  runSceneMoquiBaselineCommand,
   runSceneTemplateValidateCommand,
   runSceneTemplateResolveCommand,
   runSceneTemplateRenderCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiro-spec-engine",
-  "version": "1.47.30",
+  "version": "1.47.32",
   "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": {