@planu/cli 4.13.0 → 5.0.0

package/dist/tools/create-spec.js

@@ -3,41 +3,42 @@ import { upsertToken, hashQuestions } from '../engine/clarification-gate/token-s
 import { ti } from '../i18n/index.js';
 import { knowledgeStore, specStore } from '../storage/index.js';
 import { readTechnologySelectionContract } from '../storage/technology-selection-store.js';
-import { formatSuccess, addNextSteps, toolResult, interactiveResult } from './response-helpers.js';
-import { writeFile, mkdir, rm, readFile, stat as fsStat, rename, link as hardLink, } from 'node:fs/promises';
+import { toolResult, interactiveResult } from './response-helpers.js';
+import { readFile, stat as fsStat } from 'node:fs/promises';
 import { createHash, randomUUID } from 'node:crypto';
 import { dirname as pathDirname, isAbsolute as pathIsAbsolute, join as pathJoin, relative as pathRelative, sep as pathSeparator, } from 'node:path';
-import { checkSpecReadiness } from '../engine/readiness-checker.js';
 import { buildSpecContext, buildSplitResult } from './create-spec/spec-builder.js';
 import { validateConstitution } from './create-spec/constitution-validator.js';
-import { setupGitBranch, checkContradictions, fireSpecCreatedHook, generatePostCreationSuggestions, formatPostCreationSuggestion, runAutopilotAsync, getAsyncAnalysisPath, } from './create-spec/post-creation.js';
-import { notifyStoreChange } from '../engine/doc-generator/portal/regen-hook.js';
-import { compactObj } from '../engine/compact-obj.js';
-import { runAutoPostCreatePipeline } from './create-spec/auto-pipeline.js';
+import { getAsyncAnalysisPath } from './create-spec/post-creation.js';
 import { extractCriteria, generateLeanSpecContent, } from '../engine/spec-format/lean-spec-generator.js';
 import { generateLeanTechnicalContent, } from '../engine/spec-format/lean-technical-generator.js';
 import { extractFilesFromSpecBody } from '../engine/spec-format/technical-md-populator.js';
-import { buildUnifiedSpecContent } from '../engine/spec-format/unified-spec-builder.js';
-import { appendImplementationContractIfMissing } from '../engine/implementation-contract/index.js';
+import { buildCanonicalUnifiedSpecContent, validateUnifiedSpecCandidate, } from '../engine/spec-format/unified-spec-builder.js';
+import { buildImplementationContractSection } from '../engine/implementation-contract/index.js';
 import { validateEnglishOnlySpecText } from '../engine/spec-language/english-only.js';
 import { FallbackGenerator } from '../engine/spec-generator/index.js';
 import { analyzeProjectForSpec, getEmptyAutopilotResult, } from './create-spec/autopilot-analyzer.js';
-import { AutopilotSummaryCollector } from '../engine/autopilot/summary-collector.js';
 import { trackCost } from '../engine/cost-tracking/operation-tracker.js';
 import { analyzeSimplicity } from '../engine/simplicity-detector.js';
 import { withBudget, unwrapBudget, withTotalBudget } from '../engine/timing/budget.js';
 import { measureStep } from '../engine/timing/structured-log.js';
 import { resolveProjectIdOrAutoDetect } from './resolve-project-id.js';
 import { hashProjectPath } from '../storage/base-store.js';
-import { findSimilarSpecs } from '../engine/spec-searcher.js';
-import { scoreSpecQuality } from '../engine/spec-quality-scorer.js';
-import { runPriorDecisionsHint } from './create-spec/adapters/prior-decisions-hint.js';
-import { adviseSimilarSpecs } from '../engine/complexity-budget/index.js';
 import { issuePlannerToken } from '../engine/reviewer-tokens/issuer.js';
+import { getRuntimePolicy } from '../engine/runtime-policy.js';
 import { generateInteractiveQuestions } from './create-spec/question-generator.js';
 import { buildCriterionGroundingRecords, filterGroundedCriteria, getAdvisoryCriteria, getContractCriteria, } from '../engine/spec-grounding/contract.js';
 import { checkGenericSpecOutput } from '../engine/spec-quality/generic-output-gate.js';
 import { calculateActionableSpecMetrics, shouldExposeMetric, } from '../engine/spec-metrics/actionable-metrics.js';
