@planu/cli 4.11.9 → 4.12.2

package/dist/tools/init-project/conventions-writer.js

@@ -25,7 +25,7 @@ function buildConventionsContent(knowledge) {
     }
     lines.push('', '## Naming Conventions', '', '- Variables/functions: `camelCase`', '- Types/interfaces: `PascalCase`', '- Files: `kebab-case`', '- Constants: `SCREAMING_SNAKE_CASE`', '', '## File Structure', '');
     if (knowledge.projectPath) {
-        lines.push(`- Project root: \`${knowledge.projectPath}\``);
+        lines.push('- Project root: repository root (`.`)');
     }
     lines.push('- Source: `src/`', '- Tests: `tests/` (mirrors `src/` structure)', '- Specs: `planu/specs/`', '', '## Code Style', '', '- Prefer explicit return types on all functions', '- No magic numbers — use named constants', '- Error handling: return `ToolResult` with `isError: true`, never throw from handlers', '', '## Spec Conventions', '', '- One spec per feature/bugfix', '- ACs must be testable: GIVEN/WHEN/THEN or measurable condition', '- spec.md always in English', '- Technical planning belongs in `spec.md` under `## Technical`; do not create `technical.md`');
     return lines.join('\n') + '\n';

package/dist/tools/init-project/scaffold-writer.js

@@ -353,7 +353,7 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
             // Read the canonical template from src/config/hook-templates/
             const templatePath = joinFn(
             // Resolve relative to this file's compiled location in dist/ or src/
-            homedir(), '.claude', 'projects', '-Users-kevin-Documents-desarrollo-sdd-mcp-server');
+            homedir(), '.claude', 'projects', '-Users-maintainer-Documents-desarrollo-sdd-mcp-server');
             void templatePath; // unused — we read from a fixed relative location
             // Read template from its canonical src/ location
             const { fileURLToPath } = await import('node:url');

package/dist/tools/safe-handler.d.ts

@@ -11,6 +11,10 @@ export declare function isProjectInitialized(projectPath: string): boolean;
  * tool calls reflect the new state.
  */
 export declare function markProjectInitialized(projectPath: string): void;
+/** Signal for the currently executing tool, including server deadline and client cancellation. */
+export declare function getToolExecutionSignal(): AbortSignal | undefined;
+/** Abort every in-flight tool before stdio shutdown closes the transport. */
+export declare function abortActiveToolExecutions(reason?: string): void;
 /**
  * Races a promise against a hard deadline, resolving with `fallback` on timeout.
  * Unlike withTimeout (which rejects), this always resolves — safe for non-critical gates
@@ -24,7 +28,7 @@ export declare function withToolTimeout<T>(p: Promise<T>, ms: number, fallback:
 /**
  * Wraps a tool handler so that any unhandled error is caught and returned as a
  * graceful MCP error response, preventing server crashes. Also enforces a
- * configurable execution timeout (default 60s, env PLANU_TOOL_TIMEOUT_MS).
+ * configurable execution timeout (default 55s, env PLANU_TOOL_TIMEOUT_MS).
  *
  * Usage — only for alwaysAllowed tools (activate_license, license_status, etc.):
  *   server.registerTool('my_tool', schema, safe(async (args) => { ... }));

package/dist/tools/safe-handler.js

@@ -26,6 +26,7 @@ import { checkBudgetEnforcement } from '../engine/cost-guardrails.js';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { maybeWriteCheckpoint } from '../engine/session/checkpoint-writer.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
 // SPEC-922: Compact response auto-on
 import { parseContextHeader } from '../engine/compact/header-parser.js';
 import { evaluateCompactMode } from '../engine/compact/threshold-evaluator.js';
@@ -137,16 +138,19 @@ function injectDriftBanner(result, banner) {
  * Checks `projectPath` and `path` fields for directory traversal attacks.
  * Also triggers lazy auto-start for hooks and workers when a projectPath is present.
  */
