@planu/cli 4.10.5 → 4.10.6

package/dist/tools/package-handoff.js

@@ -3,7 +3,7 @@ import { specStore, knowledgeStore } from '../storage/index.js';
 import { checkSpecReadiness } from '../engine/readiness-checker.js';
 import { packageHandoff } from '../engine/handoff-packager.js';
 import { detectParadigms } from '../engine/paradigm-detector.js';
-import { analyzeContextPreflight, buildTokenWasteReport, formatTokenWasteReport, loadTokenWastePolicy, recommendRelevantTools, toolsFromPolicyGroups, } from '../engine/token-optimizer/index.js';
+import { analyzeContextPreflight, buildTokenWasteReport, loadTokenWastePolicy, recommendRelevantTools, toolsFromPolicyGroups, } from '../engine/token-optimizer/index.js';
 import { appendTransitionEvent } from '../storage/transition-log.js';
 import { formatProjectGraphContext, queryProjectGraphSlice, } from '../engine/project-graph/index.js';
 import { analyzeMinimalImplementation, loadMinimalImplementationPolicy, } from '../engine/minimality/index.js';
@@ -137,6 +137,98 @@ function formatHandoff(pkg) {
     }
     return lines.join('\n');
 }
+function topItems(items, limit) {
+    return items.slice(0, limit);
+}
+function buildHandoffSummaryText(args) {
+    const lines = [];
+    lines.push(`# Implementation Handoff Package - ${args.pkg.specId}`);
+    lines.push('');
+    lines.push(`Readiness Score: ${String(args.pkg.readinessScore)}/100`);
+    lines.push(`Blocked: ${args.pkg.blocked ? 'yes' : 'no'}`);
+    if (args.pkg.handoffPath) {
+        lines.push(`Handoff Path: ${args.pkg.handoffPath}`);
+    }
+    if (args.pkg.contextHash) {
+        lines.push(`Context Hash: ${args.pkg.contextHash}`);
+    }
+    lines.push(`Counts: ${String(args.pkg.criteria.length)} criteria, ${String(args.pkg.filesToModify.length)} files to modify, ${String(args.pkg.filesToCreate.length)} files to create, ${String(args.pkg.testPlan.length)} tests, ${String(args.pkg.risks.length)} risks.`);
+    if (args.topBlockers.length > 0) {
+        lines.push(`Top blockers: ${args.topBlockers.join('; ')}`);
+    }
+    if (args.topRisks.length > 0) {
+        lines.push(`Top risks: ${args.topRisks.join('; ')}`);
+    }
+    if (args.minimalityBlocked !== null) {
+        lines.push(`Minimality: ${args.minimalityBlocked ? 'blocked' : 'pass'}`);
+    }
+    if (args.tokenWasteRiskCount !== null) {
+        lines.push(`Token Waste Autopilot risks: ${String(args.tokenWasteRiskCount)}`);
+    }
+    lines.push(`Next Action: ${args.pkg.nextAction}`);
+    lines.push('');
+    lines.push('Full handoff is available via the handoffPath artifact; it is not embedded by default.');
+    return lines.join('\n');
+}
+function summarizeMinimality(report) {
+    if (report === null) {
+        return undefined;
+    }
+    const blockingFindings = report.findings.filter((finding) => finding.blocksDone);
+    return {
+        enabled: report.enabled,
+        blocked: report.blocked,
+        findingCount: report.findings.length,
+        blockingFindingCount: blockingFindings.length,
+        blockersTop3: topItems(blockingFindings, 3).map((finding) => ({
+            ruleId: finding.ruleId,
+            target: finding.target,
+            evidence: finding.evidence,
+        })),
+        safetyExceptionCount: report.safetyExceptions.length,
+        debtEvidenceCount: report.debtEvidence.length,
+    };
+}
+function summarizeTokenWaste(report) {
+    if (report === null) {
+        return undefined;
+    }
+    return {
+        actionsTakenCount: report.actionsTaken.length,
+        recommendationCount: report.recommendations.length,
+        riskCount: report.risks.length,
+        risksTop3: topItems(report.risks, 3).map((risk) => ({
+            decision: risk.decision,
+            target: risk.target,
+            reason: risk.reason,
+            confidence: risk.confidence,
+        })),
+        modelEffort: {
+            effort: report.modelEffort.effort,
+            reason: report.modelEffort.reason,
+        },
+    };
+}
+function summarizeGraphContext(graphContext) {
+    if (graphContext === null || typeof graphContext !== 'object') {
+        return { available: false };
+    }
+    const graph = graphContext;
+    return {
+        available: true,
+        nodeCount: Array.isArray(graph.nodes) ? graph.nodes.length : 0,
+        edgeCount: Array.isArray(graph.edges) ? graph.edges.length : 0,
+        summary: graph.summary,
+        tokenSavings: graph.tokenSavings,
+        freshness: graph.freshness
+            ? {
+                graphPath: graph.freshness.graphPath,
+                stale: graph.freshness.stale,
+                reason: graph.freshness.reason,
+            }
+            : undefined,
+    };
+}
 async function buildHandoffTokenWasteReport(pkg, knowledge, spec) {
     try {
         const { policy } = await loadTokenWastePolicy(knowledge.projectPath);
@@ -277,12 +369,6 @@ export async function handlePackageHandoff(args) {
         ? `${formatHandoff(pkgWithScore)}\n${graphContext.text}`
         : formatHandoff(pkgWithScore);
     const minimalityReport = await buildMinimalImplementationReport(pkgWithScore, knowledge, spec, baseHandoffText);
-    const handoffText = minimalityReport !== null && minimalityReport.markdown.length > 0
-        ? `${baseHandoffText}\n${minimalityReport.markdown}`
-        : baseHandoffText;
-    const formatted = tokenWasteReport !== null
-        ? `${handoffText}\n${formatTokenWasteReport(tokenWasteReport)}`
-        : handoffText;
     void appendTransitionEvent({
         projectId,
         specId,
@@ -296,16 +382,54 @@ export async function handlePackageHandoff(args) {
     }).catch(() => {
         /* best-effort — handoff rendering should not fail because telemetry failed */
     });
+    const topBlockers = topItems(pkgWithScore.blockers, 3);
+    const topRisks = topItems(pkgWithScore.risks, 5);
+    const minimalitySummary = summarizeMinimality(minimalityReport);
+    const tokenWasteSummary = summarizeTokenWaste(tokenWasteReport);
+    const graphSummary = graphContext !== null ? summarizeGraphContext(graphContext.structured) : undefined;
     return {
-        content: [{ type: 'text', text: formatted }],
+        content: [
+            {
+                type: 'text',
+                text: buildHandoffSummaryText({
+                    pkg: pkgWithScore,
+                    topBlockers,
+                    topRisks,
+                    minimalityBlocked: minimalityReport?.blocked ?? null,
+                    tokenWasteRiskCount: tokenWasteReport?.risks.length ?? null,
+                }),
+            },
+        ],
         structuredContent: {
+            specId,
             blocked: pkgWithScore.blocked,
-            blockers: pkgWithScore.blockers,
+            readinessScore: pkgWithScore.readinessScore,
+            blockersCount: pkgWithScore.blockers.length,
+            blockersTop3: topBlockers,
+            risksTop5: topRisks,
+            criteriaTop5: topItems(pkgWithScore.criteria, 5),
+            constraintsTop5: topItems(pkgWithScore.constraints, 5),
+            warningsTop5: topItems(pkgWithScore.warnings, 5),
             handoffPath: pkgWithScore.handoffPath,
             contextHash: pkgWithScore.contextHash,
-            ...(minimalityReport !== null ? { minimality: minimalityReport } : {}),
-            ...(tokenWasteReport !== null ? { tokenWaste: tokenWasteReport } : {}),
-            ...(graphContext !== null ? { graphContext: graphContext.structured } : {}),
+            artifactRefs: {
+                handoff: pkgWithScore.handoffPath,
+            },
+            counts: {
+                criteria: pkgWithScore.criteria.length,
+                filesToModify: pkgWithScore.filesToModify.length,
+                filesToCreate: pkgWithScore.filesToCreate.length,
+                ownership: pkgWithScore.ownership.length,
+                testPlan: pkgWithScore.testPlan.length,
+                risks: pkgWithScore.risks.length,
+                constraints: pkgWithScore.constraints.length,
+                warnings: pkgWithScore.warnings.length,
+                outOfScope: pkgWithScore.outOfScope.length,
+            },
+            nextAction: pkgWithScore.nextAction,
+            ...(minimalitySummary !== undefined ? { minimality: minimalitySummary } : {}),
+            ...(tokenWasteSummary !== undefined ? { tokenWaste: tokenWasteSummary } : {}),
+            ...(graphSummary !== undefined ? { graphContext: graphSummary } : {}),
         },
     };
 }

package/dist/tools/status-handler.js

@@ -308,7 +308,12 @@ export async function handlePlanStatus(args) {
             ...(sessionTip !== undefined ? { sessionTip } : {}),
             ...(tokenWasteHint !== undefined ? { tokenWasteHint } : {}),
             ...(graphFreshnessHint !== undefined ? { graphFreshnessHint } : {}),
-            ...(btwHint !== undefined ? { btw_hint: btwHint } : {}),
+            ...(btwHint !== undefined
+                ? {
+                    btwHintAvailable: true,
+                    btwHintReason: 'Use /btw for side questions when the current implementation context is large.',
+                }
+                : {}),
             ...(updateBanner !== undefined ? { update_banner: updateBanner } : {}),
             // SPEC-751: pending cleanup counters
             pending_cleanup: pendingCleanup,

package/dist/tools/token-recording.d.ts

@@ -5,12 +5,13 @@
 export declare function recordToolTokens(toolName: string, projectPath: string, inputArgs: unknown, outputText: string, sessionId: string): void;
 /**
  * Extract output text from a ToolResult for token counting.
- * Concatenates all text content items into a single string.
+ * Concatenates visible text and compacted structuredContent into a single string.
  */
 export declare function extractOutputText(result: {
     content: {
         type: string;
         text?: string;
     }[];
+    structuredContent?: Record<string, unknown>;
 }): string;
 //# sourceMappingURL=token-recording.d.ts.map

package/dist/tools/token-recording.js

@@ -4,6 +4,20 @@ import { join } from 'node:path';
 import { countTokens, estimateCost } from '../engine/token-optimizer/counter.js';
 import { recordEntry } from '../storage/token-ledger-store.js';
 import { hashProjectPath } from '../storage/base-store.js';
+const SECRET_KEY_PATTERN = /(api[-_]?key|auth|bearer|credential|password|secret|token)/i;
+function stringifyForTokenCounting(value) {
+    try {
+        return JSON.stringify(value, (key, entryValue) => {
+            if (SECRET_KEY_PATTERN.test(key)) {
+                return '[redacted]';
+            }
+            return entryValue;
+        });
+    }
+    catch {
+        return '[unserializable structuredContent]';
+    }
+}
 /**
  * Record a tool call's token usage to the persistent ledger.
  * Always fire-and-forget — never throws, never blocks the response.
@@ -39,11 +53,16 @@ export function recordToolTokens(toolName, projectPath, inputArgs, outputText, s
 }
 /**
  * Extract output text from a ToolResult for token counting.
- * Concatenates all text content items into a single string.
+ * Concatenates visible text and compacted structuredContent into a single string.
  */
 export function extractOutputText(result) {
-    return result.content
+    const text = result.content
         .flatMap((item) => (item.type === 'text' && typeof item.text === 'string' ? [item.text] : []))
         .join('\n');
+    if (result.structuredContent === undefined) {
+        return text;
+    }
+    const structuredText = stringifyForTokenCounting(result.structuredContent);
+    return text.length > 0 ? `${text}\n${structuredText}` : structuredText;
 }
 //# sourceMappingURL=token-recording.js.map

package/dist/tools/update-status/dod-gates.d.ts

@@ -28,6 +28,7 @@ export type ValidateGateResult = {
     score: number | null;
     forced: true;
     forcedReason: string;
+    scoreSource: 'forced-best-effort-validateSpec';
 };
 /**
  * SPEC-721 / SPEC-222 Trigger 1: Run validate engine before marking done.
@@ -99,8 +100,7 @@ export interface ComplianceGateResult {
  * Never blocks the transition if the compliance engine is unavailable or fails.
  */
 export declare function checkComplianceGate(specId: string, projectId: string, projectPath: string | undefined): Promise<ComplianceGateResult>;
-/** SPEC-642: Block done if QA gate has not run and passed. */
-export declare function checkQaGate(specId: string, projectPath: string | undefined, force: boolean): Promise<ToolResult | null>;
+export { checkQaGate } from './qa-gate.js';
 /**
  * SPEC-716 / SPEC-780: Format gate for transition to 'approved'.
  *

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

@@ -54,7 +54,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');
@@ -512,33 +518,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'.
  *

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

@@ -466,7 +466,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 +503,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 +538,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 +1050,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-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)
 // ---------------------------------------------------------------------------