+import { RuntimeDatabase } from '../storage/runtime-db.js';
+import { BoundaryFailure } from '../errors/error-taxonomy.js';
+import { SpecAcFormatEnum, SpecScopeEnum, SpecTargetEnum, SpecTypeEnum } from './schemas/spec.js';
+import { SPEC_CREATED_POST_COMMIT_TASKS } from '../types/outbox-worker.js';
+import { resolveStorageLayout } from '../storage/storage-layout.js';
+import { OperationJournal, recoverOperationJournal, } from '../engine/execution/operation-journal.js';
+import { assertExecutionCanCommit } from '../engine/execution/context.js';
+import { cleanupExecutionArtifact, executionLink, executionMkdir, executionRemove, executionRename, executionWriteFileExclusive, } from '../engine/execution/deadline-io.js';
+import { atomicWriteFile } from '../engine/safety/atomic-write-file.js';
 /** SPEC-584: Persist a clarification token when interactive questions are emitted. Best-effort. */
 async function persistClarificationToken(earlyReturn, projectId, toolName) {
     try {
@@ -88,31 +89,13 @@ function handleClarification(_server, description, knowledge, autopilot, params)
 function hasFileEntries(files) {
     return files.create.length + files.modify.length + files.test.length > 0;
 }
-function mergeTechnicalFiles(primary, fallback) {
-    return {
-        create: mergeFileEntries(primary.create, fallback.create),
-        modify: mergeFileEntries(primary.modify, fallback.modify),
-        test: mergeFileEntries(primary.test, fallback.test),
-    };
-}
-function mergeFileEntries(primary, fallback) {
-    const byPath = new Map();
-    for (const file of [...primary, ...fallback]) {
-        if (!byPath.has(file.path)) {
-            byPath.set(file.path, file);
-        }
-    }
-    return [...byPath.values()];
-}
 async function resolveTechnicalFiles(input) {
     const generatedSource = [input.generatedTechnicalSection, input.generatedSpecBody]
         .filter((part) => part.trim().length > 0)
         .join('\n\n');
     const extracted = await extractFilesFromSpecBody(generatedSource, input.projectPath);
     if (extracted !== null && hasFileEntries(extracted)) {
-        return input.fallbackReason === undefined
-            ? mergeTechnicalFiles(extracted, input.autopilot.suggestedFiles)
-            : extracted;
+        return extracted;
     }
     return { create: [], modify: [], test: [] };
 }
@@ -185,23 +168,6 @@ const HIGH_RISK_WARNING = 'High-risk spec — consider: ' +
     '1) Is the approach technically feasible within the project constraints? ' +
     '2) What edge cases (network failure, concurrent writes, empty state) could break this? ' +
     '3) Which existing specs or external services does this depend on?';
-async function runQualityScore(spec) {
-    try {
-        const report = await scoreSpecQuality(spec);
-        return {
-            total: report.score.total,
-            grade: report.score.grade,
-            completeness: report.score.completeness,
-            testability: report.score.testability,
-            ambiguity: report.score.ambiguity,
-            risk: report.score.risk,
-        };
-    }
-    catch {
-        /* best-effort — never block spec creation */
-        return null;
-    }
-}
 function runSimplicityCheck(text, hours) {
     try {
         return analyzeSimplicity(text, hours);
@@ -221,37 +187,15 @@ function buildAdvisoryCompat() {
     };
 }
 /** Persist only out-of-scope items supplied explicitly by the caller. */
-function resolveOutOfScope(provided) {
-    return provided?.filter((item) => item.trim().length > 0) ?? [];
-}
-/** SPEC-614 AC4: suggest complexity category based on similar historical specs (best-effort). */
-async function runComplexityAdvice(projectId, currentSpecId, tags, targetCriteriaCount) {
-    try {
-        const allSpecs = await specStore.listSpecs(projectId);
-        const historicals = allSpecs
-            .filter((s) => s.id !== currentSpecId)
-            .slice(-200)
-            .map((s) => ({
-            specId: s.id,
-            criteriaCount: s.reviewNotes?.length ?? 0,
-            filesCount: s.impactAnalysis?.affectedFiles.length ?? 0,
-            estimatedHours: s.estimation.devHours,
-            actualHours: s.actuals?.devHours,
-            tags: s.tags,
-        }));
-        const advice = adviseSimilarSpecs(targetCriteriaCount, tags, historicals);
-        if (advice.similarSpecsCount === 0) {
-            return null;
-        }
-        return {
-            suggestedCategory: advice.suggestedCategory,
-            reasoning: advice.reasoning,
-            similarSpecsCount: advice.similarSpecsCount,
-        };
-    }
-    catch {
-        return null;
+function resolveOutOfScope(provided, source = '') {
+    const explicit = provided?.filter((item) => item.trim().length > 0) ?? [];
+    if (explicit.length > 0) {
+        return explicit;
     }
+    const section = /(?:^|\n)##\s+Out of scope\s*\n([\s\S]*?)(?=\n##\s|$)/i.exec(source)?.[1];
+    return section
+        ? Array.from(section.matchAll(/^[-*]\s+(.+)$/gm), (match) => match[1]?.trim() ?? '').filter(Boolean)
+        : [];
 }
 /** SPEC-783: Synthesize agent team findings into unified spec.md ## Technical section. */
 async function handleAgentTeamSynthesis(specId, projectPath, findings) {
@@ -296,7 +240,7 @@ async function handleAgentTeamSynthesis(specId, projectPath, findings) {
             const synthesized = synthesizeFindings('', findings);
             updatedContent = `${specContent.trimEnd()}\n\n## Technical\n\n${synthesized}\n`;
         }
-        await writeFile(specPath, updatedContent, 'utf8');
+        await atomicWriteFile(specPath, updatedContent, { encoding: 'utf8' });
         return {
             content: [
                 {
@@ -311,14 +255,139 @@ async function handleAgentTeamSynthesis(specId, projectPath, findings) {
         return { content: [{ type: 'text', text: `Synthesis failed: ${msg}` }], isError: true };
     }
 }
-/** SPEC-770: Derive idempotency key from title and projectPath. */
-function computeIdempotencyKey(title, projectPath) {
-    return createHash('sha256').update(`${title}::${projectPath}`).digest('hex');
+/** Derive a bounded storage key from an explicit caller key or the legacy request identity. */
+function computeIdempotencyKey(title, projectPath, explicitKey) {
+    const identity = explicitKey ? `explicit::${explicitKey}` : `${title}::${projectPath}`;
+    return createHash('sha256').update(identity).digest('hex');
+}
+function createSpecRequestDigest(params, projectPath) {
+    return createHash('sha256')
+        .update(JSON.stringify({ ...params, projectPath, idempotencyKey: undefined }))
+        .digest('hex');
+}
+function computeOperationKey(params, projectPath, dedupeKey) {
+    const identity = params.idempotencyKey
+        ? `explicit::${params.idempotencyKey}`
+        : `implicit::${dedupeKey}::${params.description}::${randomUUID()}`;
+    return createHash('sha256').update(`${identity}::${projectPath}`).digest('hex');
 }
-const IDEMPOTENCY_CLAIM_STALE_MS = 60_000;
-const IDEMPOTENCY_CLAIM_WAIT_MS = 25_000;
-const IDEMPOTENCY_CLAIM_POLL_MS = 20;
-const IDEMPOTENCY_MATCH_WINDOW_MS = 10 * 60 * 1000;
+function finishRecoveredOperation(journal, key, result) {
+    let entry = journal.get('create_spec', key);
+    if (entry?.state === 'intent') {
+        entry = journal.prepared('create_spec', key);
+    }
+    if (entry?.state === 'prepared') {
+        entry = journal.committed('create_spec', key, result);
+    }
+    if (entry?.state === 'committed') {
+        entry = journal.acknowledged('create_spec', key);
+    }
+    return entry?.result ?? result;
+}
+function buildCommittedCreateResult(input) {
+    const advisorySignals = [];
+    if (input.advisoryCriteria.length > 0) {
+        advisorySignals.push(makeAdvisorySignal({
+            key: 'ungrounded-contract-items',
+            kind: 'quality',
+            message: `${String(input.advisoryCriteria.length)} ungrounded contract item(s) kept advisory-only.`,
+            source: 'validator',
+            evidence: input.advisoryCriteria.slice(0, 10),
+            confidence: 0.8,
+            surface: 'structuredContent',
+            value: input.advisoryCriteria,
+        }));
+    }
+    const splitResult = buildSplitResult(input.splitSuggestion, input.experienceLevel);
+    if (splitResult) {
+        advisorySignals.push(makeAdvisorySignal({
+            key: 'split-suggestion',
+            kind: 'complexity',
+            message: 'Spec may benefit from splitting.',
+            source: 'heuristic',
+            evidence: ['spec-splitter heuristic'],
+            confidence: 0.5,
+            surface: 'structuredContent',
+            value: splitResult,
+        }));
+    }
+    if (input.simplicityResult) {
+        advisorySignals.push(makeAdvisorySignal({
+            key: 'simplicity-check',
+            kind: 'simplicity',
+            message: `Simplicity recommendation: ${input.simplicityResult.recommendation}.`,
+            source: 'heuristic',
+            evidence: input.simplicityResult.signals.map((signal) => signal.type),
+            confidence: 0.55,
+            surface: 'structuredContent',
+            value: input.simplicityResult,
+            deprecatedAlias: 'simplicityCheck',
+        }));
+    }
+    const spec = input.spec;
+    const riskWarning = spec.risk === 'high' || spec.difficulty >= 4 ? HIGH_RISK_WARNING : undefined;
+    if (riskWarning) {
+        advisorySignals.push(makeAdvisorySignal({
+            key: 'risk-warning',
+            kind: 'challenge',
+            message: 'High-risk heuristic warning generated.',
+            source: 'heuristic',
+            evidence: [`risk:${spec.risk}`, `difficulty:${String(spec.difficulty)}`],
+            confidence: 0.6,
+            surface: 'structuredContent',
+            value: riskWarning,
+            deprecatedAlias: 'riskWarning',
+        }));
+    }
+    return toolResult(`Spec ${spec.id} created and persisted.`, {
+        operationId: input.operationId,
+        /** @deprecated Operation-journal durability; this is not Git evidence. */
+        committed: true,
+        persisted: true,
+        gitCommitPerformed: false,
+        pendingAnalysis: true,
+        specId: spec.id,
+        title: spec.title,
+        slug: spec.slug,
+        type: spec.type,
+        scope: spec.scope,
+        difficulty: spec.difficulty,
+        risk: spec.risk,
+        tags: spec.tags,
+        target: spec.target,
+        status: spec.status,
+        gitBranch: spec.gitBranch,
+        specPath: spec.specPath,
+        ...(input.duplicate
+            ? { duplicateWarning: ti('spec.duplicateTitle', { title: spec.title, slug: spec.slug }) }
+            : {}),
+        ...(input.constitutionWarnings.length > 0
+            ? { constitutionWarnings: input.constitutionWarnings }
+            : {}),
+        ...(input.clarificationSession
+            ? {
+                linkedClarificationSession: input.clarificationSession.id,
+                clarificationTopic: input.clarificationSession.topic,
+                clarificationAnswersUsed: Object.keys(input.clarificationSession.answers).length,
+            }
+            : {
+                clarificationNote: 'Spec created directly from the supplied description; no clarification session was linked.',
+            }),
+        ...(input.contradictionHint ? { contradictionHint: input.contradictionHint } : {}),
+        ...(input.actionableMetrics.length > 0 ? { actionableMetrics: input.actionableMetrics } : {}),
+        ...(input.simplicityResult ? { simplicityCheck: input.simplicityResult } : {}),
+        ...(riskWarning ? { riskWarning } : {}),
+        ...(input.plannerToken ? { plannerToken: input.plannerToken } : {}),
+        ...(advisorySignals.length > 0 ? { advisorySignals } : {}),
+        compat: buildAdvisoryCompat(),
+        message: ti('tools.create_spec.success', { id: spec.id, title: spec.title }),
+    });
+}
+const CREATE_SPEC_POLICY = getRuntimePolicy().createSpec;
+const IDEMPOTENCY_CLAIM_STALE_MS = CREATE_SPEC_POLICY.idempotencyClaimStaleMs;
+const IDEMPOTENCY_CLAIM_WAIT_MS = CREATE_SPEC_POLICY.idempotencyClaimWaitMs;
+const IDEMPOTENCY_CLAIM_POLL_MS = CREATE_SPEC_POLICY.idempotencyClaimPollMs;
+const IDEMPOTENCY_MATCH_WINDOW_MS = CREATE_SPEC_POLICY.idempotencyMatchWindowMs;
 function getIdempotencyEvidencePath(projectPath, key) {
     const analysisPath = getAsyncAnalysisPath(projectPath, 'SPEC-000');
     const projectDataPath = pathDirname(pathDirname(analysisPath));
@@ -438,9 +507,8 @@ async function commitIdempotencyEvidence(projectPath, key, claim, spec, specPath
         committedAt,
     };
     try {
-        await writeFile(evidencePath, JSON.stringify(evidence, null, 2), {
+        await executionWriteFileExclusive(evidencePath, JSON.stringify(evidence, null, 2), {
             encoding: 'utf-8',
-            flag: 'wx',
         });
     }
     catch (error) {
@@ -464,10 +532,66 @@ async function releaseIdempotencyClaim(projectPath, key, ownerId) {
         await quarantineAndDeleteIdempotencyClaim(claimPath, raw);
     }
 }
+async function decideCreateSpecRecovery(entry) {
+    const payload = entry.payload;
+    if (entry.payloadVersion !== 1 || payload?.operationVersion !== 1) {
+        return { action: 'quarantine', reason: 'Unsupported create_spec recovery payload' };
+    }
+    if (entry.state === 'intent') {
+        if (payload.ownerId) {
+            await releaseIdempotencyClaim(payload.projectPath, payload.idempotencyKey, payload.ownerId);
+        }
+        return { action: 'rollback', reason: 'Intent has no prepared durable side effects' };
+    }
+    if (!payload.projectId ||
+        !payload.specId ||
+        !payload.specPath ||
+        !payload.specContentDigest ||
+        !payload.result) {
+        return { action: 'quarantine', reason: 'Prepared payload is incomplete' };
+    }
+    const [content, storedSpec, evidenceRaw] = await Promise.all([
+        readFile(payload.specPath, 'utf8').catch(() => ''),
+        specStore.getSpec(payload.projectId, payload.specId).catch(() => null),
+        readFile(getIdempotencyEvidencePath(payload.projectPath, payload.idempotencyKey), 'utf8').catch(() => ''),
+    ]);
+    const evidence = parseIdempotencyEvidence(evidenceRaw);
+    const isCommitted = createHash('sha256').update(content).digest('hex') === payload.specContentDigest &&
+        storedSpec?.id === payload.specId &&
+        evidence?.specId === payload.specId &&
+        (!payload.ownerId || !evidence.ownerId || evidence.ownerId === payload.ownerId);
+    if (isCommitted) {
+        return {
+            action: 'commit',
+            result: payload.result,
+            outbox: {
+                topic: 'spec.created',
+                payload: {
+                    schemaVersion: 1,
+                    specId: payload.specId,
+                    projectId: payload.projectId,
+                    projectPath: payload.projectPath,
+                    postCommitTasks: SPEC_CREATED_POST_COMMIT_TASKS,
+                },
+            },
+        };
+    }
+    const noDurableArtifacts = content.length === 0 && storedSpec === null && evidence === undefined;
+    if (noDurableArtifacts) {
+        if (payload.ownerId) {
+            await releaseIdempotencyClaim(payload.projectPath, payload.idempotencyKey, payload.ownerId);
+        }
+        return { action: 'rollback', reason: 'Prepared mutation has no durable artifacts' };
+    }
+    return {
+        action: 'quarantine',
+        reason: 'Prepared create_spec artifacts are partial or inconsistent',
+    };
+}
 async function quarantineAndDeleteIdempotencyClaim(claimPath, expectedRaw) {
     const quarantinePath = `${claimPath}.${randomUUID()}.quarantine`;
     try {
-        await rename(claimPath, quarantinePath);
+        await executionRename(claimPath, quarantinePath);
     }
     catch (error) {
         if (error.code === 'ENOENT') {
@@ -477,18 +601,18 @@ async function quarantineAndDeleteIdempotencyClaim(claimPath, expectedRaw) {
     }
     const quarantinedRaw = await readFile(quarantinePath, 'utf-8').catch(() => '');
     if (quarantinedRaw === expectedRaw) {
-        await rm(quarantinePath, { force: true });
+        await executionRemove(quarantinePath, { force: true });
         return true;
     }
     try {
-        await hardLink(quarantinePath, claimPath);
+        await executionLink(quarantinePath, claimPath);
     }
     catch (error) {
         if (error.code !== 'EEXIST') {
             throw error;
         }
     }
-    await rm(quarantinePath, { force: true });
+    await executionRemove(quarantinePath, { force: true });
     return false;
 }
 async function waitForIdempotencyOwner(projectPath, key, claim) {
@@ -514,7 +638,7 @@ async function waitForIdempotencyOwner(projectPath, key, claim) {
 }
 async function acquireIdempotencyClaim(projectPath, key, title) {
     const claimPath = getIdempotencyClaimPath(projectPath, key);
-    await mkdir(pathDirname(claimPath), { recursive: true });
+    await executionMkdir(pathDirname(claimPath), { recursive: true });
     for (let attempt = 0; attempt < 4; attempt += 1) {
         const claim = {
             version: 2,
@@ -525,9 +649,8 @@ async function acquireIdempotencyClaim(projectPath, key, title) {
             claimedAt: new Date().toISOString(),
         };
         try {
-            await writeFile(claimPath, JSON.stringify(claim, null, 2), {
+            await executionWriteFileExclusive(claimPath, JSON.stringify(claim, null, 2), {
                 encoding: 'utf-8',
-                flag: 'wx',
             });
             const racedCommit = await findByIdempotencyEvidence(projectPath, key, Date.now() - IDEMPOTENCY_MATCH_WINDOW_MS);
             if (racedCommit !== undefined) {
@@ -536,7 +659,7 @@ async function acquireIdempotencyClaim(projectPath, key, title) {
             }
             const expiredEvidencePath = getIdempotencyEvidencePath(projectPath, key);
             if ((await fsStat(expiredEvidencePath).catch(() => null)) !== null) {
-                await rm(expiredEvidencePath, { force: true });
+                await executionRemove(expiredEvidencePath, { force: true });
             }
             return { kind: 'owner', claim };
         }
@@ -600,28 +723,27 @@ async function buildIdempotencyMatchResult(projectPath, existing) {
     };
 }
 const FRONTMATTER_ID_RE = /^id:\s*(SPEC-\d+)/m;
-const FRONTMATTER_TITLE_RE = /^title:\s*"?([^"\n]+?)"?\s*$/m;
 const FRONTMATTER_STATUS_RE = /^status:\s*(\S+)/m;
-/** SPEC-770: Scan store and filesystem for a spec with matching idempotency key within windowMs. */
-async function findByIdempotencyKey(projectPath, key, projectId, windowMs = IDEMPOTENCY_MATCH_WINDOW_MS) {
-    const cutoff = Date.now() - windowMs;
-    // Fast path: check store (always authoritative for successfully created specs)
+async function findStoreByIdempotencyKey(projectId, key, cutoff) {
     try {
         const existing = await specStore.listSpecs(projectId);
-        const match = existing.find((s) => s.idempotencyKey === key && new Date(s.createdAt).getTime() > cutoff);
-        if (match !== undefined) {
-            return match;
-        }
+        return existing.find((s) => s.idempotencyKey === key && new Date(s.createdAt).getTime() > cutoff);
     }
     catch {
-        /* best-effort */
+        return undefined;
+    }
+}
+/** SPEC-770: Scan store and filesystem for a spec with matching idempotency key within windowMs. */
+async function findByIdempotencyKey(projectPath, key, projectId, windowMs = IDEMPOTENCY_MATCH_WINDOW_MS) {
+    const cutoff = Date.now() - windowMs;
+    const storeMatch = await findStoreByIdempotencyKey(projectId, key, cutoff);
+    if (storeMatch) {
+        return storeMatch;
     }
-    // Transactional fallback: the request key stays in external project data, not spec.md.
     const evidenceMatch = await findByIdempotencyEvidence(projectPath, key, cutoff);
     if (evidenceMatch !== undefined) {
         return evidenceMatch;
     }
-    // Compatibility fallback for specs created before external evidence was introduced.
     try {
         const { glob } = await import('glob');
         const { join: joinPath } = await import('node:path');
@@ -651,7 +773,7 @@ async function findByIdempotencyKey(projectPath, key, projectId, windowMs = IDEM
     return undefined;
 }
 /** SPEC-770: Scan for recently written spec.md files (for possibleDuplicates in timeout response). */
-async function findRecentlyWrittenSpecs(projectPath, windowMs) {
+async function findRecentlyWrittenSpecs(projectPath, windowMs, requestedTitle) {
     try {
         const { glob } = await import('glob');
         const { join: joinPath } = await import('node:path');
@@ -665,9 +787,11 @@ async function findRecentlyWrittenSpecs(projectPath, windowMs) {
             }
             const content = await readFile(specFile, 'utf-8').catch(() => '');
             const idMatch = FRONTMATTER_ID_RE.exec(content);
-            const titleMatch = FRONTMATTER_TITLE_RE.exec(content);
-            if (idMatch?.[1] !== undefined) {
-                results.push({ id: idMatch[1], title: titleMatch?.[1] ?? '' });
+            const title = extractFrontmatterTitle(content);
+            if (idMatch?.[1] !== undefined &&
+                normalizeDuplicateTitle(title) !== '' &&
+                normalizeDuplicateTitle(title) === normalizeDuplicateTitle(requestedTitle)) {
+                results.push({ id: idMatch[1], title });
             }
         }
         return results;
@@ -676,6 +800,69 @@ async function findRecentlyWrittenSpecs(projectPath, windowMs) {
         return [];
     }
 }
+function extractFrontmatterTitle(content) {
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content)?.[1];
+    const rawTitle = frontmatter ? /^title:\s*(.*?)\s*$/m.exec(frontmatter)?.[1] : undefined;
+    if (!rawTitle) {
+        return '';
+    }
+    if (rawTitle.startsWith('"') && rawTitle.endsWith('"')) {
+        try {
+            const parsed = JSON.parse(rawTitle);
+            return typeof parsed === 'string' ? parsed : '';
+        }
+        catch {
+            return '';
+        }
+    }
+    if (rawTitle.startsWith("'") && rawTitle.endsWith("'")) {
+        return rawTitle.slice(1, -1).replace(/''/g, "'");
+    }
+    return rawTitle;
+}
+function normalizeDuplicateTitle(value) {
+    return value
+        .normalize('NFKC')
+        .toLocaleLowerCase('en-US')
+        .replace(/[\p{P}]+/gu, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+const CREATE_SPEC_ENUMS = {
+    type: SpecTypeEnum,
+    scope: SpecScopeEnum,
+    target: SpecTargetEnum,
+    acFormat: SpecAcFormatEnum,
+};
+function validateCreateSpecEnums(input) {
+    for (const [field, schema] of Object.entries(CREATE_SPEC_ENUMS)) {
+        const received = input[field];
+        if (received === undefined || schema.safeParse(received).success) {
+            continue;
+        }
+        const boundedReceived = received === null || ['string', 'number', 'boolean'].includes(typeof received)
+            ? received
+            : typeof received;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${field} must be one of: ${schema.options.join(', ')}.`,
+                },
+            ],
+            isError: true,
+            structuredContent: {
+                error: 'INVALID_INPUT',
+                code: 'INVALID_INPUT',
+                status: 422,
+                field,
+                received: boundedReceived,
+                allowed: schema.options,
+            },
+        };
+    }
+    return null;
+}
 const DESCRIPTION_MAX_CHARS = 10_000;
 const DESCRIPTION_EXCEED_MSG = 'Description exceeds 10000 chars. Create with a summary (<3k) and use reconcile_spec to add the rest.';
 function checkEnglishOnlyInput(params) {
@@ -700,8 +887,273 @@ function checkEnglishOnlyInput(params) {
         },
     };
 }
+function quotePosixShellArgument(value) {
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+function earlyPreparation(result, clarificationProjectId) {
+    return {
+        kind: 'early',
+        result,
+        ...(clarificationProjectId ? { clarificationProjectId } : {}),
+    };
+}
+export async function resolveGroundedVerificationCommands(projectPath, testPaths) {
+    if (testPaths.length === 0) {
+        return [];
+    }
+    const packageJsonRaw = await readFile(pathJoin(projectPath, 'package.json'), 'utf8').catch(() => '');
+    if (!packageJsonRaw) {
+        return [];
+    }
+    try {
+        const manifest = JSON.parse(packageJsonRaw);
+        if (typeof manifest.packageManager !== 'string') {
+            return [];
+        }
+        const packageManager = /^(pnpm|npm|yarn|bun)@\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/u.exec(manifest.packageManager)?.[1];
+        if (!packageManager) {
+            return [];
+        }
+        if (typeof manifest.scripts?.test !== 'string' || manifest.scripts.test.trim() === '') {
+            return [];
+        }
+        return [`${packageManager} run test -- ${testPaths.map(quotePosixShellArgument).join(' ')}`];
+    }
+    catch {
+        return [];
+    }
+}
+async function prepareCreateSpecCandidate(initialParams, server) {
+    let params = initialParams;
+    const buildResult = await measureStep('buildSpecContext', () => buildSpecContext(params));
+    if (!buildResult.ok) {
+        return earlyPreparation({
+            content: [{ type: 'text', text: buildResult.errorMessage }],
+            isError: true,
+        });
+    }
+    const context = buildResult.context;
+    const { spec, estimation, projectId } = context;
+    const knowledge = await measureStep('loadKnowledge', () => knowledgeStore.getKnowledge(projectId));
+    const clarificationSession = params.clarificationSessionId
+        ? await knowledgeStore.getClarification(projectId, params.clarificationSessionId)
+        : null;
+    const constitutionCheck = await measureStep('validateConstitution', () => validateConstitution(projectId, spec.title, spec.tags));
+    if (constitutionCheck.blocked && constitutionCheck.errorResult) {
+        return earlyPreparation(constitutionCheck.errorResult);
+    }
+    const inlineAnalysis = await withBudget('create-spec-inline-analysis', getRuntimePolicy().createSpec.inlineAnalysisBudgetMs, (signal) => analyzeProjectForSpec(params.projectPath ?? '', params.description, spec.title, knowledge, signal));
+    const autopilot = unwrapBudget(inlineAnalysis, getEmptyAutopilotResult());
+    if (autopilot.isIdea) {
+        return earlyPreparation({
+            content: [
+                {
+                    type: 'text',
+                    text: `💡 **Idea captured**: "${params.description}"\n\nThe description is too brief for a full spec. Use \`capture_idea\` to save it to the backlog, or provide more detail (>10 words) to create a spec.`,
+                },
+            ],
+        });
+    }
+    const clarificationResult = handleClarification(server, params.description, knowledge, autopilot, params);
+    if (clarificationResult !== null) {
+        if ('earlyReturn' in clarificationResult) {
+            return earlyPreparation(clarificationResult.earlyReturn, projectId);
+        }
+        params = clarificationResult.params;
+    }
+    const filteredCriteria = filterGroundedCriteria(autopilot.suggestedCriteria);
+    const technologyContract = await readTechnologySelectionContract(params.projectPath ?? '');
+    const contractNote = technologyContract
+        ? [
+            '',
+            'Technology Contract:',
+            `- Mode: ${technologyContract.mode}`,
+            technologyContract.language ? `- Language: ${technologyContract.language}` : '',
+            technologyContract.framework
+                ? `- Framework: ${technologyContract.framework}`
+                : '- Framework: none or not selected',
+            technologyContract.platform ? `- Platform: ${technologyContract.platform}` : '',
+            technologyContract.projectType ? `- Project type: ${technologyContract.projectType}` : '',
+            '- Agents must not choose a different stack unless the user approves a new contract.',
+        ]
+            .filter(Boolean)
+            .join('\n')
+        : '';
+    const generatedSpec = await measureStep('generateSpecBody', () => new FallbackGenerator().generate({
+        title: spec.title,
+        description: `${params.description}${contractNote}`,
+        type: spec.type,
+        scope: spec.scope,
+        target: spec.target,
+        acFormat: params.acFormat,
+        projectContext: {
+            language: technologyContract?.language ?? knowledge?.language ?? undefined,
+            framework: technologyContract?.framework ?? knowledge?.framework ?? undefined,
+            architecture: knowledge?.architecture.primary ?? undefined,
+        },
+    }));
+    spec.generation = generatedSpec.generation;
+    spec.qualityWarnings =
+        generatedSpec.qualityWarnings.length > 0 ? generatedSpec.qualityWarnings : undefined;
+    const baseCriteria = extractCriteria(generatedSpec.specBody).map((criterion) => criterion.text);
+    const groundingCriteria = buildCriterionGroundingRecords({
+        criteria: [...baseCriteria, ...filteredCriteria],
+        userInput: params.description,
+        generatedEvidence: [generatedSpec.generation.modelId ?? generatedSpec.generation.method],
+    });
+    const contractCriteria = getContractCriteria(groundingCriteria);
+    const advisoryCriteria = getAdvisoryCriteria(groundingCriteria).map((record) => record.text);
+    if (contractCriteria.length === 0) {
+        return earlyPreparation({
+            content: [
+                {
+                    type: 'text',
+                    text: 'create_spec did not persist a spec because no acceptance criterion was grounded in the user request. ' +
+                        'Needs decision: provide at least one explicit, verifiable criterion as a checkbox or Given/When/Then outcome.',
+                },
+            ],
+            isError: true,
+            structuredContent: {
+                error: 'MISSING_GROUNDED_ACCEPTANCE_CRITERIA',
+                missingDecision: 'Provide at least one explicit, verifiable acceptance criterion.',
+                persisted: false,
+            },
+        });
+    }
+    const actionableMetrics = calculateActionableSpecMetrics({
+        criteria: [...baseCriteria, ...filteredCriteria],
+        groundingRecords: groundingCriteria,
+    }).filter(shouldExposeMetric);
+    const technicalFiles = await measureStep('resolveTechnicalFiles', () => resolveTechnicalFiles({
+        generatedSpecBody: generatedSpec.specBody,
+        generatedTechnicalSection: generatedSpec.technicalSection,
+        projectPath: params.projectPath ?? '',
+    }));
+    const groundedTechnical = await measureStep('groundTechnicalFiles', () => groundTechnicalFiles({
+        files: technicalFiles,
+        projectPath: params.projectPath ?? '',
+        userInput: params.description,
+        autopilot,
+    }));
+    const outOfScope = resolveOutOfScope(params.outOfScope, params.description);
+    const scenarioTestPaths = groundedTechnical.files.test.map((file) => file.path);
+    const criteria = contractCriteria.map((record) => ({ text: record.text, done: false }));
+    const leanSpec = generateLeanSpecContent({
+        spec,
+        description: generatedSpec.specBody,
+        estimation,
+        criteriaOverride: criteria,
+        groundingCriteria: contractCriteria,
+        groundingTechnicalReferences: groundedTechnical.records,
+        acFormat: params.acFormat,
+        scenarioTestPaths,
+    });
+    const leanTechnical = generateLeanTechnicalContent({
+        specId: spec.id,
+        filesToCreate: groundedTechnical.files.create,
+        filesToModify: groundedTechnical.files.modify,
+        filesToTest: groundedTechnical.files.test,
+        includeDecisionRequiredPlaceholder: spec.scope !== 'trivial',
+    });
+    const verificationCommands = await resolveGroundedVerificationCommands(params.projectPath ?? '', scenarioTestPaths);
+    const implementationContract = buildImplementationContractSection({
+        description: generatedSpec.specBody,
+        criteria,
+        files: groundedTechnical.files,
+        outOfScope,
+        verificationCommands,
+    });
+    const unifiedSpec = buildCanonicalUnifiedSpecContent({
+        leanSpecBody: leanSpec,
+        sourceDescription: params.description,
+        technicalBody: leanTechnical,
+        implementationContract,
+        criteria,
+        files: groundedTechnical.files,
+        outOfScope,
+    });
+    const candidateValidation = validateUnifiedSpecCandidate(unifiedSpec, {
+        groundedFilePaths: groundedTechnical.records.map((record) => record.path),
+    });
+    if (!candidateValidation.valid) {
+        return earlyPreparation({
+            content: [
+                {
+                    type: 'text',
+                    text: `Unified spec candidate is invalid: ${candidateValidation.issues
+                        .slice(0, 3)
+                        .map((issue) => issue.message)
+                        .join('; ')}`,
+                },
+            ],
+            isError: true,
+            structuredContent: {
+                error: 'SPEC_FORMAT_INVALID',
+                code: 422,
+                persisted: false,
+                issues: candidateValidation.issues,
+            },
+        });
+    }
+    const genericOutputGate = checkGenericSpecOutput(unifiedSpec);
+    if (!genericOutputGate.passed) {
+        return earlyPreparation({
+            content: [
+                {
+                    type: 'text',
+                    text: 'Spec quality gate blocked generic output before persistence. ' +
+                        genericOutputGate.issues
+                            .slice(0, 3)
+                            .map((issue) => `${issue.phrase}: ${issue.reason}`)
+                            .join('; '),
+                },
+            ],
+            isError: true,
+            structuredContent: {
+                error: 'GENERIC_SPEC_OUTPUT_BLOCKED',
+                sddConstitutionRuleId: 'sdd.no-generic-output',
+                issues: genericOutputGate.issues,
+                fixHint: 'Replace generic criteria or placeholder references with grounded, testable behavior.',
+            },
+        });
+    }
+    if (outOfScope.length > 0) {
+        spec.outOfScope = outOfScope;
+    }
+    return {
+        kind: 'ready',
+        prepared: {
+            params,
+            context,
+            knowledge,
+            clarificationSession,
+            constitutionWarnings: constitutionCheck.warnings,
+            advisoryCriteria,
+            actionableMetrics,
+            unifiedSpec,
+            simplicityResult: runSimplicityCheck([params.description, ...filteredCriteria].join('\n'), estimation.devHours),
+        },
+    };
+}
 // eslint-disable-next-line max-lines-per-function
 export async function handleCreateSpec(inputParams, server) {
+    const enumValidation = validateCreateSpecEnums(inputParams);
+    if (enumValidation) {
+        return enumValidation;
+    }
+    if (inputParams.idempotencyKey !== undefined &&
+        !/^[A-Za-z0-9._:-]{8,128}$/.test(inputParams.idempotencyKey)) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: 'idempotencyKey must contain 8-128 letters, digits, dots, underscores, colons or hyphens.',
+                },
+            ],
+            isError: true,
+            structuredContent: { error: 'INVALID_IDEMPOTENCY_KEY', code: 422 },
+        };
+    }
     // SPEC-781: Friendly error for description exceeding 10000 chars (replaces cryptic Zod error)
     if (inputParams.description && inputParams.description.length > DESCRIPTION_MAX_CHARS) {
         return {
@@ -746,28 +1198,157 @@ export async function handleCreateSpec(inputParams, server) {
     if (languageGate) {
         return languageGate;
     }
+    // SPEC-584: Gate check — block if pending clarification token exists and no answers provided
+    const gateError = await runClarificationGate(resolvedPath, 'create_spec', inputParams.clarificationAnswers);
+    if (gateError) {
+        return gateError;
+    }
+    const idempotencyKey = computeIdempotencyKey(inputParams.title, resolvedPath, inputParams.idempotencyKey);
+    const cutoff = Date.now() - IDEMPOTENCY_MATCH_WINDOW_MS;
+    const storeOnlyCandidate = await findStoreByIdempotencyKey(hashProjectPath(resolvedPath), idempotencyKey, cutoff);
+    let preparation;
+    try {
+        preparation = await prepareCreateSpecCandidate(resolvedInputParams, server);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            content: [{ type: 'text', text: ti('errors.internalError', { message }) }],
+            isError: true,
+        };
+    }
+    if (preparation.kind === 'early') {
+        if (preparation.clarificationProjectId) {
+            await persistClarificationToken(preparation.result, preparation.clarificationProjectId, 'create_spec');
+        }
+        return preparation.result;
+    }
+    const prepared = preparation.prepared;
+    prepared.context.spec.idempotencyKey = idempotencyKey;
+    if (storeOnlyCandidate) {
+        const committedEvidence = await findByIdempotencyEvidence(resolvedPath, idempotencyKey, cutoff);
+        if (!committedEvidence) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `A partial create_spec transaction exists for ${storeOnlyCandidate.id}: the store row has no committed idempotency evidence. Recovery is required before retrying.`,
+                    },
+                ],
+                isError: true,
+                structuredContent: {
+                    error: 'PARTIAL_IDEMPOTENCY_STATE',
+                    code: 409,
+                    persisted: false,
+                    specId: storeOnlyCandidate.id,
+                },
+            };
+        }
+    }
     // SPEC-665: Fire-and-forget TTL refresh for conventions.json (never blocks create_spec)
     void import('../engine/conventions-ttl.js').then(({ triggerConventionsTtlRefresh }) => {
         void triggerConventionsTtlRefresh(resolvedPath).catch(() => {
             /* best-effort */
         });
     });
-    // SPEC-584: Gate check — block if pending clarification token exists and no answers provided
-    const gateError = await runClarificationGate(resolvedPath, 'create_spec', inputParams.clarificationAnswers);
-    if (gateError) {
-        return gateError;
-    }
     // SPEC-770: Idempotency check — return existing spec if same title+projectPath within 10 minutes
-    const idempotencyKey = computeIdempotencyKey(inputParams.title, resolvedPath);
+    const operationKey = computeOperationKey(resolvedInputParams, resolvedPath, idempotencyKey);
+    const runtimeDatabase = new RuntimeDatabase({ path: resolveStorageLayout().runtimeDatabase });
+    const operationJournal = new OperationJournal(runtimeDatabase, createHash('sha256').update(hashProjectPath(resolvedPath)).digest('hex').slice(0, 32));
+    let journalEntry;
+    try {
+        await recoverOperationJournal({
+            journal: operationJournal,
+            operation: 'create_spec',
+            staleBefore: new Date(Date.now() - IDEMPOTENCY_CLAIM_STALE_MS).toISOString(),
+            decide: decideCreateSpecRecovery,
+        });
+        journalEntry = operationJournal.begin('create_spec', operationKey, inputParams.idempotencyKey
+            ? createSpecRequestDigest(resolvedInputParams, resolvedPath)
+            : operationKey, {
+            payloadVersion: 1,
+            payload: {
+                operationVersion: 1,
+                projectPath: resolvedPath,
+                idempotencyKey,
+            },
+        });
+        if (journalEntry.state === 'rolled-back') {
+            journalEntry = operationJournal.restartRolledBack('create_spec', operationKey);
+            journalEntry = operationJournal.setRecoveryPayload('create_spec', operationKey, 1, {
+                operationVersion: 1,
+                projectPath: resolvedPath,
+                idempotencyKey,
+            });
+        }
+    }
+    catch (error) {
+        runtimeDatabase.close();
+        if (error instanceof BoundaryFailure &&
+            error.kind === 'Conflict' &&
+            error.operation === 'operation begin') {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: 'The idempotency key is already bound to a different create_spec request.',
+                    },
+                ],
+                isError: true,
+                structuredContent: {
+                    error: 'IDEMPOTENCY_CONFLICT',
+                    code: 'IDEMPOTENCY_CONFLICT',
+                    status: 409,
+                    persisted: false,
+                },
+            };
+        }
+        throw error;
+    }
+    if ((journalEntry.state === 'committed' || journalEntry.state === 'acknowledged') &&
+        journalEntry.result) {
+        if (journalEntry.state === 'committed') {
+            operationJournal.acknowledged('create_spec', operationKey);
+        }
+        runtimeDatabase.close();
+        return journalEntry.result;
+    }
+    if (journalEntry.state === 'quarantined') {
+        runtimeDatabase.close();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `The previous create_spec attempt is quarantined: ${journalEntry.recoveryReason ?? 'artifact mismatch'}.`,
+                },
+            ],
+            isError: true,
+            structuredContent: { recoveryQuarantined: true, operationId: operationKey },
+        };
+    }
     const existingByKey = await findByIdempotencyKey(resolvedPath, idempotencyKey, hashProjectPath(resolvedPath));
     if (existingByKey) {
-        return buildIdempotencyMatchResult(resolvedPath, existingByKey);
+        const result = await buildIdempotencyMatchResult(resolvedPath, existingByKey);
+        finishRecoveredOperation(operationJournal, operationKey, result);
+        runtimeDatabase.close();
+        return result;
+    }
+    let claimResolution;
+    try {
+        claimResolution = await acquireIdempotencyClaim(resolvedPath, idempotencyKey, inputParams.title);
+    }
+    catch (error) {
+        runtimeDatabase.close();
+        throw error;
     }
-    const claimResolution = await acquireIdempotencyClaim(resolvedPath, idempotencyKey, inputParams.title);
     if (claimResolution.kind === 'existing') {
-        return buildIdempotencyMatchResult(resolvedPath, claimResolution.spec);
+        const result = await buildIdempotencyMatchResult(resolvedPath, claimResolution.spec);
+        finishRecoveredOperation(operationJournal, operationKey, result);
+        runtimeDatabase.close();
+        return result;
     }
     if (claimResolution.kind === 'pending') {
+        runtimeDatabase.close();
         return {
             content: [
                 {
@@ -785,254 +1366,101 @@ export async function handleCreateSpec(inputParams, server) {
         retainForInFlightWork: false,
     };
     try {
-        // eslint-disable-next-line max-lines-per-function, complexity -- orchestrator: one sequential gate + response-build block per lifecycle step; splitting requires threading 15+ shared variables
+        operationJournal.setRecoveryPayload('create_spec', operationKey, 1, {
+            operationVersion: 1,
+            projectPath: resolvedPath,
+            idempotencyKey,
+            ownerId: idempotencyClaim.ownerId,
+        });
         return await trackCost(resolvedInputParams.projectPath ?? '', 'create_spec', async () => {
-            // Allow internal re-enrichment without mutating function parameter
-            let params = resolvedInputParams;
-            const { description, clarificationSessionId } = params;
             try {
                 // SPEC-713: Phase 1 — Critical path: build + persist spec within 25s hard ceiling.
                 // Only the steps required to produce spec.md on disk are inside this budget.
-                // Post-creation enrichment (git, contradictions, quality scores, etc.) runs outside.
-                const criticalResult = await withTotalBudget('create_spec-critical', 25_000, async () => {
-                    // Build spec context (ID, estimation, diagrams, scope filters)
-                    const buildResult = await measureStep('buildSpecContext', () => buildSpecContext(params));
-                    if (!buildResult.ok) {
-                        return {
-                            ok: false,
-                            earlyReturn: {
-                                content: [{ type: 'text', text: buildResult.errorMessage }],
-                                isError: true,
-                            },
-                        };
-                    }
-                    const { spec, specDir, specPath, technicalPath, estimation, splitSuggestion, duplicate, projectId, agentTeamPlan, } = buildResult.context;
-                    // Kept in external store/evidence for retries; the value-only serializer omits it.
-                    spec.idempotencyKey = idempotencyKey;
-                    // Load project knowledge and clarification session
-                    const knowledge = await measureStep('loadKnowledge', () => knowledgeStore.getKnowledge(projectId));
-                    const clarificationSession = clarificationSessionId
-                        ? await knowledgeStore.getClarification(projectId, clarificationSessionId)
-                        : null;
-                    // Validate against Constitution
-                    const constitutionCheck = await measureStep('validateConstitution', () => validateConstitution(projectId, spec.title, spec.tags));
-                    if (constitutionCheck.blocked && constitutionCheck.errorResult) {
-                        return { ok: false, earlyReturn: constitutionCheck.errorResult };
-                    }
-                    // SPEC-461 Phase 3: Autopilot — analyze project to enrich spec (best-effort)
-                    // SPEC-560: Wrapped with 5s timeout to prevent hangs on large projects (2000+ files)
-                    // SPEC-713: measureStep for Phase 0 diagnostic; withBudget enforces 5s ceiling
-                    const autopilotResult = await withBudget('autopilot-analyzer', 5_000, () => measureStep('autopilot-analyzer', () => analyzeProjectForSpec(params.projectPath ?? '', description, spec.title, knowledge)));
-                    const autopilot = unwrapBudget(autopilotResult, getEmptyAutopilotResult());
-                    // If very vague (<10 words), capture as idea instead of spec
-                    if (autopilot.isIdea) {
-                        return {
-                            ok: false,
-                            earlyReturn: {
-                                content: [
-                                    {
-                                        type: 'text',
-                                        text: `💡 **Idea captured**: "${description}"\n\nThe description is too brief for a full spec. Use \`capture_idea\` to save it to the backlog, or provide more detail (>10 words) to create a spec.`,
-                                    },
-                                ],
-                            },
-                        };
+                // Durable post-commit work is delegated to the spec.created outbox consumer.
+                const criticalResult = await withTotalBudget('create_spec-critical', getRuntimePolicy().createSpec.criticalTimeoutMs, async (criticalSignal) => {
+                    const { params, context, knowledge, clarificationSession, constitutionWarnings, advisoryCriteria, actionableMetrics, unifiedSpec, simplicityResult: committedSimplicity, } = prepared;
+                    const { spec, specDir, specPath, splitSuggestion, duplicate, projectId } = context;
+                    let committedPlannerToken;
+                    try {
+                        committedPlannerToken = await issuePlannerToken(resolvedPath, spec.id, params.sessionId ?? 'unknown-session', params.modelId ?? 'unknown-model', params.host ?? 'unknown-host');
                     }
-                    // SPEC-463 / SPEC-471: Interactive clarification
-                    const clarificationResult = handleClarification(server, description, knowledge, autopilot, params);
-                    if (clarificationResult !== null) {
-                        if ('earlyReturn' in clarificationResult) {
-                            // SPEC-584: Persist token so the gate blocks retries without answers
-                            await persistClarificationToken(clarificationResult.earlyReturn, projectId, 'create_spec');
-                            return { ok: false, earlyReturn: clarificationResult.earlyReturn };
-                        }
-                        params = clarificationResult.params;
+                    catch {
+                        // Best-effort evidence must not block durable spec creation.
                     }
-                    const filteredCriteria = filterGroundedCriteria(autopilot.suggestedCriteria);
-                    const technologyContract = await readTechnologySelectionContract(params.projectPath ?? '');
-                    const contractNote = technologyContract
-                        ? [
-                            '',
-                            'Technology Contract:',
-                            `- Mode: ${technologyContract.mode}`,
-                            technologyContract.language ? `- Language: ${technologyContract.language}` : '',
-                            technologyContract.framework
-                                ? `- Framework: ${technologyContract.framework}`
-                                : '- Framework: none or not selected',
-                            technologyContract.platform ? `- Platform: ${technologyContract.platform}` : '',
-                            technologyContract.projectType
-                                ? `- Project type: ${technologyContract.projectType}`
-                                : '',
-                            '- Agents must not choose a different stack unless the user approves a new contract.',
-                        ]
-                            .filter(Boolean)
-                            .join('\n')
-                        : '';
-                    const specGenerator = new FallbackGenerator();
-                    const generatedSpec = await measureStep('generateSpecBody', () => specGenerator.generate({
-                        title: spec.title,
-                        description: `${description}${contractNote}`,
-                        type: spec.type,
-                        scope: spec.scope,
-                        target: spec.target,
-                        acFormat: params.acFormat,
-                        projectContext: {
-                            language: technologyContract?.language ?? knowledge?.language ?? undefined,
-                            framework: technologyContract?.framework ?? knowledge?.framework ?? undefined,
-                            architecture: knowledge?.architecture.primary ?? undefined,
-                        },
-                    }));
-                    spec.generation = generatedSpec.generation;
-                    spec.qualityWarnings =
-                        generatedSpec.qualityWarnings.length > 0 ? generatedSpec.qualityWarnings : undefined;
-                    const baseCriteria = extractCriteria(generatedSpec.specBody).map((criterion) => criterion.text);
-                    const groundingCriteria = buildCriterionGroundingRecords({
-                        criteria: [...baseCriteria, ...filteredCriteria],
-                        userInput: description,
-                        generatedEvidence: [
-                            generatedSpec.generation.modelId ?? generatedSpec.generation.method,
-                        ],
-                    });
-                    const contractCriteria = getContractCriteria(groundingCriteria);
-                    const advisoryCriteria = getAdvisoryCriteria(groundingCriteria).map((record) => record.text);
-                    if (contractCriteria.length === 0) {
-                        return {
-                            ok: false,
-                            earlyReturn: {
-                                content: [
-                                    {
-                                        type: 'text',
-                                        text: 'create_spec did not persist a spec because no acceptance criterion was grounded in the user request. ' +
-                                            'Needs decision: provide at least one explicit, verifiable criterion as a checkbox or Given/When/Then outcome.',
-                                    },
-                                ],
-                                isError: true,
-                                structuredContent: {
-                                    error: 'MISSING_GROUNDED_ACCEPTANCE_CRITERIA',
-                                    missingDecision: 'Provide at least one explicit, verifiable acceptance criterion.',
-                                    persisted: false,
-                                },
-                            },
-                        };
-                    }
-                    const actionableMetrics = calculateActionableSpecMetrics({
-                        criteria: [...baseCriteria, ...filteredCriteria],
-                        groundingRecords: groundingCriteria,
-                    }).filter(shouldExposeMetric);
-                    const technicalFiles = await measureStep('resolveTechnicalFiles', () => resolveTechnicalFiles({
-                        generatedSpecBody: generatedSpec.specBody,
-                        generatedTechnicalSection: generatedSpec.technicalSection,
-                        projectPath: params.projectPath ?? '',
-                        autopilot,
-                        fallbackReason: generatedSpec.fallbackReason,
-                    }));
-                    const groundedTechnical = await measureStep('groundTechnicalFiles', () => groundTechnicalFiles({
-                        files: technicalFiles,
-                        projectPath: params.projectPath ?? '',
-                        userInput: description,
-                        autopilot,
-                    }));
-                    const outOfScope = resolveOutOfScope(params.outOfScope);
-                    const scenarioTestPaths = groundedTechnical.files.test.map((file) => file.path);
-                    const leanSpec = generateLeanSpecContent({
+                    const committedResult = buildCommittedCreateResult({
                         spec,
-                        description: generatedSpec.specBody,
-                        estimation,
-                        criteriaOverride: contractCriteria.map((record) => ({
-                            text: record.text,
-                            done: false,
-                        })),
-                        groundingCriteria: contractCriteria,
-                        groundingTechnicalReferences: groundedTechnical.records,
-                        acFormat: params.acFormat,
-                        scenarioTestPaths,
-                    });
-                    const leanTechnical = generateLeanTechnicalContent({
-                        specId: spec.id,
-                        filesToCreate: groundedTechnical.files.create,
-                        filesToModify: groundedTechnical.files.modify,
-                        filesToTest: groundedTechnical.files.test,
-                        includeDecisionRequiredPlaceholder: spec.scope !== 'trivial',
-                    });
-                    // SPEC-709: write unified spec.md from origin — no separate technical.md.
-                    // The legacy two-file output is preserved by appending the technical body
-                    // as a `## Technical` section inside spec.md.
-                    const unifiedWithoutContract = buildUnifiedSpecContent(leanSpec, leanTechnical);
-                    const unifiedSpec = appendImplementationContractIfMissing(unifiedWithoutContract, {
-                        description: generatedSpec.specBody,
-                        criteria: contractCriteria.map((record) => ({ text: record.text, done: false })),
-                        files: groundedTechnical.files,
-                        outOfScope,
-                        verificationCommands: [],
+                        operationId: operationKey,
+                        duplicate,
+                        constitutionWarnings,
+                        clarificationSession,
+                        advisoryCriteria,
+                        actionableMetrics,
+                        splitSuggestion,
+                        experienceLevel: knowledge?.experienceLevel,
+                        contradictionHint: undefined,
+                        simplicityResult: committedSimplicity,
+                        plannerToken: committedPlannerToken,
                     });
-                    const genericOutputGate = checkGenericSpecOutput(unifiedSpec);
-                    if (!genericOutputGate.passed) {
-                        return {
-                            ok: false,
-                            earlyReturn: {
-                                content: [
-                                    {
-                                        type: 'text',
-                                        text: 'Spec quality gate blocked generic output before persistence. ' +
-                                            genericOutputGate.issues
-                                                .slice(0, 3)
-                                                .map((issue) => `${issue.phrase}: ${issue.reason}`)
-                                                .join('; '),
-                                    },
-                                ],
-                                isError: true,
-                                structuredContent: {
-                                    error: 'GENERIC_SPEC_OUTPUT_BLOCKED',
-                                    sddConstitutionRuleId: 'sdd.no-generic-output',
-                                    issues: genericOutputGate.issues,
-                                    fixHint: 'Replace generic criteria or placeholder references with grounded, testable behavior.',
-                                },
-                            },
-                        };
-                    }
+                    let storeCreated = false;
                     try {
-                        await measureStep('mkdir-specDir', () => mkdir(specDir, { recursive: true }));
+                        assertExecutionCanCommit(criticalSignal);
+                        operationJournal.setRecoveryPayload('create_spec', operationKey, 1, {
+                            operationVersion: 1,
+                            projectPath: resolvedPath,
+                            idempotencyKey,
+                            ownerId: idempotencyClaim.ownerId,
+                            projectId,
+                            specId: spec.id,
+                            specPath,
+                            specContentDigest: createHash('sha256').update(unifiedSpec).digest('hex'),
+                            result: committedResult,
+                        });
+                        operationJournal.prepared('create_spec', operationKey);
+                        await measureStep('mkdir-specDir', () => executionMkdir(specDir, { recursive: true }));
                         // SPEC-713: measure file write — this is the critical persistence step.
-                        await measureStep('writeFile-specPath', () => writeFile(specPath, unifiedSpec, 'utf-8'));
+                        assertExecutionCanCommit(criticalSignal);
+                        await measureStep('writeFile-specPath', () => atomicWriteFile(specPath, unifiedSpec, { encoding: 'utf-8' }));
+                        assertExecutionCanCommit(criticalSignal);
+                        await measureStep('specStore-createSpec', () => specStore.createSpec(projectId, spec));
+                        storeCreated = true;
+                        assertExecutionCanCommit(criticalSignal);
                         await measureStep('commit-idempotency-evidence', () => commitIdempotencyEvidence(resolvedPath, idempotencyKey, idempotencyClaim, spec, specPath));
+                        operationJournal.commitWithOutbox('create_spec', operationKey, committedResult, {
+                            topic: 'spec.created',
+                            payload: {
+                                schemaVersion: 1,
+                                specId: spec.id,
+                                projectId,
+                                projectPath: resolvedPath,
+                                postCommitTasks: SPEC_CREATED_POST_COMMIT_TASKS,
+                            },
+                        });
                         claimLifecycle.committed = true;
-                        // SPEC-709: technical.md no longer written — content lives inside spec.md.
-                        // SPEC-461: No progress.md, no HTML reports.
+                        // SPEC-709/SPEC-461: unified spec.md; no progress or HTML artifacts.
                     }
                     catch (writeErr) {
-                        // Clean up partial files to avoid orphaned spec directories
-                        await rm(specDir, { recursive: true, force: true });
+                        const storeRolledBack = storeCreated
+                            ? await specStore.deleteSpec(projectId, spec.id).catch(() => false)
+                            : true;
+                        await cleanupExecutionArtifact(getIdempotencyEvidencePath(resolvedPath, idempotencyKey), { force: true });
+                        await cleanupExecutionArtifact(specDir, { recursive: true, force: true });
+                        try {
+                            operationJournal.resolveRecovery('create_spec', operationKey, {
+                                action: storeRolledBack ? 'rollback' : 'quarantine',
+                                reason: storeRolledBack
+                                    ? 'create_spec persistence failed and compensating cleanup completed'
+                                    : 'create_spec persistence failed and the spec store rollback was incomplete',
+                            });
+                        }
+                        catch {
+                            // The original persistence failure remains the primary error.
+                        }
                         throw writeErr;
                     }
-                    // Persist only explicit out-of-scope input.
-                    if (outOfScope.length > 0) {
-                        spec.outOfScope = outOfScope;
-                    }
-                    // Persist spec in storage
-                    // SPEC-713: measure specStore.createSpec — file lock + JSON rewrite
-                    await measureStep('specStore-createSpec', () => specStore.createSpec(projectId, spec));
                     return {
                         ok: true,
                         data: {
-                            spec,
-                            specDir,
-                            specPath,
-                            technicalPath,
-                            estimation,
-                            splitSuggestion,
-                            duplicate,
-                            projectId,
-                            agentTeamPlan,
-                            knowledge,
-                            clarificationSession,
-                            constitutionCheck,
-                            autopilot,
-                            filteredCriteria,
-                            advisoryCriteria: [
-                                ...advisoryCriteria,
-                                ...groundedTechnical.advisoryFiles.map((file) => file.path),
-                            ],
-                            actionableMetrics,
+                            committedResult,
                         },
                     };
                 }); // end withTotalBudget critical path
@@ -1041,7 +1469,7 @@ export async function handleCreateSpec(inputParams, server) {
                     claimLifecycle.retainForInFlightWork = criticalResult.warning.includes('exceeded');
                     // SPEC-770: Wait briefly for any in-flight spec write to complete, then scan for duplicates
                     await new Promise((resolve) => setTimeout(resolve, 500));
-                    const recentSpecs = await findRecentlyWrittenSpecs(resolvedPath, 2 * 60 * 1000);
+                    const recentSpecs = await findRecentlyWrittenSpecs(resolvedPath, 2 * 60 * 1000, resolvedInputParams.title);
                     const possibleDuplicates = recentSpecs.length > 0 ? recentSpecs : undefined;
                     const dupNote = possibleDuplicates
                         ? `\n\nA spec may have been created server-side: ${possibleDuplicates.map((s) => s.id).join(', ')}. Retry with the same title to return it instead of creating a duplicate.`
@@ -1050,401 +1478,42 @@ export async function handleCreateSpec(inputParams, server) {
                         content: [
                             {
                                 type: 'text',
-                                text: `❌ create_spec exceeded 25s internal budget.\n\n${criticalResult.warning}${dupNote}`,
+                                text: `❌ create_spec exceeded its ${String(criticalResult.ceilingMs)}ms internal budget.\n\n${criticalResult.warning}${dupNote}`,
                             },
                         ],
                         isError: true,
                         ...(possibleDuplicates ? { structuredContent: { possibleDuplicates } } : {}),
                     };
                 }
-                if (!criticalResult.value.ok) {
-                    return criticalResult.value.earlyReturn;
-                }
-                // Destructure critical path results for use in post-creation enrichment
-                const { spec, specDir: _specDir, specPath, 
-                // SPEC-1010 Bug A: no longer surfaced in the response payload (SSR back-migration).
-                technicalPath: _technicalPath, estimation, splitSuggestion, duplicate, projectId, agentTeamPlan, knowledge, clarificationSession, constitutionCheck, autopilot, filteredCriteria, advisoryCriteria, actionableMetrics, } = criticalResult.value.data;
-                // -----------------------------------------------------------------------
-                // Post-creation enrichment (outside 25s ceiling — best-effort, budgeted)
-                // -----------------------------------------------------------------------
-                // Auto-setup git branch (non-blocking)
-                // SPEC-713: withBudget 3s — git subprocess can be slow on large repos
-                const gitBudgetResult = await withBudget('setupGitBranch', 3_000, () => measureStep('setupGitBranch', () => setupGitBranch(projectId, spec.id)));
-                const gitSetupResult = unwrapBudget(gitBudgetResult, undefined);
-                /* v8 ignore start -- requires real git repo */
-                if (gitSetupResult) {
-                    spec.gitBranch = gitSetupResult.branch;
-                }
-                /* v8 ignore stop */
-                // Brief contradiction check (non-blocking)
-                // SPEC-713: withBudget 2s — scans all specs for contradiction keywords
-                const contradictionResult = await withBudget('checkContradictions', 2_000, () => measureStep('checkContradictions', () => checkContradictions(projectId, spec.id, description)));
-                const contradictionHint = unwrapBudget(contradictionResult, undefined);
-                // Build result (SPEC-461: lean — no progress, HTML, diagrams, scope filters)
-                const result = {
-                    // SPEC-781: async analysis running in background (external project data)
-                    pendingAnalysis: true,
-                    specId: spec.id,
-                    title: spec.title,
-                    slug: spec.slug,
-                    type: spec.type,
-                    scope: spec.scope,
-                    difficulty: spec.difficulty,
-                    risk: spec.risk,
-                    tags: spec.tags,
-                    target: spec.target,
-                    status: spec.status,
-                    gitBranch: spec.gitBranch,
-                    specPath,
-                    // SPEC-1010 Bug A — `technicalPath` no longer leaked in the response.
-                    // SSR back-migration (SPEC-752) folded technical.md into spec.md as
-                    // ## Technical; the file is never written and the field would point to
-                    // a non-existent path. Internal Spec record still carries it for
-                    // backwards-compat with stored data — that field is removed in PR-C.
-                    duplicateWarning: duplicate
-                        ? ti('spec.duplicateTitle', { title: spec.title, slug: spec.slug })
-                        : undefined,
-                    ...(constitutionCheck.warnings.length > 0
-                        ? { constitutionWarnings: constitutionCheck.warnings }
-                        : {}),
-                    ...(clarificationSession
-                        ? {
-                            linkedClarificationSession: clarificationSession.id,
-                            clarificationTopic: clarificationSession.topic,
-                            clarificationAnswersUsed: Object.keys(clarificationSession.answers).length,
-                        }
-                        : {
-                            clarificationNote: 'Spec created directly from the supplied description; no clarification session was linked.',
-                        }),
-                    message: ti('tools.create_spec.success', { id: spec.id, title: spec.title }),
-                    ...(contradictionHint ? { contradictionHint } : {}),
-                    /* v8 ignore next -- requires real git repo */
-                    ...(gitSetupResult ? { gitAutoSetup: gitSetupResult.data } : {}),
-                };
-                const advisorySignals = [];
-                if (actionableMetrics.length > 0) {
-                    result.actionableMetrics = actionableMetrics;
-                }
-                if (advisoryCriteria.length > 0) {
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'ungrounded-contract-items',
-                        kind: 'quality',
-                        message: `${String(advisoryCriteria.length)} ungrounded contract item(s) kept advisory-only.`,
-                        source: 'validator',
-                        evidence: advisoryCriteria.slice(0, 10),
-                        confidence: 0.8,
-                        surface: 'structuredContent',
-                        value: advisoryCriteria,
-                    }));
-                }
-                const splitResult = buildSplitResult(splitSuggestion, knowledge?.experienceLevel);
-                if (splitResult) {
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'split-suggestion',
-                        kind: 'complexity',
-                        message: 'Spec may benefit from splitting.',
-                        source: 'heuristic',
-                        evidence: ['spec-splitter heuristic'],
-                        confidence: 0.5,
-                        surface: 'structuredContent',
-                        value: splitResult,
-                    }));
-                }
-                // Dispatch hook event (fire-and-forget)
-                fireSpecCreatedHook(projectId, spec, params.projectPath ?? '');
-                // SPEC-781: Fire-and-forget async analysis (external project data)
-                runAutopilotAsync(spec.id, params.projectPath ?? '', description);
-                // SPEC-713: Track warnings from budgeted post-creation steps
-                const budgetWarnings = [];
-                // SPEC-461: No per-spec HTML reports — lean format
-                // SPEC-713: Run post-creation checks in parallel to reduce total wall-clock time.
-                // Each has an individual budget; results are merged into `result` after settlement.
-                const [readinessResult, qualityResult, duplicatesResult, complexityResult, priorLinksResult, nextStepsResult,] = await Promise.all([
-                    // Auto-readiness check (best-effort) — SPEC-713: 3s budget
-                    withBudget('auto-readiness', 3_000, () => measureStep('auto-readiness', () => checkSpecReadiness(spec, 'lenient'))),
-                    // SPEC-492: Spec quality score (0-100) — SPEC-713: 2s budget
-                    withBudget('quality-score', 2_000, () => measureStep('quality-score', () => runQualityScore(spec).then((r) => r ?? null))),
-                    // SPEC-514: Semantic duplicate detection — SPEC-713: 2s budget
-                    withBudget('duplicate-detection', 2_000, () => measureStep('duplicate-detection', async () => {
-                        const allSpecs = await specStore.listSpecs(projectId);
-                        const recentSpecs = allSpecs.slice(-200).filter((s) => s.id !== spec.id);
-                        return findSimilarSpecs(spec.title, recentSpecs, { threshold: 0.3, topN: 3 });
-                    })),
-                    // SPEC-614 AC4: complexity-category hint — SPEC-713: 2s budget
-                    withBudget('complexity-advice', 2_000, () => measureStep('complexity-advice', () => runComplexityAdvice(projectId, spec.id, spec.tags, filteredCriteria.length))),
-                    // SPEC-615: prior-decision links — SPEC-713: 2s budget
-                    withBudget('prior-decisions', 2_000, () => measureStep('prior-decisions', () => runPriorDecisionsHint(projectId, description, spec.tags))),
-                    // Post-creation suggestions — SPEC-713: 3s budget
-                    withBudget('post-creation-suggestions', 3_000, () => measureStep('post-creation-suggestions', () => generatePostCreationSuggestions(params.projectPath ?? '', description, knowledge ?? undefined))),
-                ]);
-                // Merge parallel results into `result`
-                if (!readinessResult.exceeded) {
-                    const readiness = readinessResult.value;
-                    result.autoReadiness = { score: readiness.score, isReady: readiness.ready };
-                }
-                else {
-                    budgetWarnings.push(readinessResult.warning);
-                }
-                const qualityValue = unwrapBudget(qualityResult, null, budgetWarnings);
-                if (qualityValue !== null) {
-                    result.qualityScore = qualityValue;
-                }
-                // SPEC-485: Simplicity autopilot — detect over-engineering signals (best-effort, sync)
-                const simplicityResult = runSimplicityCheck([params.description, ...filteredCriteria].join('\n'), estimation.devHours);
-                if (simplicityResult) {
-                    result.simplicityCheck = simplicityResult;
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'simplicity-check',
-                        kind: 'simplicity',
-                        message: `Simplicity recommendation: ${simplicityResult.recommendation}.`,
-                        source: 'heuristic',
-                        evidence: simplicityResult.signals.map((signal) => signal.type),
-                        confidence: 0.55,
-                        surface: 'structuredContent',
-                        value: simplicityResult,
-                        deprecatedAlias: 'simplicityCheck',
-                    }));
-                }
-                // SPEC-514: duplicate results
-                const possibleDuplicates = unwrapBudget(duplicatesResult, [], budgetWarnings);
-                if (possibleDuplicates.length > 0) {
-                    result.possibleDuplicates = possibleDuplicates;
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'possible-duplicates',
-                        kind: 'duplicate',
-                        message: `${String(possibleDuplicates.length)} possible duplicate spec(s) detected.`,
-                        source: 'heuristic',
-                        evidence: possibleDuplicates.map((dup) => dup.specId),
-                        confidence: 0.5,
-                        surface: 'structuredContent',
-                        value: possibleDuplicates,
-                        deprecatedAlias: 'possibleDuplicates',
-                    }));
-                }
-                // SPEC-222 Trigger 2: Auto-challenge hint for high-risk specs
-                if (spec.risk === 'high' || spec.difficulty >= 4) {
-                    result.riskWarning = HIGH_RISK_WARNING;
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'risk-warning',
-                        kind: 'challenge',
-                        message: 'High-risk heuristic warning generated.',
-                        source: 'heuristic',
-                        evidence: [`risk:${spec.risk}`, `difficulty:${String(spec.difficulty)}`],
-                        confidence: 0.6,
-                        surface: 'structuredContent',
-                        value: HIGH_RISK_WARNING,
-                        deprecatedAlias: 'riskWarning',
-                    }));
-                }
-                // SPEC-614 AC4: complexity advice
-                const cAdvice = unwrapBudget(complexityResult, null, budgetWarnings);
-                if (cAdvice) {
-                    result.complexityAdvice = cAdvice;
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'complexity-advice',
-                        kind: 'complexity',
-                        message: cAdvice.reasoning,
-                        source: 'history',
-                        evidence: [`similarSpecs:${String(cAdvice.similarSpecsCount)}`],
-                        confidence: 0.6,
-                        surface: 'structuredContent',
-                        value: cAdvice,
-                        deprecatedAlias: 'complexityAdvice',
-                    }));
-                }
-                // SPEC-615: prior decisions
-                const priorLinks = unwrapBudget(priorLinksResult, [], budgetWarnings);
-                if (priorLinks.length > 0) {
-                    result.priorDecisions = priorLinks.map((l) => l.decisionId);
-                    spec.priorDecisions = result.priorDecisions;
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'prior-decisions',
-                        kind: 'prior-decision',
-                        message: `${String(priorLinks.length)} prior decision link(s) found.`,
-                        source: 'history',
-                        evidence: priorLinks.map((link) => link.decisionId),
-                        confidence: 0.65,
-                        surface: 'structuredContent',
-                        value: result.priorDecisions,
-                        deprecatedAlias: 'priorDecisions',
-                    }));
-                }
-                // Post-creation suggestions
-                const nextSteps = unwrapBudget(nextStepsResult, [], budgetWarnings);
-                if (nextSteps.length > 0) {
-                    result.nextSteps = nextSteps;
-                }
-                // SPEC-713: Surface budget warnings in result when steps exceeded their budget
-                if (budgetWarnings.length > 0) {
-                    result.budgetWarnings = budgetWarnings;
-                }
-                // SPEC-1017: No auto-regeneration of project-tree dashboard HTML.
-                if (params.projectPath) {
-                    notifyStoreChange(params.projectPath, 'specs');
-                }
-                // SPEC-644: Refresh model mapping TTL in background (fire-and-forget)
-                void import('../engine/model-tier-resolver.js')
-                    .then(({ triggerModelMappingRefresh }) => {
-                    triggerModelMappingRefresh(knowledge?.projectPath ?? params.projectPath ?? '');
-                })
-                    .catch(() => {
-                    /* best-effort */
-                });
-                // Auto post-creation pipeline: challenge + readiness (SPEC-445).
-                // Keep it observable and bounded so users see the actual result instead of
-                // background work that may finish invisibly after the tool already returned.
-                const pipelineResult = await runAutoPostCreatePipeline(spec.id, projectId, knowledge?.projectPath ?? params.projectPath ?? '');
-                // Build markdown response
-                const lines = [
-                    `**SPEC-${spec.id}** — ${spec.title}`,
-                    '',
-                    `| Field | Value |`,
-                    `|-------|-------|`,
-                    `| Type | ${spec.type} |`,
-                    `| Scope | ${spec.scope} |`,
-                    `| Difficulty | ${String(spec.difficulty)}/5 |`,
-                    `| Risk | ${spec.risk} |`,
-                    `| Target | ${spec.target} |`,
-                    `| Status | ${spec.status} |`,
-                    `| Tags | ${spec.tags.join(', ')} |`,
-                ];
-                if (spec.gitBranch) {
-                    lines.push(`| Branch | \`${spec.gitBranch}\` |`);
-                }
-                if (duplicate) {
-                    lines.push('', `⚠️ ${ti('spec.duplicateTitle', { title: spec.title, slug: spec.slug })}`);
-                }
-                if (constitutionCheck.warnings.length > 0) {
-                    lines.push('', '⚠️ **Constitution Warnings**');
-                    constitutionCheck.warnings.forEach((w) => lines.push(`- ${w.description}`));
-                }
-                if (contradictionHint) {
-                    lines.push('', `⚠️ ${contradictionHint}`);
-                }
-                if (possibleDuplicates.length > 0 ||
-                    result.riskWarning ||
-                    splitResult ||
-                    result.qualityScore ||
-                    simplicityResult) {
-                    lines.push('', 'Advisory signals were computed and are available in structuredContent.advisorySignals.');
-                }
-                const allNextSteps = (result.nextSteps ?? []).map((step) => (typeof step === 'string' ? step : formatPostCreationSuggestion(step)));
-                const markdownText = allNextSteps.length > 0
-                    ? addNextSteps(formatSuccess(ti('tools.create_spec.success', { id: spec.id, title: spec.title }), lines.join('\n')), allNextSteps)
-                    : formatSuccess(ti('tools.create_spec.success', { id: spec.id, title: spec.title }), lines.join('\n'));
-                // SPEC-469: Build autopilot summary from analyzer results
-                const collector = new AutopilotSummaryCollector();
-                if (autopilot.detectedPatterns.length > 0) {
-                    collector.pushOk('pattern-detection', `Detected patterns: ${autopilot.detectedPatterns.join(', ')}`);
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'detected-patterns',
-                        kind: 'domain',
-                        message: `Detected patterns: ${autopilot.detectedPatterns.join(', ')}`,
-                        source: 'heuristic',
-                        evidence: autopilot.detectedPatterns,
-                        confidence: 0.5,
-                        surface: 'structuredContent',
-                        value: autopilot.detectedPatterns,
-                    }));
-                }
-                const totalSuggestedFiles = autopilot.suggestedFiles.create.length +
-                    autopilot.suggestedFiles.modify.length +
-                    autopilot.suggestedFiles.test.length;
-                if (totalSuggestedFiles > 0) {
-                    collector.pushOk('file-analysis', `Suggested ${String(totalSuggestedFiles)} files (${String(autopilot.suggestedFiles.create.length)} create, ${String(autopilot.suggestedFiles.modify.length)} modify, ${String(autopilot.suggestedFiles.test.length)} test)`);
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'suggested-files',
-                        kind: 'file',
-                        message: `${String(totalSuggestedFiles)} possible related file(s) detected.`,
-                        source: 'heuristic',
-                        evidence: [
-                            ...autopilot.suggestedFiles.create.map((f) => f.path),
-                            ...autopilot.suggestedFiles.modify.map((f) => f.path),
-                            ...autopilot.suggestedFiles.test.map((f) => f.path),
-                        ],
-                        confidence: 0.45,
-                        surface: 'structuredContent',
-                        value: {
-                            create: autopilot.suggestedFiles.create.map((f) => f.path),
-                            modify: autopilot.suggestedFiles.modify.map((f) => f.path),
-                            test: autopilot.suggestedFiles.test.map((f) => f.path),
+                if (criticalResult.status === 'failed') {
+                    return {
+                        content: [{ type: 'text', text: criticalResult.warning }],
+                        isError: true,
+                        structuredContent: {
+                            error: 'OPERATION_FAILED',
+                            category: criticalResult.category,
+                            elapsedMs: criticalResult.elapsedMs,
+                            persisted: false,
                         },
-                        deprecatedAlias: 'autopilotSummary.suggestedFiles',
-                    }));
-                }
-                if (filteredCriteria.length > 0) {
-                    collector.pushOk('criteria-enrichment', `Evaluated ${String(filteredCriteria.length)} proposed criteria; only directly grounded items entered the contract`);
-                }
-                if (pipelineResult.challengeSummary) {
-                    collector.pushOk('challenge', `Challenge analysis complete: ${pipelineResult.challengeSummary}`);
-                }
-                if (pipelineResult.readinessScore !== null) {
-                    collector.pushOk('readiness', `Readiness score: ${String(pipelineResult.readinessScore)}/100`);
-                    advisorySignals.push(makeAdvisorySignal({
-                        key: 'readiness-score',
-                        kind: 'readiness',
-                        message: `Readiness score: ${String(pipelineResult.readinessScore)}/100.`,
-                        source: 'validator',
-                        evidence: ['auto post-creation pipeline'],
-                        confidence: 0.6,
-                        surface: 'structuredContent',
-                        value: pipelineResult.readinessScore,
-                    }));
+                    };
                 }
