@devflow-tools/delivery-line 0.18.19 → 0.18.21

package/dist/facade/delivery-line-facade.js

@@ -32,9 +32,17 @@ function nextActionsFor(record) {
         nextActions.push('compare_options');
     if (['clarifying', 'spec_ready', 'plan_ready', 'reviewed'].includes(record.stage))
         nextActions.push('approve');
-    if (['plan_approved', 'executing', 'needs_changes', 'held', 'blocked'].includes(record.stage))
+    if (record.blockers?.some(blocker => blocker.code === 'WORKTREE_ADMISSION_REQUIRED'))
+        nextActions.push('admit_worktree');
+    else if (record.blockers?.some(blocker => blocker.code === 'STALE_STACK_FACTS'))
+        nextActions.push('refresh_activation');
+    else if (record.blockers?.some(blocker => blocker.code === 'EXTERNAL_CANDIDATE_REQUIRED'))
+        nextActions.push('import_external_change');
+    else if (['plan_approved', 'executing', 'needs_changes', 'held', 'blocked'].includes(record.stage))
         nextActions.push('resume');
-    if (record.stage === 'failed')
+    if (record.tasks.some(task => task.status === 'running' || task.status === 'merge_pending') || record.blockers?.some(blocker => blocker.code === 'WORKER_RECONCILIATION_INCONCLUSIVE'))
+        nextActions.push('recover_task');
+    if (record.stage === 'failed' && (record.blockers?.some(blocker => blocker.retryable) ?? true))
         nextActions.push('retry_task');
     if (record.stage === 'release_pending')
         nextActions.push('export');
@@ -95,17 +103,6 @@ export class DeliveryLineFacade {
             if (input.caseId)
                 return this.status(id);
         }
-        if (this.ports.revision?.inspectWorktree) {
-            const worktree = await this.ports.revision.inspectWorktree({ repositoryPath: projectRoot, baseRevision: baseRef });
-            if (worktree.dirtyFiles.length > 0) {
-                throw new DeliveryLineError('MISSING_PREREQUISITE', 'delivery requires a clean worktree before case creation', {
-                    dirtyFiles: worktree.dirtyFiles,
-                    baseRevision: baseRef,
-                    currentRevision: worktree.currentRevision,
-                    recoveryAction: 'stash or commit existing changes, then create the Delivery case again',
-                });
-            }
-        }
         let contextReceipt = input.contextReceipt;
         let contextQuality;
         if (this.ports.context) {
@@ -125,22 +122,45 @@ export class DeliveryLineFacade {
                 throw new DeliveryLineError('MISSING_PREREQUISITE', 'context receipt is not authoritative');
             contextReceipt = bound.receiptHash;
             if (bound.channelStatus && bound.gaps && bound.attribution)
-                contextQuality = { blocking: bound.blocking ?? false, ...(bound.channelAvailability ? { channelAvailability: bound.channelAvailability } : {}), channelStatus: bound.channelStatus, gaps: bound.gaps, attribution: bound.attribution };
+                contextQuality = { blocking: bound.blocking ?? false, ...(bound.channelAvailability ? { channelAvailability: bound.channelAvailability } : {}), channelStatus: bound.channelStatus, gaps: bound.gaps, attribution: bound.attribution, ...('quality' in bound && bound.quality ? { quality: bound.quality } : {}) };
         }
         if (!contextReceipt)
             throw new DeliveryLineError('MISSING_PREREQUISITE', 'context receipt is required when authoritative retrieval is not configured');
         const now = Date.now();
         const riskTier = input.riskSignals?.some(signal => /auth|scope|security|database|gateway|release/i.test(signal)) ? 'high' : input.riskTier ?? 'low';
+        const worktreeMode = input.worktreeMode ?? 'isolated';
+        const admission = await this.ports.worktreeAdmission?.inspect({ projectRoot });
+        const stackFacts = await this.ports.stackFacts?.inspect({ projectRoot });
+        const runtimeProjection = await this.ports.runtimeActivation?.capture({ projectRoot, sessionId: input.sessionId, executionId: input.executionId, revision: baseRef }) ?? {
+            host: 'external', provider: 'none', model: 'none', permissions: { mode: 'external-candidate-only' }, probeReceiptHash: 'not-applicable',
+        };
+        const activationBody = {
+            schemaVersion: 'delivery-runtime-activation.v1',
+            projectRoot, sessionId: input.sessionId, executionId: input.executionId, revision: baseRef,
+            ...runtimeProjection,
+            contextReceiptHash: contextReceipt,
+            stackFactsHash: stackFacts?.fingerprint ?? hash({ projectRoot, baseRef }),
+            pluginSelectionHash: hash({ selectedPlugins: stackFacts?.selectedPlugins ?? [], selectedRunners: stackFacts?.selectedRunners ?? [] }),
+            createdAt: now,
+        };
+        const admissionBlocked = Boolean(admission && !admission.clean && (worktreeMode === 'auto' || worktreeMode === 'clean'));
         const record = {
             id, projectRoot, baseRef, integrationRef: `refs/devflow/delivery/${id}`, targetRef: input.targetRef,
             title: input.title, source: input.source ?? 'human', riskTier, autonomy: input.autonomy ?? 'manual', stage: 'clarifying',
             budgets: { ...defaults, ...input.budgets }, artifacts: [], tasks: [], approvals: [], decisions: [], evidence: [],
             approvalStates: {},
             interaction: { phase: 'clarification', status: 'awaiting_user', turn: 1, openQuestions: [input.existingImplementations?.length ? `Existing implementations were detected (${input.existingImplementations.join(', ')}). Which implementation should be extended, replaced, or retained?` : 'What outcome and acceptance criteria should this change satisfy?'], blockingUnknowns: [input.existingImplementations?.length ? `Existing implementations were detected (${input.existingImplementations.join(', ')}). Which implementation should be extended, replaced, or retained?` : 'What outcome and acceptance criteria should this change satisfy?'], summaryRefs: [] },
-            createdBy: input.actor, sessionId: input.sessionId, executionId: input.executionId, createdAt: now, updatedAt: now, version: 0, contextReceipt,
+            createdBy: input.actor, sessionId: input.sessionId, executionId: input.executionId, createdAt: now, updatedAt: now, version: 0, contextReceipt, worktreeMode,
+            runtimeActivation: { ...activationBody, snapshotHash: hash(activationBody) },
             ...(input.existingImplementations?.length ? { existingImplementations: [...input.existingImplementations] } : {}),
             ...(contextQuality ? { contextQuality } : {}),
+            ...(stackFacts ? { stackFacts: { ...stackFacts, capturedAt: now } } : {}),
         };
+        if (admissionBlocked) {
+            record.stage = 'held';
+            record.interaction.status = 'paused';
+            record.blockers = [{ code: 'WORKTREE_ADMISSION_REQUIRED', message: 'The project worktree contains uncommitted changes.', responsibleRole: 'delivery-owner', requiredRole: 'delivery-owner', artifactRefs: [], evidenceRefs: [], recoveryAction: 'Choose isolated, external, or clean admission before continuing.', retryable: true, diagnostics: { dirtyFiles: admission?.dirtyFiles ?? [], actions: ['isolated', 'external', 'clean'], currentRevision: admission?.revision, baseRevision: baseRef, admissionToken: hash({ projectRoot, baseRef, currentRevision: admission?.revision, dirtyFiles: admission?.dirtyFiles ?? [] }) } }];
+        }
         await this.ports.store.create(record);
         await appendLedgerEvent(this.ports.store, { caseId: id, type: 'case.created', actor: input.actor, idempotencyKey: input.idempotencyKey, payload: { stage: record.stage } });
         return this.view(record);
@@ -170,6 +190,8 @@ export class DeliveryLineFacade {
     async answer(caseId, input) {
         requireIdentity(input);
         return this.mutate(caseId, input, 'interaction.answered', async (record) => {
+            if (!['clarifying', 'designing'].includes(record.stage))
+                throw new DeliveryLineError('INVALID_TRANSITION', 'interaction answers are only accepted during clarification or design', { currentStage: record.stage, allowedStages: ['clarifying', 'designing'] });
             if (input.turn !== record.interaction.turn)
                 throw staleTurnError(record, input.turn);
             if (record.interaction.turn >= record.budgets.maxInteractionTurns) {
@@ -200,6 +222,9 @@ export class DeliveryLineFacade {
     async revise(caseId, input) {
         requireIdentity(input);
         return this.mutate(caseId, input, 'interaction.revised', record => {
+            const allowedStages = input.phase === 'clarification' ? ['draft', 'clarifying'] : ['designing'];
+            if (!allowedStages.includes(record.stage))
+                throw new DeliveryLineError('INVALID_TRANSITION', `${input.phase} revisions are not allowed at ${record.stage}`, { currentStage: record.stage, requestedPhase: input.phase, allowedStages });
             const stage = input.phase === 'clarification' ? 'clarifying' : 'designing';
             const next = invalidateDownstream(stage, record);
             next.interaction = { ...next.interaction, phase: input.phase, status: 'awaiting_user', turn: next.interaction.turn + 1, openQuestions: [input.content], blockingUnknowns: [input.content] };
@@ -244,11 +269,11 @@ export class DeliveryLineFacade {
                 });
                 record.contextReceipt = designerReceipt.receiptHash;
                 if (designerReceipt.channelStatus && designerReceipt.gaps && designerReceipt.attribution)
-                    record.contextQuality = { blocking: designerReceipt.blocking ?? false, ...(designerReceipt.channelAvailability ? { channelAvailability: designerReceipt.channelAvailability } : {}), channelStatus: designerReceipt.channelStatus, gaps: designerReceipt.gaps, attribution: designerReceipt.attribution };
+                    record.contextQuality = { blocking: designerReceipt.blocking ?? false, ...(designerReceipt.channelAvailability ? { channelAvailability: designerReceipt.channelAvailability } : {}), channelStatus: designerReceipt.channelStatus, gaps: designerReceipt.gaps, attribution: designerReceipt.attribution, ...('quality' in designerReceipt && designerReceipt.quality ? { quality: designerReceipt.quality } : {}) };
             }
             const decisionHash = hash({ questionId, optionId, selectedLabel, optionsSnapshot });
             record.decisions.push({ id: randomUUID(), kind: 'technical', questionId, question: 'Which implementation option should Delivery execute?', options: optionsSnapshot.map(option => option.label), optionsSnapshot, optionId, selectedLabel, decisionHash, sessionId: input.sessionId, toolUseId: input.toolUseId, decision: selectedLabel, decidedBy: input.actor, artifactHash: decisionHash });
-            const stackFactsHash = hash({ projectRoot: record.projectRoot, baseRef: record.baseRef, targetRef: record.targetRef });
+            const stackFactsHash = record.stackFacts?.fingerprint ?? record.runtimeActivation?.stackFactsHash ?? record.stackFactsHash ?? hash({ projectRoot: record.projectRoot, baseRef: record.baseRef, targetRef: record.targetRef });
             const selectedCapabilities = this.capabilities?.manifests.length
                 ? selectPluginCapabilities({
                     detectedStacks: this.capabilities.detectedStacks,
@@ -258,7 +283,9 @@ export class DeliveryLineFacade {
                 : undefined;
             const pluginManifestHash = selectedCapabilities?.selectedManifestHash ?? hash({ capability: selectedLabel, protocolVersion: 'delivery-capability.v1' });
             record.stackFactsHash = stackFactsHash;
-            record.pluginSelection = { selectedManifestHash: pluginManifestHash, stackFactsHash, decisionRefs: [decisionHash], selectionReason: selectedCapabilities?.selectionReason ?? 'selected by current user decision', rejectedAlternatives: [...new Set([...(selectedCapabilities?.rejectedAlternatives ?? []), ...optionsSnapshot.filter(option => option.id !== optionId).map(option => option.id)])], selectedAt: Date.now() };
+            const requiredContextChannels = [...new Set(Object.values(selectedCapabilities?.selected ?? {}).flatMap(manifest => manifest.requiredContextChannels))]
+                .filter((channel) => ['code', 'memory', 'knowledge'].includes(channel));
+            record.pluginSelection = { selectedManifestHash: pluginManifestHash, stackFactsHash, decisionRefs: [decisionHash], selectionReason: selectedCapabilities?.selectionReason ?? 'selected by current user decision', rejectedAlternatives: [...new Set([...(selectedCapabilities?.rejectedAlternatives ?? []), ...optionsSnapshot.filter(option => option.id !== optionId).map(option => option.id)])], ...(requiredContextChannels.length ? { requiredContextChannels } : {}), selectedAt: Date.now() };
             await this.createProjectionArtifact(record, 'plugin-selection.md', 'Plugin selection', 'Capability providers selected by Delivery from stack facts and the current decision.', record.pluginSelection, input.actor);
             record.stage = 'spec_ready';
             record.interaction = { ...record.interaction, phase: 'design', status: 'awaiting_approval', openQuestions: [], blockingUnknowns: [] };
@@ -282,6 +309,7 @@ export class DeliveryLineFacade {
                 if (this.ports.context) {
                     const plannerReceipt = await this.ports.context.build({
                         role: 'planner',
+                        ...(record.pluginSelection?.requiredContextChannels?.length ? { requiredChannels: record.pluginSelection.requiredContextChannels } : {}),
                         retrieval: {
                             taskRevision: record.version + 1,
                             projectRoot: record.projectRoot,
@@ -294,7 +322,7 @@ export class DeliveryLineFacade {
                     });
                     record.contextReceipt = plannerReceipt.receiptHash;
                     if (plannerReceipt.channelStatus && plannerReceipt.gaps && plannerReceipt.attribution)
-                        record.contextQuality = { blocking: plannerReceipt.blocking ?? false, ...(plannerReceipt.channelAvailability ? { channelAvailability: plannerReceipt.channelAvailability } : {}), channelStatus: plannerReceipt.channelStatus, gaps: plannerReceipt.gaps, attribution: plannerReceipt.attribution };
+                        record.contextQuality = { blocking: plannerReceipt.blocking ?? false, ...(plannerReceipt.channelAvailability ? { channelAvailability: plannerReceipt.channelAvailability } : {}), channelStatus: plannerReceipt.channelStatus, gaps: plannerReceipt.gaps, attribution: plannerReceipt.attribution, ...('quality' in plannerReceipt && plannerReceipt.quality ? { quality: plannerReceipt.quality } : {}) };
                 }
                 planContent = renderPlanMarkdown(input.plan);
                 proposedArtifactHash = contentHash(planContent);
@@ -370,6 +398,9 @@ export class DeliveryLineFacade {
                         taskId: envelopes[0]?.taskId ?? '',
                         baseRevision: record.baseRef,
                         verificationEvidenceHashes: [],
+                        reviewEvidenceHashes: [],
+                        intentArtifactHash: record.artifacts.find(item => item.type === 'intent')?.contentHash,
+                        specArtifactHash: record.artifacts.find(item => item.type === 'spec')?.contentHash,
                     };
                 }
                 record.tasks = envelopes.map(envelope => ({
@@ -382,6 +413,7 @@ export class DeliveryLineFacade {
                     dependsOn: envelope.dependencies,
                     allowedFiles: envelope.allowedFiles,
                     expectedChanges: envelope.implementationSteps,
+                    acceptanceCriteria: envelope.verification.acceptanceCriteria,
                     verificationCommands: envelope.verification.commands,
                     inputArtifacts: envelope.inputArtifacts,
                     planHash: envelope.planHash,
@@ -389,6 +421,7 @@ export class DeliveryLineFacade {
                     hostSelectionSnapshotHash: envelope.hostSelectionSnapshotHash,
                     executionAuthority: envelope.executionAuthority,
                     constraints: envelope.constraints,
+                    planNodes: envelope.nodes,
                     status: 'pending',
                     evidence: [],
                 }));
@@ -413,7 +446,15 @@ export class DeliveryLineFacade {
             }
             if (record.stage === 'plan_approved')
                 record.stage = 'executing';
-            if (record.stage === 'executing') {
+            if (record.stage === 'executing' || (record.stage === 'held' && record.tasks.some(task => task.status === 'running' || task.status === 'merge_pending') && this.ports.operationJournal)) {
+                if (record.stackFacts && this.ports.stackFacts) {
+                    const currentStackFacts = await this.ports.stackFacts.inspect({ projectRoot: record.projectRoot });
+                    if (currentStackFacts.fingerprint !== record.stackFacts.fingerprint)
+                        return hold(record, { code: 'STALE_STACK_FACTS', message: 'Project stack facts changed after case creation.', responsibleRole: 'planner', requiredRole: 'planner', recoveryAction: 'Refresh stack facts and re-approve the executable plan.', retryable: false, diagnostics: { previousFingerprint: record.stackFacts.fingerprint, currentFingerprint: currentStackFacts.fingerprint } });
+                }
+                if (record.worktreeMode === 'external' && !record.evidence.some(item => item.kind === 'tool' && item.metadata.trust === 'external-untrusted' && item.metadata.imported === true)) {
+                    return hold(record, { code: 'EXTERNAL_CANDIDATE_REQUIRED', message: 'The admitted external workspace must be imported as an untrusted candidate before execution.', responsibleRole: 'delivery-owner', requiredRole: 'delivery-owner', recoveryAction: 'Commit the admitted workspace changes, then call import-change with that candidate revision.', retryable: false, diagnostics: { baseRevision: record.worktreeAdmission?.baseRevision ?? record.baseRef, currentRevision: record.worktreeAdmission?.currentRevision, dirtyFiles: record.worktreeAdmission?.dirtyFiles ?? [] } });
+                }
                 const verifier = this.ports.verification;
                 if (!this.ports.execution)
                     return hold(record, { code: 'WORKER_UNAVAILABLE', message: 'No Delivery execution adapter is configured for this case.', responsibleRole: 'execution-owner', recoveryAction: 'Configure a Delivery execution adapter or import an external change.', retryable: false });
@@ -426,6 +467,18 @@ export class DeliveryLineFacade {
                     verify: input => this.ports.verification.verify(input),
                     integrate: input => this.ports.integration.integrate(input),
                     inspectIntegration: async (input) => await this.ports.integration.inspect?.(input) ?? null,
+                    inspectWorker: this.ports.execution.inspectWorker ? (input => this.ports.execution.inspectWorker(input)) : undefined,
+                    runCapabilities: record.stackFacts?.selectedRunners?.length && this.ports.capabilities ? async ({ task, execution }) => {
+                        const receipts = [];
+                        for (const pluginName of record.stackFacts.selectedRunners) {
+                            const manifest = await this.ports.capabilities.manifest(pluginName);
+                            const receipt = await this.ports.capabilities.run({ caseId: record.id, taskId: task.id, pluginName, capability: manifest.capability, manifestHash: manifest.manifestHash, stackFactsFingerprint: record.stackFacts.fingerprint, allowedFiles: task.allowedFiles, payload: { changedFiles: execution.handoff?.changedFiles ?? [], planHash: task.planHash, contextReceiptHash: task.contextReceiptHash, baseRevision: task.baseRevision, fencingToken: task.fencingToken } });
+                            if (receipt.manifestHash !== manifest.manifestHash)
+                                throw new DeliveryLineError('ARTIFACT_HASH_MISMATCH', `plugin receipt hash mismatch: ${pluginName}`);
+                            receipts.push({ ...receipt, pluginName, capability: manifest.capability, stackFactsFingerprint: record.stackFacts.fingerprint });
+                        }
+                        return receipts;
+                    } : undefined,
                 }, this.ports.operationJournal).run(record);
                 if (record.tasks.length > 0 && record.tasks.every(task => task.status === 'integrated')) {
                     await this.createProjectionArtifact(record, 'code-evidence.md', 'Code evidence', 'Worker handoffs and changed files bound to the integrated candidate revision.', {
@@ -434,7 +487,7 @@ export class DeliveryLineFacade {
                     }, input.actor);
                     const integrationRevision = record.integrationRevision ?? record.baseRef;
                     try {
-                        const planReceipt = await verifier.verify({ caseId: record.id, integrationRef: record.integrationRef, commit: integrationRevision, planLevel: true, commands: record.tasks.flatMap(task => task.verificationCommands) });
+                        const planReceipt = await verifier.verify({ caseId: record.id, integrationRef: record.integrationRef, commit: integrationRevision, planLevel: true, commands: record.tasks.flatMap(task => task.verificationCommands), acceptanceCriteria: record.tasks.flatMap(task => task.acceptanceCriteria) });
                         if (!planReceipt.passed) {
                             record.stage = 'failed';
                             return record;
@@ -442,7 +495,7 @@ export class DeliveryLineFacade {
                         record.evidence.push(this.evidence('verification', planReceipt));
                         await this.createProjectionArtifact(record, 'verification.md', 'Verification', 'Verification evidence for the integrated revision.', { commit: planReceipt.commit, passed: planReceipt.passed, evidenceHash: hash(planReceipt) }, input.actor);
                         if (record.lineage) {
-                            record.lineage = { ...record.lineage, candidateRevision: integrationRevision, verificationEvidenceHashes: record.evidence.filter(item => item.kind === 'verification').map(item => item.hash) };
+                            record.lineage = { ...record.lineage, candidateRevision: integrationRevision, integrationRevision, verificationEvidenceHashes: record.evidence.filter(item => item.kind === 'verification').map(item => item.hash) };
                         }
                         record.stage = 'verified';
                     }
@@ -461,7 +514,10 @@ export class DeliveryLineFacade {
                     if (result.receipts.some(receipt => receipt.artifactHash !== reviewArtifactHash))
                         return hold(record, { code: 'STALE_REVIEW_EVIDENCE', message: 'Review evidence does not match the current integration revision.', responsibleRole: 'review-owner', recoveryAction: 'Run review again against the current integration revision.', retryable: true });
                     else {
-                        record.evidence.push(...result.receipts.map(receipt => this.evidence('review', receipt)));
+                        const reviewEvidence = result.receipts.map(receipt => this.evidence('review', receipt));
+                        record.evidence.push(...reviewEvidence);
+                        if (record.lineage)
+                            record.lineage = { ...record.lineage, reviewEvidenceHashes: reviewEvidence.map(item => item.hash) };
                         await this.createProjectionArtifact(record, 'review.md', 'Review', 'Independent review evidence for the integrated revision.', { artifactHash: reviewArtifactHash, passed: result.passed, receipts: result.receipts.map(receipt => receipt.id) }, input.actor);
                         if (!result.passed) {
                             record.stage = 'needs_changes';
@@ -480,9 +536,62 @@ export class DeliveryLineFacade {
             return record;
         });
     }
+    /** Explicit recovery action used after a process restart or an unknown operation receipt. */
+    async recoverTask(caseId, input) {
+        return this.resume(caseId, input);
+    }
+    async admitWorktree(caseId, input) {
+        requireIdentity(input);
+        return this.mutate(caseId, input, 'worktree.admitted', async (record) => {
+            if (record.blockers?.[0]?.code !== 'WORKTREE_ADMISSION_REQUIRED')
+                throw new DeliveryLineError('INVALID_TRANSITION', 'case is not awaiting worktree admission');
+            const expectedToken = record.blockers[0].diagnostics?.admissionToken;
+            if (typeof expectedToken !== 'string' || input.admissionToken !== expectedToken)
+                throw new DeliveryLineError('ARTIFACT_HASH_MISMATCH', 'worktree admission token is stale');
+            const admission = await this.ports.worktreeAdmission?.inspect({ projectRoot: record.projectRoot });
+            if (input.mode === 'clean' && admission && !admission.clean)
+                return hold(record, { code: 'WORKTREE_ADMISSION_REQUIRED', message: 'The project worktree is still dirty.', responsibleRole: 'delivery-owner', requiredRole: 'delivery-owner', recoveryAction: 'Clean the listed files or choose isolated/external admission.', retryable: true, diagnostics: { dirtyFiles: admission.dirtyFiles, choices: ['isolated', 'external', 'clean'] } });
+            record.worktreeMode = input.mode;
+            record.worktreeAdmission = { mode: input.mode, baseRevision: record.baseRef, currentRevision: admission?.revision, dirtyFiles: admission?.dirtyFiles ?? [], admissionToken: input.admissionToken, admittedAt: Date.now() };
+            record.stage = 'clarifying';
+            record.blockers = [];
+            record.interaction.status = 'awaiting_user';
+            return record;
+        });
+    }
+    async refreshActivation(caseId, input) {
+        requireIdentity(input);
+        return this.mutate(caseId, input, 'activation.refreshed', async (record) => {
+            if (!this.ports.stackFacts)
+                throw new DeliveryLineError('MISSING_PREREQUISITE', 'stack facts adapter is required to refresh activation');
+            const current = await this.ports.stackFacts.inspect({ projectRoot: record.projectRoot });
+            let runtimeActivation = record.runtimeActivation;
+            if (this.ports.runtimeActivation) {
+                const projection = await this.ports.runtimeActivation.capture({ projectRoot: record.projectRoot, sessionId: input.sessionId, executionId: input.executionId, revision: record.baseRef });
+                const body = {
+                    schemaVersion: 'delivery-runtime-activation.v1',
+                    projectRoot: record.projectRoot, sessionId: input.sessionId, executionId: input.executionId, revision: record.baseRef,
+                    ...projection,
+                    contextReceiptHash: record.contextReceipt ?? input.contextReceipt,
+                    stackFactsHash: current.fingerprint,
+                    pluginSelectionHash: record.pluginSelection ? hash(record.pluginSelection) : hash({ selectedPlugins: current.selectedPlugins, selectedRunners: current.selectedRunners }),
+                    createdAt: Date.now(),
+                };
+                runtimeActivation = { ...body, snapshotHash: hash(body) };
+            }
+            const changed = record.stackFacts?.fingerprint !== current.fingerprint || runtimeActivation?.snapshotHash !== record.runtimeActivation?.snapshotHash;
+            let next = changed && ['plan_approved', 'executing', 'held', 'blocked', 'failed', 'needs_changes', 'verified', 'reviewed', 'release_pending'].includes(record.stage)
+                ? invalidateDownstream('plan_ready', record) : record;
+            next.stackFacts = { ...current, capturedAt: Date.now() };
+            next.runtimeActivation = runtimeActivation;
+            next.blockers = next.blockers?.filter(blocker => blocker.code !== 'STALE_STACK_FACTS');
+            return next;
+        });
+    }
     async retryTask(caseId, input) { return this.mutate(caseId, input, 'task.retried', record => { const task = record.tasks.find(item => item.id === input.taskId); if (!task)
         throw new DeliveryLineError('MISSING_PREREQUISITE', 'task not found'); if (!['failed', 'blocked', 'needs_changes', 'verified'].includes(task.status))
-        throw new DeliveryLineError('INVALID_TRANSITION', 'task is not retryable'); task.status = 'pending'; task.integratedRevision = undefined; if (['failed', 'blocked', 'needs_changes', 'held'].includes(record.stage))
+        throw new DeliveryLineError('INVALID_TRANSITION', 'task is not retryable'); const blocker = record.blockers?.find(item => item.taskId === task.id); if (blocker && !blocker.retryable)
+        throw new DeliveryLineError('INVALID_TRANSITION', `task failure is not retryable: ${blocker.code}`); task.status = 'pending'; task.integratedRevision = undefined; record.blockers = record.blockers?.filter(item => item.taskId !== task.id); if (['failed', 'blocked', 'needs_changes', 'held'].includes(record.stage))
         record.stage = 'executing'; return record; }); }
     async importExternalChange(caseId, input) {
         requireIdentity(input);
@@ -512,7 +621,7 @@ export class DeliveryLineFacade {
             task.evidence = [];
             if (!this.ports.verification || !this.ports.integration)
                 throw new DeliveryLineError('MISSING_PREREQUISITE', 'verification and integration adapters are required for external import');
-            const verification = await this.ports.verification.verify({ caseId: record.id, taskId: task.id, projectRoot: record.projectRoot, commit: authority.candidateRevision, commands: task.verificationCommands });
+            const verification = await this.ports.verification.verify({ caseId: record.id, taskId: task.id, projectRoot: record.projectRoot, commit: authority.candidateRevision, commands: task.verificationCommands, acceptanceCriteria: task.acceptanceCriteria });
             if (!verification.passed || verification.commit !== authority.candidateRevision)
                 throw new DeliveryLineError('VERIFICATION_FAILED', 'external candidate verification failed');
             record.evidence.push(this.evidence('verification', verification));
@@ -525,7 +634,7 @@ export class DeliveryLineFacade {
             record.evidence.push({ id: randomUUID(), kind: 'merge', hash: hash(integrated), createdAt: Date.now(), metadata: integrated });
             record.stage = 'verified';
             if (record.lineage)
-                record.lineage = { ...record.lineage, candidateRevision: integrated.candidateRevision, verificationEvidenceHashes: record.evidence.filter(item => item.kind === 'verification').map(item => item.hash) };
+                record.lineage = { ...record.lineage, candidateRevision: integrated.candidateRevision, integrationRevision: integrated.candidateRevision, verificationEvidenceHashes: record.evidence.filter(item => item.kind === 'verification').map(item => item.hash) };
             return record;
         });
     }
@@ -538,10 +647,29 @@ export class DeliveryLineFacade {
                 throw new DeliveryLineError('MISSING_PREREQUISITE', 'delivery package adapter is required');
             if (record.tasks.length === 0 || record.tasks.some(task => task.status !== 'integrated' || !task.integratedRevision))
                 throw new DeliveryLineError('MISSING_PREREQUISITE', 'all tasks must be integrated before export');
+            if (!['intent', 'spec', 'plan'].every(type => record.artifacts.some(artifact => artifact.type === type)))
+                throw new DeliveryLineError('MISSING_PREREQUISITE', 'intent, spec, and plan lineage is required before export');
             if (!record.lineage || (record.tasks[0]?.planHash && record.lineage.planHash !== record.tasks[0].planHash) || record.lineage.baseRevision !== record.baseRef)
                 throw new DeliveryLineError('MISSING_PREREQUISITE', 'execution lineage is incomplete or stale');
             if (!record.evidence.some(item => item.kind === 'verification') || !record.evidence.some(item => item.kind === 'review'))
                 throw new DeliveryLineError('MISSING_PREREQUISITE', 'verification and review evidence are required before export');
+            if (!record.evidence.some(item => item.kind === 'merge' && item.metadata.candidateRevision === record.integrationRevision))
+                throw new DeliveryLineError('MISSING_PREREQUISITE', 'integration lineage is required before export');
+            const intentHash = record.artifacts.find(item => item.type === 'intent')?.contentHash;
+            const specHash = record.artifacts.find(item => item.type === 'spec')?.contentHash;
+            const currentVerificationHashes = record.evidence.filter(item => item.kind === 'verification').map(item => item.hash);
+            const currentReviewHashes = record.evidence.filter(item => item.kind === 'review').map(item => item.hash);
+            if (record.lineage.intentArtifactHash !== intentHash || record.lineage.specArtifactHash !== specHash
+                || record.lineage.integrationRevision !== record.integrationRevision
+                || record.lineage.verificationEvidenceHashes.length === 0
+                || record.lineage.verificationEvidenceHashes.some(item => !currentVerificationHashes.includes(item))
+                || record.lineage.reviewEvidenceHashes.length === 0
+                || record.lineage.reviewEvidenceHashes.some(item => !currentReviewHashes.includes(item))) {
+                throw new DeliveryLineError('MISSING_PREREQUISITE', 'execution lineage does not contain the current intent, spec, verification, review, and integration evidence');
+            }
+            for (const pluginName of record.stackFacts?.selectedRunners ?? [])
+                if (!record.evidence.some(item => item.kind === 'tool' && item.metadata.pluginName === pluginName && item.metadata.stackFactsFingerprint === record.stackFacts?.fingerprint && item.metadata.verified === true))
+                    throw new DeliveryLineError('MISSING_PREREQUISITE', `verified plugin runner lineage is missing: ${pluginName}`);
             const packageInput = { record, path: input.path };
             const operationId = `package:${record.id}:${input.idempotencyKey}`;
             const requestHash = hash({ caseId: record.id, path: input.path, integrationRevision: record.integrationRevision, artifacts: record.artifacts.map(item => item.contentHash), evidence: record.evidence.map(item => item.hash) });
@@ -593,6 +721,8 @@ export class DeliveryLineFacade {
             const packageArtifact = { id: randomUUID(), caseId: record.id, type: 'delivery-package', repoId: record.projectRoot, ref: record.integrationRef, commit: record.integrationRevision ?? record.baseRef, path: exported.path, blobHash: exported.packageHash, parentBlobHashes: record.artifacts.length ? [record.artifacts.at(-1).blobHash] : [], contentHash: exported.packageHash, createdBy: input.actor, createdAt: Date.now() };
             record.artifacts.push(packageArtifact);
             record.evidence.push({ id: randomUUID(), kind: 'export', hash: exported.packageHash, createdAt: Date.now(), metadata: { path: exported.path, packageHash: exported.packageHash, integrationRevision: record.integrationRevision, exportBindingHash: hash({ packageHash: exported.packageHash, path: exported.path, integrationRevision: record.integrationRevision }), candidateRevisions: record.tasks.map(task => task.integratedRevision) } });
+            if (record.lineage)
+                record.lineage = { ...record.lineage, exportEvidenceHash: exported.packageHash };
             record.stage = 'delivered';
             return record;
         });
@@ -651,7 +781,7 @@ export class DeliveryLineFacade {
         return this.createArtifact(record, 'interaction', content, actor, { artifactPath: path, path: path.replace(/\.md$/u, '.json'), content: `${JSON.stringify(data, null, 2)}\n` });
     }
     evidence(kind, value) { return { id: randomUUID(), kind, hash: hash(value), createdAt: Date.now(), metadata: value }; }
-    view(record) { const pendingDecisions = record.interaction.openQuestions.map((question, index) => ({ id: `${record.id}:question:${record.interaction.turn}:${index}`, kind: 'product', question, options: [], blocking: record.interaction.blockingUnknowns.includes(question), turn: record.interaction.turn })); const nextActions = nextActionsFor(record); const blockers = record.blockers ?? (['held', 'failed', 'needs_changes', 'blocked'].includes(record.stage) ? [this.defaultBlocker(record)] : []); return { caseId: record.id, currentTurn: record.interaction.turn, contextReceipt: record.contextReceipt, ...(record.contextQuality ? { contextQuality: record.contextQuality } : {}), ...(record.sessionId && record.executionId ? { canonicalIdentity: { sessionId: record.sessionId, executionId: record.executionId, actorId: record.createdBy.id } } : {}), stage: record.stage, pendingDecisions, nextActions, blockers, artifactRefs: record.artifacts, evidenceRefs: record.evidence, taskSummaries: record.tasks.map(task => ({ taskId: task.id, status: task.status, attempt: task.attempt })), budget: { interactionsUsed: record.interaction.turn, taskAttemptsUsed: record.tasks.reduce((sum, task) => sum + task.attempt, 0), wallTimeMs: Math.max(0, Date.now() - (record.createdAt ?? record.updatedAt)), toolCalls: 0 } }; }
+    view(record) { const pendingDecisions = record.interaction.openQuestions.map((question, index) => ({ id: `${record.id}:question:${record.interaction.turn}:${index}`, kind: 'product', question, options: [], blocking: record.interaction.blockingUnknowns.includes(question), turn: record.interaction.turn })); const nextActions = nextActionsFor(record); const blockers = record.blockers ?? (['held', 'failed', 'needs_changes', 'blocked'].includes(record.stage) ? [this.defaultBlocker(record)] : []); return { caseId: record.id, currentTurn: record.interaction.turn, contextReceipt: record.contextReceipt, ...(record.contextQuality ? { contextQuality: record.contextQuality } : {}), ...(record.sessionId && record.executionId ? { canonicalIdentity: { sessionId: record.sessionId, executionId: record.executionId, actorId: record.createdBy.id } } : {}), ...(record.runtimeActivation ? { runtimeActivationHash: record.runtimeActivation.snapshotHash } : {}), stage: record.stage, pendingDecisions, nextActions, blockers, artifactRefs: record.artifacts, evidenceRefs: record.evidence, taskSummaries: record.tasks.map(task => ({ taskId: task.id, status: task.status, attempt: task.attempt })), budget: { interactionsUsed: record.interaction.turn, taskAttemptsUsed: record.tasks.reduce((sum, task) => sum + task.attempt, 0), wallTimeMs: Math.max(0, Date.now() - (record.createdAt ?? record.updatedAt)), toolCalls: 0 } }; }
     defaultBlocker(record) {
         const task = record.tasks.find(item => ['blocked', 'failed', 'needs_changes'].includes(item.status));
         const code = record.stage === 'held' ? 'HELD' : record.stage.toUpperCase();