@planu/cli 4.10.5 → 4.10.7

package/dist/tools/update-status/dod-gates.js

@@ -10,6 +10,7 @@ import { randomUUID } from 'node:crypto';
 import { withEscalation } from '../../engine/escalator/with-escalation.js';
 import { writeImplementationReviewReport } from '../../engine/validator/validation-report-writer.js';
 import { writeSpecReviewFeedback } from '../../engine/validator/spec-review-writer.js';
+import { formatKeyValue } from '../output-formatter.js';
 /**
  * SPEC-721 / SPEC-222 Trigger 1: Run validate engine before marking done.
  *
@@ -54,7 +55,13 @@ export async function runValidateGate(spec, projectPath, forceStatus, forceStatu
         catch {
             /* swallow — forced bypass must never throw */
         }
-        return { blocked: false, score: observedScore, forced: true, forcedReason: forceStatusReason };
+        return {
+            blocked: false,
+            score: observedScore,
+            forced: true,
+            forcedReason: forceStatusReason,
+            scoreSource: 'forced-best-effort-validateSpec',
+        };
     }
     // ---- Normal path — fail-CLOSED --------------------------------------------
     const TIMEOUT_SENTINEL = Symbol('timeout');
@@ -157,29 +164,36 @@ export async function checkDodGate(spec, specId, projectId, projectPath, _force)
     }).catch((err) => {
         console.error('[planu] DoD feedback event failed:', err);
     });