-                const humanSummary = `Plan created for "${spec.title}". Review the grounded criteria before approval.`;
-                result.advisorySignals = advisorySignals;
-                result.compat = buildAdvisoryCompat();
-                const compactResult = compactObj(result);
-                // SPEC-722: Issue a planner token for this spec creation.
-                // Best-effort — token failure never blocks spec creation.
-                let plannerToken;
-                try {
-                    const resolvedProjectPath = resolvedInputParams.projectPath ?? '';
-                    if (resolvedProjectPath.length > 0) {
-                        const sessionId = resolvedInputParams.sessionId ?? 'unknown-session';
-                        const modelId = resolvedInputParams.modelId ?? 'unknown-model';
-                        const host = resolvedInputParams.host ?? 'unknown-host';
-                        plannerToken = await issuePlannerToken(resolvedProjectPath, spec.id, sessionId, modelId, host);
-                    }
+                if (!criticalResult.value.ok) {
+                    return criticalResult.value.earlyReturn;
                 }
-                catch {
-                    // best-effort — token issuance failure must not block spec creation
+                if (!claimLifecycle.committed) {
+                    throw new Error('create_spec critical path completed without a durable commit');
                 }
-                // SPEC-1011 Bug E / fallback hardening: surface local file analysis in the response payload.
-                // Those paths are also written into ## Files only when used as technical evidence.
-                const suggestedFilesPayload = autopilot.suggestedFiles.create.length +
-                    autopilot.suggestedFiles.modify.length +
-                    autopilot.suggestedFiles.test.length >
-                    0
-                    ? {
-                        create: autopilot.suggestedFiles.create.map((f) => f.path),
-                        modify: autopilot.suggestedFiles.modify.map((f) => f.path),
-                        test: autopilot.suggestedFiles.test.map((f) => f.path),
-                    }
-                    : undefined;
-                const baseResult = toolResult(markdownText, {
-                    ...compactResult,
-                    advisorySignals,
-                    compat: buildAdvisoryCompat(),
-                    humanSummary,
-                    ...(collector.hasEntries() ? { autopilotSummary: collector.getMessages() } : {}),
-                    ...(suggestedFilesPayload !== undefined
-                        ? { 'autopilotSummary.suggestedFiles': suggestedFilesPayload }
-                        : {}),
-                    ...(agentTeamPlan && agentTeamPlan.roles.length > 0 ? { agentTeamPlan } : {}),
-                    ...(plannerToken !== undefined ? { plannerToken } : {}),
-                });
-                return {
-                    ...baseResult,
-                    content: [...baseResult.content, { type: 'text', text: humanSummary }],
-                };
+                return finishRecoveredOperation(operationJournal, operationKey, criticalResult.value.data.committedResult);
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                return {
+                const errorResult = {
                     content: [{ type: 'text', text: ti('errors.internalError', { message }) }],
                     isError: true,
                 };
+                return claimLifecycle.committed
+                    ? finishRecoveredOperation(operationJournal, operationKey, errorResult)
+                    : errorResult;
             }
         }); // end trackCost
     }
@@ -1452,6 +1521,7 @@ export async function handleCreateSpec(inputParams, server) {
         if (!claimLifecycle.committed && !claimLifecycle.retainForInFlightWork) {
             await releaseIdempotencyClaim(resolvedPath, idempotencyKey, idempotencyClaim.ownerId);
         }
+        runtimeDatabase.close();
     }
 }
 //# sourceMappingURL=create-spec.js.map