-function sanitizeArgs(args) {
+function sanitizeArgs(args, toolName) {
     if (args === null || typeof args !== 'object') {
         return args;
     }
     const obj = { ...args };
     if (typeof obj.projectPath === 'string') {
         obj.projectPath = sanitizePath(obj.projectPath);
-        // Auto-start hooks + workers on first tool call with projectPath (fire-and-forget)
-        ensureHooksStarted(obj.projectPath);
-        ensureWorkersStarted(obj.projectPath);
+        // planu_status is a read-only snapshot. Starting background services here made
+        // its latency depend on repository size and violated the MCP readOnlyHint.
+        if (toolName !== 'planu_status') {
+            ensureHooksStarted(obj.projectPath);
+            ensureWorkersStarted(obj.projectPath);
+        }
         // Read-only check: track whether planu.json exists (no file writes)
         ensureProjectKnown(obj.projectPath);
     }
@@ -161,8 +165,20 @@ function sanitizeArgs(args) {
     }
     return obj;
 }
-/** Default timeout: 60 seconds. Override via PLANU_TOOL_TIMEOUT_MS env var. */
-const DEFAULT_TIMEOUT_MS = 60_000;
+/** Keep the server deadline below the common 60s client deadline. */
+const DEFAULT_TIMEOUT_MS = 55_000;
+const toolAbortContext = new AsyncLocalStorage();
+const activeToolControllers = new Set();
+/** Signal for the currently executing tool, including server deadline and client cancellation. */
+export function getToolExecutionSignal() {
+    return toolAbortContext.getStore();
+}
+/** Abort every in-flight tool before stdio shutdown closes the transport. */
+export function abortActiveToolExecutions(reason = 'MCP transport closed') {
+    for (const controller of activeToolControllers) {
+        controller.abort(new Error(reason));
+    }
+}
 /**
  * Session ID generated once per process startup.
  * Used to group all tool calls from a single MCP session in the token ledger.
@@ -180,18 +196,55 @@ function getTimeoutMs() {
  * Races a handler promise against a timeout. Returns a timeout error ToolResult
  * if the handler exceeds the configured duration.
  */
-async function withTimeout(fn, ms) {
+async function withTimeout(fn, ms, upstreamSignal) {
     let timer;
+    const controller = new AbortController();
+    activeToolControllers.add(controller);
+    const abortFromUpstream = () => {
+        controller.abort(upstreamSignal?.reason ?? new Error('Tool request aborted'));
+    };
+    if (upstreamSignal?.aborted === true) {
+        abortFromUpstream();
+    }
+    else {
+        upstreamSignal?.addEventListener('abort', abortFromUpstream, { once: true });
+    }
     const timeoutPromise = new Promise((_resolve, reject) => {
         timer = setTimeout(() => {
-            reject(new Error(`Tool execution timed out after ${ms}ms`));
+            const error = new Error(`Tool execution timed out after ${ms}ms`);
+            controller.abort(error);
+            reject(error);
         }, ms);
     });
+    const abortPromise = new Promise((_resolve, reject) => {
+        const rejectAbort = () => {
+            const reason = controller.signal.reason;
+            const error = reason instanceof Error
+                ? reason
+                : new Error(typeof reason === 'string' ? reason : 'Tool request aborted');
+            reject(error);
+        };
+        if (controller.signal.aborted) {
+            rejectAbort();
+        }
+        else {
+            controller.signal.addEventListener('abort', rejectAbort, { once: true });
+        }
+    });
+    const handlerPromise = toolAbortContext.run(controller.signal, () => fn(controller.signal));
     try {
-        return await Promise.race([fn(), timeoutPromise]);
+        return await Promise.race([handlerPromise, timeoutPromise, abortPromise]);
+    }
+    catch (error) {
+        if (controller.signal.aborted) {
+            await handlerPromise.then(() => undefined, () => undefined);
+        }
+        throw error;
     }
     finally {
         clearTimeout(timer);
+        upstreamSignal?.removeEventListener('abort', abortFromUpstream);
+        activeToolControllers.delete(controller);
     }
 }
 /**
@@ -220,7 +273,7 @@ export function withToolTimeout(p, ms, fallback) {
 /**
  * Wraps a tool handler so that any unhandled error is caught and returned as a
  * graceful MCP error response, preventing server crashes. Also enforces a
- * configurable execution timeout (default 60s, env PLANU_TOOL_TIMEOUT_MS).
+ * configurable execution timeout (default 55s, env PLANU_TOOL_TIMEOUT_MS).
  *
  * Usage — only for alwaysAllowed tools (activate_license, license_status, etc.):
  *   server.registerTool('my_tool', schema, safe(async (args) => { ... }));
@@ -234,7 +287,7 @@ export function safe(handler) {
  */
 function safeWithTelemetry(toolName, handler) {
     return async (args, extra) => {
-        const safeArgs = sanitizeArgs(args);
+        const safeArgs = sanitizeArgs(args, toolName);
         const projectPath = safeArgs !== null && typeof safeArgs === 'object'
             ? safeArgs.projectPath
             : undefined;
@@ -259,7 +312,15 @@ function safeWithTelemetry(toolName, handler) {
             recordVerboseDecision();
         }
         try {
-            const rawResult = (await withTimeout(() => handler(safeArgs, extra), getTimeoutMs()));
+            const upstreamSignal = extra &&
+                typeof extra === 'object' &&
+                extra.signal instanceof AbortSignal
+                ? extra.signal
+                : undefined;
+            const rawResult = (await withTimeout((signal) => handler(safeArgs, {
+                ...(extra && typeof extra === 'object' ? extra : {}),
+                signal,
+            }), getTimeoutMs(), upstreamSignal));
             // Defensive guard: belt-and-suspenders alongside withUsageTracking guard and noImplicitReturns.
             const result = rawResult ?? {
                 content: [{ type: 'text', text: 'Internal error: tool handler returned no result' }],

package/dist/tools/status-handler.d.ts

@@ -1,3 +1,3 @@
 import type { ToolResult, PlanStatusInput } from '../types/index.js';
-export declare function handlePlanStatus(args: PlanStatusInput): Promise<ToolResult>;
+export declare function handlePlanStatus(args: PlanStatusInput, signal?: AbortSignal | undefined): Promise<ToolResult>;
 //# sourceMappingURL=status-handler.d.ts.map

package/dist/tools/status-handler.js

@@ -1,14 +1,11 @@
 import { listSpecs } from '../storage/spec-store.js';
 import { getKnowledge } from '../storage/knowledge-store/knowledge.js';
-// SPEC-1011 Bug F: fallback resolver using disk fingerprints
-import { resolveProjectFromPath } from '../storage/project-resolver.js';
 import { hashProjectPath, readJson } from '../storage/base-store.js';
 import { execFile as execFileCb } from 'node:child_process';
 import { promisify } from 'node:util';
 import { join } from 'node:path';
 import { readFile } from 'node:fs/promises';
 import { shouldSuggestBtw, buildBtwHint } from '../engine/context-advisor/btw-advisor.js';
-import { autoCompleteSpecs } from './git/auto-complete-ops.js';
 import { computeSessionAgeMinutes } from '../engine/session-handoff-generator.js';
 import { loadSessionState } from '../storage/session-state-store.js';
 import { consumeUpdateBanner } from '../engine/update-notifier.js';
@@ -16,21 +13,32 @@ import { getPolicy, getRecords } from '../storage/approval-store.js';
 import { calculateSLAStatus } from '../engine/approval-workflow.js';
 import { readPlanuConfig } from '../engine/planu-config-writer.js';
 import { computePlanuDriftScore } from '../engine/dashboard/drift-score.js';
-import { findStaleBranches, findStaleWorktrees, findStaleStashes, } from '../engine/housekeeping/index.js';
 import { loadTokenWastePolicy } from '../engine/token-optimizer/index.js';
 import { getProjectGraphFreshnessHint } from '../engine/project-graph/index.js';
-// SPEC-1011 Bug G: fire-and-forget status.json reconciliation
-import { reconcileStatusFromDisk } from '../engine/status-reconciler/index.js';
+import { getToolExecutionSignal } from './safe-handler.js';
 const execFile = promisify(execFileCb);
+const STATUS_READ_TIMEOUT_MS = 1_500;
 // ---------------------------------------------------------------------------
 // Git helpers
 // ---------------------------------------------------------------------------
-async function getGitState(projectPath) {
+async function getGitState(projectPath, signal) {
     try {
         const [stagedResult, modifiedResult, branchResult] = await Promise.all([
-            execFile('git', ['diff', '--cached', '--name-only'], { cwd: projectPath }),
-            execFile('git', ['diff', '--name-only'], { cwd: projectPath }),
-            execFile('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: projectPath }),
+            execFile('git', ['diff', '--cached', '--name-only'], {
+                cwd: projectPath,
+                timeout: STATUS_READ_TIMEOUT_MS,
+                signal,
+            }),
+            execFile('git', ['diff', '--name-only'], {
+                cwd: projectPath,
+                timeout: STATUS_READ_TIMEOUT_MS,
+                signal,
+            }),
+            execFile('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+                cwd: projectPath,
+                timeout: STATUS_READ_TIMEOUT_MS,
+                signal,
+            }),
         ]);
         const staged = countGitPathLines(stagedResult.stdout);
         const modified = countGitPathLines(modifiedResult.stdout);
@@ -183,18 +191,13 @@ function buildOutput(params) {
 // ---------------------------------------------------------------------------
 // Public handler
 // ---------------------------------------------------------------------------
-export async function handlePlanStatus(args) {
+export async function handlePlanStatus(args, signal = getToolExecutionSignal()) {
+    signal?.throwIfAborted();
     const projectId = args.projectId ?? hashProjectPath(args.projectPath);
     const planuConfigPath = join(args.projectPath, 'planu.json');
-    // SPEC-1011 Bug F: Use resilient resolver that falls back to disk fingerprints.
-    // If knowledge.json is missing but planu/ or data/projects/{id}/ exist, the project
-    // is recovered silently and a minimal knowledge entry is written.
-    // Skip the resolver fallback when projectId is explicitly provided — caller already
-    // knows the project; resolver would compute hash redundantly and break test contracts.
-    let knowledgeExists = (await getKnowledge(projectId)) !== null;
-    if (!knowledgeExists && args.projectId === undefined) {
-        knowledgeExists = (await resolveProjectFromPath(args.projectPath)) !== null;
-    }
+    // Status is strictly read-only. Missing knowledge is repaired by startupSync/init_project,
+    // never as a side effect of reading the status snapshot.
+    const knowledgeExists = (await getKnowledge(projectId)) !== null;
     if (!knowledgeExists) {
         return {
             content: [
@@ -206,59 +209,21 @@ export async function handlePlanStatus(args) {
             isError: true,
         };
     }
-    // SPEC-1011 Bug G: reconcile status.json with disk reality (fire-and-forget, non-blocking).
-    // Skip when projectId is explicitly provided to preserve callers' contract that projectPath
-    // is not re-hashed; the reconciler is best-effort observability and not load-bearing here.
-    if (args.projectId === undefined) {
-        void reconcileStatusFromDisk(args.projectPath, projectId).catch(() => {
-            /* best-effort */
-        });
-    }
-    const [snapshot, git, ci, slaBreaches, planuConfig, autoCompleted, sessionState, driftScore, pendingCleanup, tokenWastePolicy, graphFreshnessHint,] = await Promise.all([
+    const [snapshot, git, ci, slaBreaches, planuConfig, sessionState, driftScore, tokenWastePolicy, graphFreshnessHint,] = await Promise.all([
         getStatusSpecSnapshot(projectId),
-        getGitState(args.projectPath),
+        getGitState(args.projectPath, signal),
         getCiState(args.projectPath),
         getSLABreaches(projectId),
         readPlanuConfig(planuConfigPath, readFile),
-        // SPEC-720: autoCompleteSpecs now returns {completed, blocked} — extract completed for display
-        autoCompleteSpecs(projectId, args.projectPath)
-            .then((r) => r.completed)
-            .catch(() => []),
         loadSessionState(args.projectPath).catch(() => null),
         // SPEC-748: compute drift score from pending.json drift_review entries vs done specs
         computePlanuDriftScore(args.projectPath).catch(() => null),
-        // SPEC-751: pending cleanup counters
-        (async () => {
-            try {
-                const [branchResult, worktrees, stashes] = await Promise.all([
-                    findStaleBranches({ projectPath: args.projectPath }),
-                    findStaleWorktrees({ projectPath: args.projectPath }),
-                    findStaleStashes({ projectPath: args.projectPath }),
-                ]);
-                return {
-                    branches: branchResult.stale.length,
-                    worktrees: worktrees.length,
-                    stashes: stashes.length,
-                };
-            }
-            catch {
-                return { branches: 0, worktrees: 0, stashes: 0 };
-            }
-        })(),
         loadTokenWastePolicy(args.projectPath)
             .then((loaded) => loaded.policy)
             .catch(() => null),
         getProjectGraphFreshnessHint({ projectId, projectPath: args.projectPath }).catch(() => undefined),
     ]);
-    // SPEC-1012: Detect stale release status (best-effort, non-blocking)
-    let staleStatusWarnings = [];
-    try {
-        const { detectReleaseStatusDrift } = await import('../engine/drift-detection/release-status-drift.js');
-        staleStatusWarnings = await detectReleaseStatusDrift(args.projectPath);
-    }
-    catch {
-        /* best-effort — never block planu_status */
-    }
+    signal?.throwIfAborted();
     const sessionAgeMinutes = sessionState !== null ? computeSessionAgeMinutes(sessionState.savedAt) : null;
     const SESSION_TIP_THRESHOLD_MIN = 60;
     const sessionTip = sessionAgeMinutes !== null && sessionAgeMinutes > SESSION_TIP_THRESHOLD_MIN
@@ -279,7 +244,6 @@ export async function handlePlanStatus(args) {
         slaBreaches,
         workMode,
         updateBanner,
-        autoCompleted,
         sessionTip,
         tokenWasteHint,
         graphFreshnessHint,
@@ -304,7 +268,6 @@ export async function handlePlanStatus(args) {
             // SPEC-748: drift score
             planu_drift_score: driftScore?.score ?? 0,
             lastAuditAt: driftScore?.lastAuditAt ?? null,
-            ...(autoCompleted.length > 0 ? { autoCompleted } : {}),
             ...(sessionTip !== undefined ? { sessionTip } : {}),
             ...(tokenWasteHint !== undefined ? { tokenWasteHint } : {}),
             ...(graphFreshnessHint !== undefined ? { graphFreshnessHint } : {}),
@@ -316,9 +279,7 @@ export async function handlePlanStatus(args) {
                 : {}),
             ...(updateBanner !== undefined ? { update_banner: updateBanner } : {}),
             // SPEC-751: pending cleanup counters
-            pending_cleanup: pendingCleanup,
-            // SPEC-1012: stale status warnings (released but not done)
-            ...(staleStatusWarnings.length > 0 ? { staleStatusWarnings } : {}),
+            pending_cleanup: { branches: 0, worktrees: 0, stashes: 0 },
         },
     };
 }

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

@@ -5,12 +5,11 @@ import { addLesson, getLessons } from '../../storage/lessons-store.js';
 import { dispatchFeedbackEvent } from '../learn.js';
 import { auditDeps } from '../../engine/dep-auditor/index.js';
 import { getComplianceGateConfig } from '../../storage/compliance-gate-config-store.js';
-import { readJson, writeJson, projectDataDir } from '../../storage/base-store.js';
-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';
+import { recordForceDoneBypass } from './force-done-audit.js';
 /**
  * SPEC-721 / SPEC-222 Trigger 1: Run validate engine before marking done.
  *
@@ -28,7 +27,6 @@ import { formatKeyValue } from '../output-formatter.js';
  * @param budgetMs        Max milliseconds to wait for validate. Default: 9000.
  */
 export async function runValidateGate(spec, projectPath, forceStatus, forceStatusReason, budgetMs = 9_000, reviewContext) {
-    // ---- Path A: explicit force bypass ----------------------------------------
     if (forceStatus) {
         if (!forceStatusReason || forceStatusReason.trim().length < 100) {
             return {
@@ -63,7 +61,12 @@ export async function runValidateGate(spec, projectPath, forceStatus, forceStatu
             scoreSource: 'forced-best-effort-validateSpec',
         };
     }
-    // ---- Normal path — fail-CLOSED --------------------------------------------
+    if (reviewContext) {
+        const report = await readApprovedValidationReportGate(reviewContext.specId, reviewContext.projectId, false);
+        if (report.ok && report.score === 100) {
+            return { blocked: false, score: 100, forced: false };
+        }
+    }
     const TIMEOUT_SENTINEL = Symbol('timeout');
     let validateResult;
     try {
@@ -247,33 +250,6 @@ export async function checkSecurityGate(projectPath, specId, force) {
         return null;
     }
 }
-function forceDoneBypassLogPath(projectId) {
-    return `${projectDataDir(projectId)}/force-bypass-log.json`;
-}
-/**
- * Writes an audit record when force=true bypasses DoD gates on 'done' transition.
- * Never throws — audit failures must not block transitions.
- */
-async function recordForceDoneBypass(specId, projectId, reason, failingItems, warningItems) {
-    try {
-        const logPath = forceDoneBypassLogPath(projectId);
-        const entries = await readJson(logPath, []);
-        entries.push({
-            id: randomUUID(),
-            timestamp: new Date().toISOString(),
-            action: 'force_done_bypass',
-            specId,
-            projectId,
-            reason,
-            failingItems,
-            warningItems,
-        });
-        await writeJson(logPath, entries);
-    }
-    catch {
-        /* best-effort — never block transition due to audit failures */
-    }
-}
 /**
  * SPEC-725: Check the validation-report artifact gate before marking done.
  * SPEC-1050: Fail closed. A done transition requires a fresh validation-report

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

@@ -5,7 +5,7 @@ import { readEvidenceArtifacts } from '../../engine/evidence-gates/artifact-read
 import { checkLifecycleEvidenceGate } from '../../engine/evidence-gates/lifecycle-gate.js';
 import { buildSpecEvidenceIndex } from '../../engine/evidence-index/index-builder.js';
 import { checkDoneDriftContract } from '../../engine/evidence-index/done-drift.js';
-import { parseTechnicalReferenceGroundingRecords } from '../../engine/spec-grounding/contract.js';
+import { parseGroundedTechnicalPaths } 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. */
@@ -33,9 +33,7 @@ export async function checkLifecycleEvidenceTransitionGate(args) {
             artifacts,
             projectPath: args.projectPath,
         });
-        const groundedTechnicalPaths = body
-            ? parseTechnicalReferenceGroundingRecords(body).map((record) => record.path)
-            : [];
+        const groundedTechnicalPaths = body ? parseGroundedTechnicalPaths(body) : [];
         result.issues.push(...checkDoneDriftContract({ index, groundedTechnicalPaths }));
     }
     if (result.issues.length === 0) {

package/dist/tools/update-status/force-done-audit.d.ts

@@ -0,0 +1,2 @@
+export declare function recordForceDoneBypass(specId: string, projectId: string, reason: string, failingItems: string[], warningItems: string[]): Promise<void>;
+//# sourceMappingURL=force-done-audit.d.ts.map

package/dist/tools/update-status/force-done-audit.js

@@ -0,0 +1,23 @@
+import { randomUUID } from 'node:crypto';
+import { projectDataDir, readJson, writeJson } from '../../storage/base-store.js';
+export async function recordForceDoneBypass(specId, projectId, reason, failingItems, warningItems) {
+    try {
+        const logPath = `${projectDataDir(projectId)}/force-bypass-log.json`;
+        const entries = await readJson(logPath, []);
+        entries.push({
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            action: 'force_done_bypass',
+            specId,
+            projectId,
+            reason,
+            failingItems,
+            warningItems,
+        });
+        await writeJson(logPath, entries);
+    }
+    catch {
+        // Best effort: audit storage failure must not hide the original gate result.
+    }
+}
+//# sourceMappingURL=force-done-audit.js.map

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

@@ -1,4 +1,5 @@
 import type { ToolResult } from '../../types/index.js';
 import type { Spec } from '../../types/spec/core.js';
+/** SPEC-642 / SPEC-1111 / SPEC-1144: verify canonical 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

@@ -1,36 +1,15 @@
-/** SPEC-642 / SPEC-1111: verify and persist local QA evidence before done. */
-const QA_GATE_TTL_MS = 15 * 60 * 1000;
+import { getToolExecutionSignal } from '../safe-handler.js';
+/** SPEC-642 / SPEC-1111 / SPEC-1144: verify canonical 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 { computeQaGateFingerprint, runQaGate } = await import('../../engine/qa-gate.js');
-    const fingerprint = computeQaGateFingerprint(spec, projectPath);
-    const state = await getGateState(projectPath, specId).catch(() => null);
-    const ranAtMs = state?.lastResult?.ranAt ? Date.parse(state.lastResult.ranAt) : NaN;
-    const freshEnough = Number.isFinite(ranAtMs) && Date.now() - ranAtMs <= QA_GATE_TTL_MS;
-    if (state?.lastResult?.passed === true &&
-        state.lastResult.fingerprint === fingerprint &&
-        freshEnough) {
-        return null;
-    }
-    if (await hasPassedExternalQaEvidence(spec, projectPath)) {
-        return null;
-    }
-    let effectiveResult = state?.lastResult ?? null;
-    const canReuseLocalQa = effectiveResult !== null &&
-        effectiveResult.fingerprint === fingerprint &&
-        freshEnough &&
-        effectiveResult.passed;
-    if (!canReuseLocalQa) {
-        effectiveResult = await runQaGate(spec, projectPath);
-        await saveGateState(projectPath, specId, effectiveResult);
-    }
-    if (effectiveResult === null) {
-        return null;
-    }
+    const { runQaGate } = await import('../../engine/qa-gate.js');
+    const effectiveResult = await runQaGate(spec, projectPath, {
+        projectId: spec.projectId,
+        signal: getToolExecutionSignal(),
+    });
     if (effectiveResult.passed) {
         return null;
     }
@@ -63,27 +42,4 @@ export async function checkQaGate(spec, projectPath, force) {
         },
     };
 }
-async function hasPassedExternalQaEvidence(spec, projectPath) {
-    try {
-        const { readEvidenceArtifacts } = await import('../../engine/evidence-gates/artifact-reader.js');
-        const artifacts = await readEvidenceArtifacts({
-            spec,
-            projectId: spec.projectId,
-            specId: spec.id,
-            projectPath,
-        });
-        const rows = artifacts.traceabilityMatrix?.rows ?? [];
-        return rows.length > 0 && rows.every((row) => isPassedQaEvidence(row.validationEvidence));
-    }
-    catch {
-        return false;
-    }
-}
-function isPassedQaEvidence(value) {
-    if (!value) {
-        return false;
-    }
-    return (/\b(?:pnpm\s+validate|pnpm\s+test|pnpm\s+typecheck)\b[\s\S]{0,120}\bpass(?:ed|ing)?\b/i.test(value) ||
-        /\bpass(?:ed|ing)?\b[\s\S]{0,120}\b(?:pnpm\s+validate|pnpm\s+test|pnpm\s+typecheck)\b/i.test(value));
-}
 //# sourceMappingURL=qa-gate.js.map