-    const failedItems = requiredItems
-        .filter((i) => i.status === 'failed')
-        .map((i) => ({ id: i.id, description: i.description, category: i.category }));
     return {
         content: [
             {
                 type: 'text',
-                text: JSON.stringify({
-                    error: 'DoD gate failed',
-                    message: humanMessage,
+                text: [
+                    humanMessage,
                     expertSummary,
-                    blockingItems,
-                    failedItems,
-                    warningItems,
-                    fixHints,
-                    gateResults: dod.gateResults ?? null,
-                    hint: '💡 Alternatively: use force:true to bypass all gates',
-                }, null, 2),
+                    ...fixHints.slice(0, 3),
+                    ...warningItems.slice(0, 2).map((item) => `Warning: ${item}`),
+                    blockingItems.length > 3 ? `More blockers: ${blockingItems.length - 3}` : undefined,
+                    warningItems.length > 0 ? `Warnings: ${warningItems.length}` : undefined,
+                    'Alternatively: use force:true to bypass all gates.',
+                ]
+                    .filter(Boolean)
+                    .join('\n'),
             },
         ],
         isError: true,
         structuredContent: {
-            error: 'dod_gate_failed',
+            error: 'DoD gate failed',
+            errorCode: 'dod_gate_failed',
+            message: humanMessage,
+            expertSummary,
+            blockingItems,
+            failedItems: requiredItems
+                .filter((i) => i.status === 'failed')
+                .map((i) => ({ id: i.id, description: i.description, category: i.category })),
+            warningItems,
+            fixHints,
+            hint: 'Alternatively: use force:true to bypass all gates',
             code: 422,
             context: {
                 specId,
@@ -402,13 +416,14 @@ function validationReportGateError(args) {
         content: [
             {
                 type: 'text',
-                text: JSON.stringify({
+                text: formatKeyValue({
                     error: args.error,
                     message: args.message,
                     artifactPath,
-                    gates: args.gates,
+                    failedGates: args.gates.filter((gate) => !gate.passed).length,
+                    totalGates: args.gates.length,
                     fixHint: args.fixHint,
-                }, null, 2),
+                }, 'Validation report gate failed'),
             },
         ],
         isError: true,
@@ -426,13 +441,14 @@ function specReviewGateError(args) {
         content: [
             {
                 type: 'text',
-                text: JSON.stringify({
+                text: formatKeyValue({
                     error: args.error,
                     message: args.message,
                     artifactPath,
-                    blockers: args.blockers,
+                    blockers: args.blockers.length,
+                    firstBlocker: args.blockers[0],
                     fixHint: args.fixHint,
-                }, null, 2),
+                }, 'Spec review gate failed'),
             },
         ],
         isError: true,
@@ -512,33 +528,7 @@ export async function checkComplianceGate(specId, projectId, projectPath) {
         return { skipped: true, score: null, issues: [], blocked: false };
     }
 }
-/** SPEC-642: Block done if QA gate has not run and passed. */
-export async function checkQaGate(specId, projectPath, force) {
-    if (force || !projectPath) {
-        return null;
-    }
-    const { getGateState } = await import('../../storage/qa-gate-store.js');
-    const state = await getGateState(projectPath, specId).catch(() => null);
-    if (state?.lastResult?.passed === true) {
-        return null;
-    }
-    const reason = state === null ? 'QA gate not run' : 'QA gate did not pass';
-    return {
-        content: [
-            {
-                type: 'text',
-                text: `❌ ${reason} — run the QA checks first or use force:true to bypass`,
-            },
-        ],
-        isError: true,
-        structuredContent: {
-            error: 'qa_gate_not_passed',
-            code: 422,
-            context: { specId, reason },
-            fixHint: 'Run the QA gate and record the result: typecheck + test by default, or typecheck + test:coverage when the spec declares a coverage threshold. Then retry update_status(done). Or use force:true to bypass.',
-        },
-    };
-}
+export { checkQaGate } from './qa-gate.js';
 /**
  * SPEC-716 / SPEC-780: Format gate for transition to 'approved'.
  *
@@ -576,17 +566,22 @@ export async function checkApprovedFormatGate(spec, newStatus, forceApprove = fa
         content: [
             {
                 type: 'text',
-                text: JSON.stringify({
+                text: formatKeyValue({
                     error: 'SPEC_FORMAT_INVALID',
                     message: `Spec format validation failed with ${String(result.errors.length)} error(s) — fix before approving, or pass forceApprove: true to bypass with warnings.`,
-                    errors: result.errors,
-                    warnings: result.warnings,
-                }, null, 2),
+                    errors: result.errors.length,
+                    warnings: result.warnings.length,
+                    firstError: result.errors[0]?.message,
+                    firstErrorPath: result.errors[0]?.path,
+                }, 'Spec format invalid'),
             },
         ],
         isError: true,
         structuredContent: {
             error: 'SPEC_FORMAT_INVALID',
+            message: `Spec format validation failed with ${String(result.errors.length)} error(s) — fix before approving, or pass forceApprove: true to bypass with warnings.`,
+            errors: result.errors,
+            warnings: result.warnings,
             code: 422,
             context: {
                 specId: spec.id,

package/dist/tools/update-status/evidence-gate.js

@@ -7,6 +7,7 @@ import { buildSpecEvidenceIndex } from '../../engine/evidence-index/index-builde
 import { checkDoneDriftContract } from '../../engine/evidence-index/done-drift.js';
 import { parseTechnicalReferenceGroundingRecords } from '../../engine/spec-grounding/contract.js';
 import { extractAcceptanceCriteriaTexts } from '../../engine/spec-format/acceptance-criteria.js';
+import { formatKeyValue } from '../output-formatter.js';
 /** SPEC-1054: BDD/SDD lifecycle evidence gate. */
 export async function checkLifecycleEvidenceTransitionGate(args) {
     const [criteriaResult, artifacts] = await Promise.all([
@@ -69,15 +70,16 @@ function evidenceGateError(args) {
         content: [
             {
                 type: 'text',
-                text: JSON.stringify({
+                text: formatKeyValue({
                     error: 'lifecycle_evidence_gate_failed',
                     message: `BDD/SDD evidence gate blocked ${args.transition}.`,
                     specId: args.specId,
                     transition: args.transition,
-                    issues: args.issues,
-                    requiredContractKinds: args.requiredContractKinds,
+                    issues: args.issues.length,
+                    firstIssue: args.issues[0]?.message,
+                    requiredContractKinds: args.requiredContractKinds.length,
                     fixHint: 'Add the missing evidence artifact to the external Planu project data handoff store, then retry the transition. Do not create JSON files under planu/specs/<spec>/.',
-                }, null, 2),
+                }),
             },
         ],
         isError: true,

package/dist/tools/update-status/index.js

@@ -26,6 +26,7 @@ import { updateFrontmatterField } from '../../engine/frontmatter-parser.js';
 import { atomicWriteFile } from '../../engine/safety/atomic-write-file.js';
 import { recordForceUsage } from '../../storage/force-analytics-store.js';
 import { maybeSafePushOnDone, runCascadeForResponse } from './side-effects.js';
+import { formatKeyValue } from '../output-formatter.js';
 import { checkCodeReality } from '../../engine/code-scanner/index.js';
 import { scanCrashRisks } from '../../engine/crash-shield/index.js';
 import { shouldSkipCrashScan, recordCrashScanRun, } from '../../engine/autopilot/crash-shield-rate-limiter.js';
@@ -341,11 +342,11 @@ export async function handleUpdateStatus(params, server) {
                             content: [
                                 {
                                     type: 'text',
-                                    text: JSON.stringify({
+                                    text: formatKeyValue({
                                         error: 'invalid_input',
                                         message: reverseValidation.error,
                                         fixHint: reverseValidation.fixHint,
-                                    }, null, 2),
+                                    }),
                                 },
                             ],
                             isError: true,
@@ -466,7 +467,7 @@ export async function handleUpdateStatus(params, server) {
                 // SPEC-642: QA gate — block done if typecheck + test:coverage have not passed
                 // ---------------------------------------------------------------------------
                 if (newStatus === 'done') {
-                    const qaGateResult = await checkQaGate(specId, effectiveGatePath, params.force ?? false);
+                    const qaGateResult = await checkQaGate(spec, effectiveGatePath, params.force ?? false);
                     if (qaGateResult !== null) {
                         return qaGateResult;
                     }
@@ -503,6 +504,7 @@ export async function handleUpdateStatus(params, server) {
                 // SPEC-447: Compliance gate on 'review' or 'implementing'
                 // ---------------------------------------------------------------------------
                 let validateScore = null;
+                let validateScoreSource = null;
                 let crashShieldWarning = null;
                 let crashShieldSkipReason = null;
                 let complianceGateResult = null;
@@ -537,11 +539,15 @@ export async function handleUpdateStatus(params, server) {
                     }
                     validateScore = validateGateResult.score;
                     if (validateGateResult.forced) {
+                        validateScoreSource = validateGateResult.scoreSource;
                         forcedValidateBypass = {
                             reason: validateGateResult.forcedReason,
                             observedScore: validateGateResult.score,
                         };
                     }
+                    else {
+                        validateScoreSource = 'validateSpec';
+                    }
                 }
                 if (newStatus === 'done' && !(params.force ?? params.forceStatus ?? false)) {
                     const validationReportError = await checkValidationReportGate(specId, projectId, false);
@@ -1045,6 +1051,7 @@ export async function handleUpdateStatus(params, server) {
                     forcedBypassWarning,
                     forceAnalyticsWarning,
                     validateScore,
+                    validateScoreSource,
                     // SPEC-721: audit ID for the forced validate bypass (null when no bypass occurred)
                     forceStatusAuditId,
                     // SPEC-780: audit ID for the forced approve bypass (null when no bypass occurred)

package/dist/tools/update-status/qa-gate.d.ts

@@ -0,0 +1,5 @@
+import type { ToolResult } from '../../types/index.js';
+import type { Spec } from '../../types/spec/core.js';
+/** SPEC-642 / SPEC-1111: verify and persist local QA evidence before done. */
+export declare function checkQaGate(spec: Spec, projectPath: string | undefined, force: boolean): Promise<ToolResult | null>;
+//# sourceMappingURL=qa-gate.d.ts.map

package/dist/tools/update-status/qa-gate.js

@@ -0,0 +1,50 @@
+/** SPEC-642 / SPEC-1111: verify and persist local QA evidence before done. */
+export async function checkQaGate(spec, projectPath, force) {
+    if (force || !projectPath) {
+        return null;
+    }
+    const specId = spec.id;
+    const { getGateState, saveGateState } = await import('../../storage/qa-gate-store.js');
+    const state = await getGateState(projectPath, specId).catch(() => null);
+    if (state?.lastResult?.passed === true) {
+        return null;
+    }
+    let effectiveResult = state?.lastResult ?? null;
+    if (effectiveResult === null) {
+        const { runQaGate } = await import('../../engine/qa-gate.js');
+        effectiveResult = await runQaGate(spec, projectPath);
+        await saveGateState(projectPath, specId, effectiveResult);
+    }
+    if (effectiveResult.passed) {
+        return null;
+    }
+    const failedChecks = effectiveResult.checks.filter((check) => !check.passed);
+    const failedSummary = failedChecks.length > 0
+        ? failedChecks
+            .map((check) => {
+            const command = check.command ?? check.name;
+            const reason = check.timedOut
+                ? `timed out after ${String(check.durationMs)}ms`
+                : (check.errorMessage ?? 'exited with a non-zero status');
+            return `${command}: ${reason}`;
+        })
+            .join('; ')
+        : 'No failed check details recorded.';
+    const reason = 'QA gate did not pass';
+    return {
+        content: [
+            {
+                type: 'text',
+                text: `❌ ${reason} — ${failedSummary}. Fix the failing local QA checks or use force:true to bypass`,
+            },
+        ],
+        isError: true,
+        structuredContent: {
+            error: 'qa_gate_not_passed',
+            code: 422,
+            context: { specId, reason, failedChecks },
+            fixHint: 'Fix the failing QA command(s), rerun update_status(done), or use force:true to bypass with audit context.',
+        },
+    };
+}
+//# sourceMappingURL=qa-gate.js.map

package/dist/tools/update-status/response-builder.js

@@ -116,7 +116,10 @@ export function buildStatusResponse(result, specId, currentStatus, newStatus, re
         lines.push(`\n🤖 Tokens: ${tokenStr}${costStr}${r.actuals.estimated ? ' *(auto-estimated)*' : ''}`);
     }
     if (r.validateScore !== null && r.validateScore !== undefined) {
-        lines.push(`\n✅ Validate score: ${String(r.validateScore)}/100`);
+        const sourceSuffix = r.validateScoreSource === 'forced-best-effort-validateSpec'
+            ? ' (forced best-effort observation from validateSpec)'
+            : '';
+        lines.push(`\n✅ Validate score: ${String(r.validateScore)}/100${sourceSuffix}`);
     }
     if (r.cascade.affectedSpecs.length > 0) {
         lines.push(`\n🔗 Downstream specs affected: ${r.cascade.affectedSpecs.map((s) => `SPEC-${s}`).join(', ')}`);
@@ -201,12 +204,103 @@ export function buildStatusResponse(result, specId, currentStatus, newStatus, re
         : withNextSteps;
     const displayTitle = specTitle ?? `SPEC-${specId}`;
     const humanSummary = buildUpdateStatusSummary(displayTitle, newStatus);
+    const warningItems = [
+        r.protectedBranchWarning,
+        r.mergeWarning,
+        r.validationWarning,
+        r.codeRealityWarning,
+        r.crashShieldWarning,
+        r.forcedBypassWarning,
+        ...(r.constitutionWarnings ?? []).map((w) => w.description),
+        ...(r.conventionWarnings ?? []),
+        ...(r.lintWarnings ?? []),
+        ...(r.testWarnings ?? []),
+        ...(r.compileWarnings ?? []),
+        ...(r.frontmatterSyncWarnings ?? []).map((w) => `frontmatter sync failed for ${w.specId}: ${w.reason}`),
+    ].filter((item) => typeof item === 'string' && item.length > 0);
+    const validationIssues = [
+        ...(r.validationWarning ? [r.validationWarning] : []),
+        ...(r.complianceGateResult?.issues ?? []),
+        ...(r.lintWarnings ?? []),
+        ...(r.testWarnings ?? []),
+        ...(r.compileWarnings ?? []),
+    ];
+    const structuredContent = {
+        specId,
+        previousStatus: currentStatus,
+        newStatus,
+        autoBranch: r.autoBranch ?? undefined,
+        protectedBranchWarning: r.protectedBranchWarning ?? undefined,
+        mergeWarning: r.mergeWarning ?? undefined,
+        validationWarning: r.validationWarning ?? undefined,
+        prSuggestion: r.prSuggestion ?? null,
+        metrics: r.metrics ?? undefined,
+        actuals: r.actuals ?? undefined,
+        cascade: {
+            ...(result.cascade ?? {}),
+            affectedSpecs: r.cascade.affectedSpecs,
+        },
+        constitutionWarnings: r.constitutionWarnings?.slice(0, 5),
+        conventionWarnings: r.conventionWarnings?.slice(0, 5),
+        lintWarnings: r.lintWarnings?.slice(0, 5),
+        testWarnings: r.testWarnings?.slice(0, 5),
+        compileWarnings: r.compileWarnings?.slice(0, 5),
+        validateScore: r.validateScore ?? undefined,
+        validateScoreSource: r.validateScoreSource ?? undefined,
+        complianceGateResult: r.complianceGateResult
+            ? {
+                skipped: r.complianceGateResult.skipped,
+                score: r.complianceGateResult.score,
+                blocked: r.complianceGateResult.blocked,
+                issues: r.complianceGateResult.issues.slice(0, 5),
+            }
+            : undefined,
+        forceApproveAuditId: typeof result.forceApproveAuditId === 'string' ? result.forceApproveAuditId : undefined,
+        forceStatusAuditId: typeof result.forceStatusAuditId === 'string' ? result.forceStatusAuditId : undefined,
+        qualityWarnings: Array.isArray(result.qualityWarnings)
+            ? result.qualityWarnings.slice(0, 5)
+            : undefined,
+        interactiveQuestions: Array.isArray(result.interactiveQuestions)
+            ? result.interactiveQuestions
+            : undefined,
+        transitionSummary: {
+            title: displayTitle,
+            from: currentStatus,
+            to: newStatus,
+            autoBranch: r.autoBranch ?? undefined,
+            versionSnapshotTag: r.versionSnapshotTag ?? undefined,
+        },
+        validationSummary: {
+            validateScore: r.validateScore ?? null,
+            validateScoreSource: r.validateScoreSource ?? null,
+            complianceScore: r.complianceGateResult?.score ?? null,
+            complianceBlocked: r.complianceGateResult?.blocked ?? false,
+            validationIssuesCount: validationIssues.length,
+            validationIssuesTop5: validationIssues.slice(0, 5),
+        },
+        blockersCount: validationIssues.length,
+        blockersTop3: validationIssues.slice(0, 3),
+        warningsCount: warningItems.length,
+        warningsTop5: warningItems.slice(0, 5),
+        affectedSpecsCount: r.cascade.affectedSpecs.length,
+        affectedSpecsTop5: r.cascade.affectedSpecs.slice(0, 5),
+        nextAction,
+        lifecycleMap,
+        humanSummary,
+        orchestrationPlan: r.orchestrationPlan
+            ? {
+                waves: r.orchestrationPlan.executionOrder.length,
+                parallelSafetyVerdict: r.orchestrationPlan.parallelSafetyVerdict,
+                executionOrder: r.orchestrationPlan.executionOrder,
+            }
+            : undefined,
+    };
     return {
         content: [
             { type: 'text', text: markdownText },
             { type: 'text', text: humanSummary },
         ],
-        structuredContent: { ...result, nextAction, lifecycleMap, humanSummary },
+        structuredContent,
     };
 }
 /** Render a compact lifecycle map line showing current, next, and remaining steps */

package/dist/tools/update-status/transition-guard.js

@@ -8,6 +8,7 @@ import { checkReadinessInternal } from '../../engine/readiness-checker.js';
 import { validateEnglishOnlySpecText } from '../../engine/spec-language/english-only.js';
 import { checkGroundedSpecContract } from '../../engine/spec-grounding/contract.js';
 import { checkGenericSpecOutput } from '../../engine/spec-quality/generic-output-gate.js';
+import { formatKeyValue } from '../output-formatter.js';
 /**
  * Valid state transitions for spec lifecycle.
  * draft -> review -> approved -> implementing -> done
@@ -133,16 +134,29 @@ export function checkDorGate(spec, specId, projectId, newStatus) {
             content: [
                 {
                     type: 'text',
-                    text: JSON.stringify({
-                        error: 'DoR gate failed',
-                        message: dorResult.humanMessage,
-                        expertSummary: dorResult.expertSummary,
-                        blockingItems: dorResult.blockingItems,
-                        warningItems: dorResult.warningItems,
-                    }, null, 2),
+                    text: [
+                        dorResult.humanMessage,
+                        dorResult.expertSummary,
+                        ...dorResult.blockingItems.slice(0, 3).map((item) => `Blocker: ${item}`),
+                        dorResult.blockingItems.length > 3
+                            ? `More blockers: ${String(dorResult.blockingItems.length - 3)}`
+                            : undefined,
+                        dorResult.warningItems.length > 0
+                            ? `Warnings: ${String(dorResult.warningItems.length)}`
+                            : undefined,
+                    ]
+                        .filter(Boolean)
+                        .join('\n'),
                 },
             ],
             isError: true,
+            structuredContent: {
+                error: 'DoR gate failed',
+                message: dorResult.humanMessage,
+                expertSummary: dorResult.expertSummary,
+                blockingItems: dorResult.blockingItems,
+                warningItems: dorResult.warningItems,
+            },
         };
     }
     return null;
@@ -163,16 +177,24 @@ export async function checkAmbiguityGate(spec, newStatus) {
         content: [
             {
                 type: 'text',
-                text: JSON.stringify({
+                text: formatKeyValue({
                     error: 'Ambiguity gate failed',
                     message: `Ambiguity score ${String(report.score)}/100 — below 70. Fix vague terms in criteria before approving.`,
                     ambiguityScore: report.score,
-                    violations: report.violations.slice(0, 5),
-                    blockers: report.blockers.slice(0, 5),
-                }, null, 2),
+                    violations: report.violations.length,
+                    blockers: report.blockers.length,
+                    firstBlocker: report.blockers[0],
+                }, 'Ambiguity gate failed'),
             },
         ],
         isError: true,
+        structuredContent: {
+            error: 'Ambiguity gate failed',
+            message: `Ambiguity score ${String(report.score)}/100 — below 70. Fix vague terms in criteria before approving.`,
+            ambiguityScore: report.score,
+            violations: report.violations.slice(0, 5),
+            blockers: report.blockers.slice(0, 5),
+        },
     };
 }
 /**

package/dist/tools/update-status-convention-gate.js

@@ -22,7 +22,7 @@ async function execGate(cmd, cwd, timeoutMs) {
             timeout: timeoutMs,
             maxBuffer: 4 * 1024 * 1024,
         });
-        return { output: stdout.trim(), ok: true };
+        return { output: stdout.trim(), ok: true, timedOut: false };
     }
     catch (err) {
         const e = err;
@@ -31,7 +31,8 @@ async function execGate(cmd, cwd, timeoutMs) {
             : typeof e.stdout === 'string'
                 ? e.stdout
                 : '';
-        return { output: raw.trim(), ok: false };
+        const timedOut = e.killed === true || e.signal === 'SIGTERM' || e.code === 'ETIMEDOUT';
+        return { output: raw.trim(), ok: false, timedOut, errorMessage: e.message };
     }
 }
 function countLintIssues(output) {
@@ -87,23 +88,38 @@ async function checkTestGate(projectPath, testCmd) {
     }
     // Run tests with a reasonable timeout — only a warning if they fail
     const cmd = testCmd ?? 'npx vitest run --reporter=verbose';
-    const { output, ok } = await execGate(cmd, projectPath, 20_000);
+    const timeoutMs = 120_000;
+    const { output, ok, timedOut, errorMessage } = await execGate(cmd, projectPath, timeoutMs);
     if (ok) {
         return [];
     }
+    if (timedOut) {
+        return [`Tests: timed out after ${String(timeoutMs)}ms. Command: ${cmd}`];
+    }
     // Extract summary line (e.g. "5 failed" or "FAIL src/foo.test.ts")
     const failLine = output
         .split('\n')
         .reverse()
-        .find((l) => /fail|error/i.test(l) && l.trim().length > 0);
+        .find((l) => isFailureSummaryLine(l));
     const summary = failLine ??
         output
             .split('\n')
-            .filter((l) => l.trim())
+            .filter((l) => l.trim() && !isPassingSummaryLine(l))
             .slice(-1)[0] ??
-        '';
+        errorMessage ??
+        'No failure summary available.';
     return [`Tests: failed. ${summary.trim()}`];
 }
+function isPassingSummaryLine(line) {
+    return /^\s*(?:✓|PASS\b|Test Files\s+\d+\s+passed|Tests\s+\d+\s+passed)/i.test(line.trim());
+}
+function isFailureSummaryLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || isPassingSummaryLine(trimmed)) {
+        return false;
+    }
+    return /\b(?:FAIL|failed|failing|error|errored)\b/i.test(trimmed);
+}
 // ---------------------------------------------------------------------------
 // Convention gate (existing logic, unchanged)
 // ---------------------------------------------------------------------------

package/dist/tools/validate-team-results.js

@@ -1,11 +1,33 @@
 import { specStore } from '../storage/index.js';
 import { validateTeamResults } from '../engine/team-planner/index.js';
 import { readFile } from 'node:fs/promises';
+import { formatKeyValue } from './output-formatter.js';
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 function text(content) {
-    return { content: [{ type: 'text', text: JSON.stringify(content, null, 2) }] };
+    const conflicts = Array.isArray(content.conflicts) ? content.conflicts.length : undefined;
+    const mergeOrder = Array.isArray(content.mergeOrder) ? content.mergeOrder.length : undefined;
+    const mergeOrderPreview = Array.isArray(content.mergeOrder)
+        ? content.mergeOrder.slice(0, 5).join(', ')
+        : undefined;
+    const warnings = Array.isArray(content.warnings) ? content.warnings.length : undefined;
+    return {
+        content: [
+            {
+                type: 'text',
+                text: formatKeyValue({
+                    passed: content.passed,
+                    conflicts,
+                    mergeOrder,
+                    mergeOrderPreview,
+                    warnings,
+                    summary: content.summary,
+                }) + '\nVerification commands: pnpm typecheck; pnpm lint; pnpm test',
+            },
+        ],
+        structuredContent: content,
+    };
 }
 function err(message) {
     return { content: [{ type: 'text', text: message }], isError: true };