@planu/cli 4.12.3 → 4.14.1

package/dist/tools/create-spec.js

@@ -3,17 +3,13 @@ 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';
@@ -22,22 +18,25 @@ import { appendImplementationContractIfMissing } from '../engine/implementation-
 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 { 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 +87,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 +166,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);
@@ -224,35 +188,6 @@ function buildAdvisoryCompat() {
 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;
-    }
-}
 /** SPEC-783: Synthesize agent team findings into unified spec.md ## Technical section. */
 async function handleAgentTeamSynthesis(specId, projectPath, findings) {
     try {
@@ -296,7 +231,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 +246,136 @@ 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');
+}
+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 committed.`, {
+        operationId: input.operationId,
+        committed: true,
+        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 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;
+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 +495,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 +520,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 +589,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 +626,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 +637,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 +647,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 };
         }
@@ -702,6 +813,19 @@ function checkEnglishOnlyInput(params) {
 }
 // eslint-disable-next-line max-lines-per-function
 export async function handleCreateSpec(inputParams, server) {
+    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 {
@@ -758,16 +882,85 @@ export async function handleCreateSpec(inputParams, server) {
         return gateError;
     }
     // SPEC-770: Idempotency check — return existing spec if same title+projectPath within 10 minutes
-    const idempotencyKey = computeIdempotencyKey(inputParams.title, resolvedPath);
+    const idempotencyKey = computeIdempotencyKey(inputParams.title, resolvedPath, inputParams.idempotencyKey);
+    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();
+        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,7 +978,13 @@ 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,
+        });
+        // eslint-disable-next-line max-lines-per-function -- cohesive transactional create boundary
         return await trackCost(resolvedInputParams.projectPath ?? '', 'create_spec', async () => {
             // Allow internal re-enrichment without mutating function parameter
             let params = resolvedInputParams;
@@ -793,8 +992,8 @@ export async function handleCreateSpec(inputParams, server) {
             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 () => {
+                // Durable post-commit work is delegated to the spec.created outbox consumer.
+                const criticalResult = await withTotalBudget('create_spec-critical', getRuntimePolicy().createSpec.criticalTimeoutMs, async (criticalSignal) => {
                     // Build spec context (ID, estimation, diagrams, scope filters)
                     const buildResult = await measureStep('buildSpecContext', () => buildSpecContext(params));
                     if (!buildResult.ok) {
@@ -806,7 +1005,7 @@ export async function handleCreateSpec(inputParams, server) {
                             },
                         };
                     }
-                    const { spec, specDir, specPath, technicalPath, estimation, splitSuggestion, duplicate, projectId, agentTeamPlan, } = buildResult.context;
+                    const { spec, specDir, specPath, estimation, splitSuggestion, duplicate, projectId } = buildResult.context;
                     // Kept in external store/evidence for retries; the value-only serializer omits it.
                     spec.idempotencyKey = idempotencyKey;
                     // Load project knowledge and clarification session
@@ -819,11 +1018,11 @@ export async function handleCreateSpec(inputParams, server) {
                     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());
+                    // Full project-wide analysis is delivered by the durable spec.created outbox consumer.
+                    // A tiny inline budget preserves deterministic idea/clarification behavior when the
+                    // answer is immediately available without allowing repository scans to delay ACK.
+                    const inlineAnalysis = await withBudget('create-spec-inline-analysis', getRuntimePolicy().createSpec.inlineAnalysisBudgetMs, (signal) => analyzeProjectForSpec(params.projectPath ?? '', description, spec.title, knowledge, signal));
+                    const autopilot = unwrapBudget(inlineAnalysis, getEmptyAutopilotResult());
                     // If very vague (<10 words), capture as idea instead of spec
                     if (autopilot.isIdea) {
                         return {
@@ -923,8 +1122,6 @@ export async function handleCreateSpec(inputParams, server) {
                         generatedSpecBody: generatedSpec.specBody,
                         generatedTechnicalSection: generatedSpec.technicalSection,
                         projectPath: params.projectPath ?? '',
-                        autopilot,
-                        fallbackReason: generatedSpec.fallbackReason,
                     }));
                     const groundedTechnical = await measureStep('groundTechnicalFiles', () => groundTechnicalFiles({
                         files: technicalFiles,
@@ -990,49 +1187,87 @@ export async function handleCreateSpec(inputParams, server) {
                             },
                         };
                     }
+                    // Contradiction analysis is durable post-commit work. Its synchronous scanners can
+                    // block the event loop, so it must never run on the persistence acknowledgement path.
+                    const contradictionHint = undefined;
+                    const committedSimplicity = runSimplicityCheck([params.description, ...filteredCriteria].join('\n'), estimation.devHours);
+                    if (outOfScope.length > 0) {
+                        spec.outOfScope = outOfScope;
+                    }
+                    let committedPlannerToken;
+                    try {
+                        committedPlannerToken = await issuePlannerToken(resolvedPath, spec.id, params.sessionId ?? 'unknown-session', params.modelId ?? 'unknown-model', params.host ?? 'unknown-host');
+                    }
+                    catch {
+                        // Best-effort evidence must not block durable spec creation.
+                    }
+                    const committedResult = buildCommittedCreateResult({
+                        spec,
+                        operationId: operationKey,
+                        duplicate,
+                        constitutionWarnings: constitutionCheck.warnings,
+                        clarificationSession,
+                        advisoryCriteria,
+                        actionableMetrics,
+                        splitSuggestion,
+                        experienceLevel: knowledge?.experienceLevel,
+                        contradictionHint,
+                        simplicityResult: committedSimplicity,
+                        plannerToken: committedPlannerToken,
+                    });
+                    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;
+                        if (storeRolledBack) {
+                            await cleanupExecutionArtifact(getIdempotencyEvidencePath(resolvedPath, idempotencyKey), {
+                                force: true,
+                            });
+                            await cleanupExecutionArtifact(specDir, { recursive: true, force: true });
+                        }
                         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
@@ -1060,391 +1295,20 @@ export async function handleCreateSpec(inputParams, server) {
                 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 (!claimLifecycle.committed) {
+                    throw new Error('create_spec critical path completed without a durable commit');
                 }
-                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),
-                        },
-                        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);
-                    }
-                }
-                catch {
-                    // best-effort — token issuance failure must not block spec creation
-                }
-                // 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 +1316,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