@ornexus/neocortex 4.60.73 → 4.60.75

package/packages/client/dist/runner/headless/epic-terminal-git-runner.d.ts

@@ -1,8 +1,9 @@
 import { type EpicGitReconciliationDirective, type EpicTerminalGitDirective, type EpicTerminalGitReceipt, type GitReconciliationCandidate, type GitReconciliationDecision, type GitReconciliationReceipt } from '../../../../shared/dist/yoloop/epic-terminal-git.js';
-import { type P205TransientExecutionAuthority } from '../../git/git-lifecycle-store.js';
+import { type EpicTerminalReleaseAuthority, type P205TransientExecutionAuthority } from '../../git/git-lifecycle-store.js';
 import { type EpicMergeCandidateQaAuthority } from './epic-merge-candidate-qa.js';
 import type { EpicMergeCandidateQaReceipt } from '../../../../shared/dist/yoloop/epic-terminal-git.js';
 import type { EpicPullRequestMergeGuardReceipt } from '../../../../shared/dist/yoloop/epic-terminal-git.js';
+import { type ManagedEnvironmentCleanupAdapter, type ManagedEnvironmentCleanupReceiptV1, type ManagedEnvironmentCleanupRequestV1 } from './managed-environment-cleanup.js';
 export interface EpicTerminalGitSnapshot {
     readonly executionHeadSha: string;
     readonly originHeadSha: string;
@@ -11,9 +12,12 @@ export interface EpicTerminalGitSnapshot {
     readonly acceptedCheckpointIds: readonly string[];
     readonly existingReceipt?: EpicTerminalGitReceipt | null;
     readonly aggregateQaReceipt?: import('../../../../shared/dist/yoloop/epic-terminal-git.js').EpicAggregateQaReceipt | null;
+    readonly headReconciliationReceipt?: import('../../../../shared/dist/yoloop/epic-terminal-git.js').EpicHeadReconciliationReceiptV1 | null;
     readonly originBinding?: import('../../../../shared/dist/yoloop/epic-terminal-git.js').EpicOriginBindingEvidence | null;
     readonly nowIso?: string;
     readonly reconciliationCandidates: readonly GitReconciliationCandidate[];
+    /** Optional capability-bound resources. Absence means no environment effect is authorized. */
+    readonly managedEnvironmentCleanupRequests?: readonly ManagedEnvironmentCleanupRequestV1[];
 }
 export type EpicTerminalEffectResult<T extends object = object> = ({
     readonly ok: true;
@@ -24,6 +28,8 @@ export type EpicTerminalEffectResult<T extends object = object> = ({
     readonly externalPolicy: boolean;
 };
 export interface EpicTerminalGitAdapter {
+    /** Optional installed capability. Missing capability preserves managed resources as pending. */
+    readonly managedEnvironmentCleanup?: ManagedEnvironmentCleanupAdapter;
     /** Produce missing physical origin/aggregate-QA evidence before server projection. */
     prepareLifecycleEvidence?(input: {
         readonly epicId: string;
@@ -31,6 +37,9 @@ export interface EpicTerminalGitAdapter {
     }): Promise<EpicTerminalEffectResult<{
         readonly originBindingCaptured: boolean;
         readonly aggregateQaRecorded: boolean;
+        readonly headReconciliationRecorded?: boolean;
+        readonly terminalAuthority?: EpicTerminalReleaseAuthority;
+        /** Backward-compatible alias for same-process fresh aggregate producers. */
         readonly p205Authority?: P205TransientExecutionAuthority;
     }>>;
     inspect(directive: EpicTerminalGitDirective): Promise<EpicTerminalEffectResult<{
@@ -73,10 +82,17 @@ export interface EpicTerminalGitAdapter {
         readonly candidateQa: EpicMergeCandidateQaReceipt;
         readonly candidateAuthority: EpicMergeCandidateQaAuthority;
         readonly idempotencyKey: string;
+        readonly terminalBinding?: {
+            readonly graphRevision: string;
+            readonly storyCheckpointIds: readonly string[];
+            readonly aggregateQaReceipt: EpicTerminalGitDirective['localGates']['aggregateQaReceipt'];
+            readonly nowIso: string;
+        };
     }): Promise<EpicTerminalEffectResult<{
         readonly prNumber: number;
     }>>;
     mergeEpicPullRequest(input: {
+        readonly epicId?: string;
         readonly prNumber: number;
         readonly originBranch: string;
         readonly executionBranch: string;
@@ -86,6 +102,11 @@ export interface EpicTerminalGitAdapter {
         readonly candidateQa?: EpicMergeCandidateQaReceipt;
         readonly candidateAuthority?: EpicMergeCandidateQaAuthority;
         readonly nowIso: string;
+        readonly terminalBinding?: {
+            readonly graphRevision: string;
+            readonly storyCheckpointIds: readonly string[];
+            readonly aggregateQaReceipt: EpicTerminalGitDirective['localGates']['aggregateQaReceipt'];
+        };
     }): Promise<EpicTerminalEffectResult<{
         readonly mergeSha: string;
         readonly pushedSha: string;
@@ -112,6 +133,8 @@ export interface EpicTerminalGitAdapter {
         readonly terminalReceipt: EpicTerminalGitReceipt;
         readonly reconciliationReceipts: readonly GitReconciliationReceipt[];
         readonly preservedDecisions: readonly GitReconciliationDecision[];
+        /** Kept separate from merge/Git reconciliation; production persistence requires an accepted store claim. */
+        readonly managedEnvironmentCleanupReceipts?: readonly ManagedEnvironmentCleanupReceiptV1[];
     }): Promise<EpicTerminalEffectResult>;
 }
 export interface EpicTerminalGitExecutionResult {
@@ -119,6 +142,8 @@ export interface EpicTerminalGitExecutionResult {
     readonly receipt: EpicTerminalGitReceipt;
     readonly reconciliationReceipts: readonly GitReconciliationReceipt[];
     readonly preservedDecisions: readonly GitReconciliationDecision[];
+    readonly managedEnvironmentCleanupReceipts: readonly ManagedEnvironmentCleanupReceiptV1[];
+    readonly managedEnvironmentCleanupPending: boolean;
     readonly reasonCodes: readonly string[];
     readonly publicSafe: true;
 }
@@ -131,4 +156,4 @@ export interface EpicGitReconciliationExecutionResult {
 }
 /** Run the same fail-closed reconciler at start/resume or explicit audit. */
 export declare function executeEpicGitReconciliation(directive: EpicGitReconciliationDirective, adapter: EpicTerminalGitAdapter, now: () => string): Promise<EpicGitReconciliationExecutionResult>;
-export declare function executeEpicTerminalGit(directive: EpicTerminalGitDirective, adapter: EpicTerminalGitAdapter, now: () => string, preparedAuthority?: P205TransientExecutionAuthority): Promise<EpicTerminalGitExecutionResult>;
+export declare function executeEpicTerminalGit(directive: EpicTerminalGitDirective, adapter: EpicTerminalGitAdapter, now: () => string, preparedAuthority?: EpicTerminalReleaseAuthority): Promise<EpicTerminalGitExecutionResult>;

package/packages/client/dist/runner/headless/epic-terminal-git-runner.js

@@ -1,318 +1,2 @@
-/**
- * Root-owned terminal epic Git executor. Effects are adapter-injected so tests
- * never mutate real refs or provider resources.
- */
-import { createHash } from 'node:crypto';
-import { EPIC_TERMINAL_GIT_REASON_CODES, classifyGitReconciliationCandidate, validateEpicTerminalGitDirective, } from '../../../../shared/dist/yoloop/epic-terminal-git.js';
-import { p205TransientAuthorityMatchesAggregate, } from '../../git/git-lifecycle-store.js';
-import { verifiedEpicMergeCandidateReceipt, } from './epic-merge-candidate-qa.js';
-/** Run the same fail-closed reconciler at start/resume or explicit audit. */
-export async function executeEpicGitReconciliation(directive, adapter, now) {
-    const inspected = await adapter.inspectReconciliation(directive);
-    if (!inspected.ok) {
-        return { ok: false, reconciliationReceipts: [], preservedDecisions: [], reasonCodes: [inspected.reasonCode], publicSafe: true };
-    }
-    const reconciliation = await reconcileCandidates({
-        idempotencyKey: directive.idempotencyKey,
-        enabled: true,
-        dryRun: directive.dryRun,
-    }, inspected.candidates, adapter, now);
-    const persisted = await adapter.persistReconciliation({
-        epicId: directive.epicId,
-        reconciliationReceipts: reconciliation.receipts,
-        preservedDecisions: reconciliation.preserved,
-    });
-    const reasonCodes = unique([...reconciliation.reasonCodes, ...(persisted.ok ? [] : [persisted.reasonCode])]);
-    return {
-        ok: reconciliation.ok && persisted.ok,
-        reconciliationReceipts: reconciliation.receipts,
-        preservedDecisions: reconciliation.preserved,
-        reasonCodes,
-        publicSafe: true,
-    };
-}
-export async function executeEpicTerminalGit(directive, adapter, now, preparedAuthority) {
-    const startedAt = now();
-    if (!adapter.prepareLifecycleEvidence) {
-        return failedBeforeSnapshot(directive, {
-            ok: false, reasonCode: 'epic-aggregate-qa-producer-required', retryEligible: false, externalPolicy: false,
-        }, startedAt);
-    }
-    const produced = preparedAuthority
-        ? { ok: true, originBindingCaptured: false, aggregateQaRecorded: true, p205Authority: preparedAuthority }
-        : await adapter.prepareLifecycleEvidence({ epicId: directive.epicId, nowIso: startedAt });
-    if (!produced.ok)
-        return failedBeforeSnapshot(directive, produced, startedAt);
-    if (!produced.p205Authority) {
-        return failedBeforeSnapshot(directive, {
-            ok: false, reasonCode: 'epic-aggregate-qa-authority-required', retryEligible: false, externalPolicy: false,
-        }, startedAt);
-    }
-    const inspected = await adapter.inspect(directive);
-    if (!inspected.ok)
-        return failedBeforeSnapshot(directive, inspected, startedAt);
-    const snapshot = inspected.snapshot;
-    if (!p205TransientAuthorityMatchesAggregate(produced.p205Authority, snapshot.executionHeadSha, directive.graphRevision)) {
-        return failedBeforeSnapshot(directive, {
-            ok: false, reasonCode: 'epic-aggregate-qa-authority-binding-mismatch', retryEligible: false, externalPolicy: false,
-        }, startedAt);
-    }
-    const readiness = validateEpicTerminalGitDirective(directive, { ...snapshot, nowIso: startedAt });
-    if (!readiness.ready) {
-        return terminalResult(false, baseReceipt(directive, snapshot, startedAt, {
-            strategy: directive.strategy === 'single_pr' ? 'single_pr' : 'direct',
-            physicalStatus: 'blocked_local_or_repo',
-            retryEligible: readiness.reasonCodes.some((code) => code.endsWith('mismatch') || code.endsWith('active')),
-            reasonCodes: readiness.reasonCodes,
-        }), [], [], readiness.reasonCodes);
-    }
-    if (readiness.reasonCodes.includes(EPIC_TERMINAL_GIT_REASON_CODES.ALREADY_COMPLETE) && snapshot.existingReceipt) {
-        const verified = await adapter.verifyTerminalReceipt(directive, snapshot.existingReceipt, startedAt);
-        if (!verified.ok)
-            return terminalResult(false, snapshot.existingReceipt, [], [], [verified.reasonCode]);
-        const candidateQa = verifiedEpicMergeCandidateReceipt(verified.candidateAuthority, {
-            mergeSha: snapshot.existingReceipt.mergeSha, originHeadSha: snapshot.existingReceipt.baseSha,
-            executionHeadSha: snapshot.existingReceipt.executionHeadSha, graphRevision: directive.graphRevision,
-        });
-        if (!candidateQa)
-            return terminalResult(false, snapshot.existingReceipt, [], [], ['epic-merge-candidate-authority-required']);
-        const verifiedReceipt = {
-            ...snapshot.existingReceipt, candidateQa,
-            ...(verified.providerGuard ? { providerGuard: verified.providerGuard } : {}),
-        };
-        const reconciliation = await reconcileCandidates({ idempotencyKey: directive.idempotencyKey, enabled: directive.reconcile.enabled, dryRun: directive.reconcile.dryRun }, snapshot.reconciliationCandidates, adapter, now);
-        const persisted = await adapter.persist({
-            terminalReceipt: verifiedReceipt,
-            reconciliationReceipts: reconciliation.receipts,
-            preservedDecisions: reconciliation.preserved,
-        });
-        const reasons = unique([...readiness.reasonCodes, ...reconciliation.reasonCodes, ...(persisted.ok ? [] : [persisted.reasonCode])]);
-        return terminalResult(persisted.ok && reconciliation.ok, verifiedReceipt, reconciliation.receipts, reconciliation.preserved, reasons);
-    }
-    let receipt;
-    const prepared = await adapter.prepareMergeObject({
-        originBranch: directive.originBranch,
-        executionBranch: directive.executionBranch,
-        originHeadSha: snapshot.originHeadSha,
-        executionHeadSha: snapshot.executionHeadSha,
-        graphRevision: directive.graphRevision,
-        nowIso: startedAt,
-        message: [
-            `merge(${directive.epicId}): integrate ${directive.executionBranch} into ${directive.originBranch}`,
-            '',
-            `Neocortex-Epic: ${directive.epicId}`,
-            `Neocortex-Origin-Branch: ${directive.originBranch}`,
-            `Neocortex-Execution-Branch: ${directive.executionBranch}`,
-            `Neocortex-Execution-Head: ${snapshot.executionHeadSha}`,
-            `Neocortex-Origin-Base: ${snapshot.originHeadSha}`,
-            `Neocortex-Graph-Revision: ${directive.graphRevision}`,
-            `Neocortex-Aggregate-QA: ${directive.localGates.aggregateQaReceipt.receiptRef}`,
-            `Neocortex-Idempotency: ${directive.idempotencyKey}`,
-        ].join('\n'),
-    });
-    if (!prepared.ok) {
-        receipt = baseReceipt(directive, snapshot, startedAt, {
-            strategy: 'direct',
-            physicalStatus: 'blocked_local_or_repo',
-            retryEligible: prepared.retryEligible,
-            reasonCodes: [prepared.reasonCode],
-        });
-        await adapter.persist({ terminalReceipt: receipt, reconciliationReceipts: [], preservedDecisions: [] });
-        return terminalResult(false, receipt, [], [], receipt.reasonCodes);
-    }
-    const candidateQa = verifiedEpicMergeCandidateReceipt(prepared.candidateAuthority, {
-        originHeadSha: snapshot.originHeadSha, executionHeadSha: snapshot.executionHeadSha,
-        mergeSha: prepared.mergeSha, graphRevision: directive.graphRevision,
-    });
-    if (!candidateQa)
-        return failedBeforeSnapshot(directive, {
-            ok: false, reasonCode: 'epic-merge-candidate-authority-required', retryEligible: false, externalPolicy: false,
-        }, startedAt);
-    if (directive.strategy !== 'single_pr') {
-        const pushed = await adapter.pushMergeObject({
-            epicId: directive.epicId,
-            originBranch: directive.originBranch,
-            executionBranch: directive.executionBranch,
-            executionHeadSha: snapshot.executionHeadSha,
-            expectedOriginSha: snapshot.originHeadSha,
-            mergeSha: prepared.mergeSha,
-            graphRevision: directive.graphRevision,
-            candidateAuthority: prepared.candidateAuthority,
-            storyCheckpointIds: directive.storyCheckpointIds,
-            aggregateQaReceipt: directive.localGates.aggregateQaReceipt,
-            nowIso: now(),
-        });
-        if (pushed.ok) {
-            receipt = baseReceipt(directive, snapshot, startedAt, {
-                strategy: 'direct', mergeSha: prepared.mergeSha, pushedSha: pushed.pushedSha, candidateQa,
-                physicalStatus: 'pushed', retryEligible: false,
-                reasonCodes: [EPIC_TERMINAL_GIT_REASON_CODES.READY], completedAt: now(),
-            });
-        }
-        else if (directive.strategy === 'direct_or_single_pr' && pushed.externalPolicy) {
-            receipt = await executePullRequestFallback(directive, snapshot, adapter, startedAt, now, candidateQa, prepared.candidateAuthority);
-        }
-        else {
-            receipt = baseReceipt(directive, snapshot, startedAt, {
-                strategy: 'direct', mergeSha: prepared.mergeSha,
-                physicalStatus: pushed.externalPolicy ? 'denied_external_gate' : 'blocked_local_or_repo',
-                retryEligible: pushed.retryEligible,
-                reasonCodes: [pushed.reasonCode, ...(pushed.retryEligible ? [EPIC_TERMINAL_GIT_REASON_CODES.RETRY_ELIGIBLE] : [])],
-            });
-        }
-    }
-    else {
-        receipt = await executePullRequestFallback(directive, snapshot, adapter, startedAt, now, candidateQa, prepared.candidateAuthority);
-    }
-    const verified = receipt.physicalStatus === 'pushed'
-        ? await adapter.verifyTerminalReceipt(directive, receipt, now())
-        : null;
-    if (verified && !verified.ok) {
-        const failedReceipt = baseReceipt(directive, snapshot, startedAt, {
-            ...receipt,
-            physicalStatus: 'blocked_local_or_repo',
-            retryEligible: verified.retryEligible,
-            reasonCodes: [verified.reasonCode],
-        });
-        await adapter.persist({ terminalReceipt: failedReceipt, reconciliationReceipts: [], preservedDecisions: [] });
-        return terminalResult(false, failedReceipt, [], [], failedReceipt.reasonCodes);
-    }
-    if (verified?.ok) {
-        const accepted = verifiedEpicMergeCandidateReceipt(verified.candidateAuthority, {
-            mergeSha: receipt.mergeSha, originHeadSha: receipt.baseSha,
-            executionHeadSha: receipt.executionHeadSha, graphRevision: directive.graphRevision,
-        });
-        if (!accepted)
-            return terminalResult(false, receipt, [], [], ['epic-merge-candidate-authority-required']);
-        receipt = {
-            ...receipt, candidateQa: accepted,
-            ...(verified.providerGuard ? { providerGuard: verified.providerGuard } : {}),
-        };
-    }
-    const reconciliation = receipt.physicalStatus === 'pushed'
-        ? await reconcileCandidates({ idempotencyKey: directive.idempotencyKey, enabled: directive.reconcile.enabled, dryRun: directive.reconcile.dryRun }, snapshot.reconciliationCandidates, adapter, now)
-        : { ok: true, receipts: [], preserved: [], reasonCodes: [] };
-    const persisted = await adapter.persist({
-        terminalReceipt: receipt,
-        reconciliationReceipts: reconciliation.receipts,
-        preservedDecisions: reconciliation.preserved,
-    });
-    const reasons = unique([...receipt.reasonCodes, ...reconciliation.reasonCodes, ...(persisted.ok ? [] : [persisted.reasonCode])]);
-    return terminalResult(receipt.physicalStatus === 'pushed' && reconciliation.ok && persisted.ok, receipt, reconciliation.receipts, reconciliation.preserved, reasons);
-}
-async function executePullRequestFallback(directive, snapshot, adapter, startedAt, now, candidateQa, candidateAuthority) {
-    const pr = await adapter.ensureSingleEpicPullRequest({
-        epicId: directive.epicId,
-        originBranch: directive.originBranch,
-        executionBranch: directive.executionBranch,
-        expectedStoryHeadSha: snapshot.executionHeadSha,
-        expectedPullRequestHeadSha: candidateQa.mergeSha,
-        candidateQa,
-        candidateAuthority,
-        idempotencyKey: directive.idempotencyKey,
-    });
-    if (!pr.ok)
-        return baseReceipt(directive, snapshot, startedAt, {
-            strategy: 'single_pr', physicalStatus: pr.externalPolicy ? 'denied_external_gate' : 'blocked_local_or_repo',
-            retryEligible: pr.retryEligible, reasonCodes: [pr.reasonCode],
-        });
-    const merged = await adapter.mergeEpicPullRequest({
-        prNumber: pr.prNumber,
-        originBranch: directive.originBranch,
-        executionBranch: directive.executionBranch,
-        expectedStoryHeadSha: snapshot.executionHeadSha,
-        expectedPullRequestHeadSha: candidateQa.mergeSha,
-        expectedOriginHeadSha: snapshot.originHeadSha,
-        candidateQa, candidateAuthority, nowIso: now(),
-    });
-    if (!merged.ok)
-        return baseReceipt(directive, snapshot, startedAt, {
-            strategy: 'single_pr', prNumber: pr.prNumber,
-            physicalStatus: merged.externalPolicy ? 'denied_external_gate' : 'blocked_local_or_repo',
-            retryEligible: merged.retryEligible,
-            reasonCodes: [merged.reasonCode, ...(merged.retryEligible ? [EPIC_TERMINAL_GIT_REASON_CODES.RETRY_ELIGIBLE] : [])],
-        });
-    return baseReceipt(directive, snapshot, startedAt, {
-        strategy: 'single_pr', prNumber: pr.prNumber, mergeSha: merged.mergeSha, pushedSha: merged.pushedSha, candidateQa,
-        providerGuard: merged.providerGuard,
-        physicalStatus: 'pushed', retryEligible: false,
-        reasonCodes: [EPIC_TERMINAL_GIT_REASON_CODES.READY], completedAt: now(),
-    });
-}
-async function reconcileCandidates(directive, candidates, adapter, now) {
-    if (!directive.enabled)
-        return { ok: true, receipts: [], preserved: [], reasonCodes: [] };
-    const receipts = [];
-    const preserved = [];
-    const reasons = [];
-    let ok = true;
-    const failedPrBranches = new Set();
-    const order = { pull_request: 0, local_branch: 1, remote_branch: 2 };
-    for (const candidate of [...candidates].sort((a, b) => order[a.kind] - order[b.kind] || a.resourceId.localeCompare(b.resourceId))) {
-        const decision = classifyGitReconciliationCandidate(candidate);
-        reasons.push(...decision.reasonCodes);
-        if (decision.action === 'preserve') {
-            preserved.push(decision);
-            continue;
-        }
-        if (candidate.kind !== 'pull_request' && failedPrBranches.has(candidate.branchName)) {
-            preserved.push({ ...decision, action: 'preserve', reasonCodes: ['git-resource-related-pr-close-pending'] });
-            reasons.push('git-resource-related-pr-close-pending');
-            continue;
-        }
-        // Stable across start/resume/terminal directives; no long branch name or
-        // unbounded parent id can overflow the public receipt schema.
-        const receiptKey = `reconciliation:v2:${createHash('sha256').update([candidate.resourceId, decision.action].join('\0')).digest('hex')}`;
-        const applied = await adapter.applyReconciliation(candidate, decision, directive.dryRun);
-        if (!applied.ok) {
-            ok = false;
-            if (candidate.kind === 'pull_request')
-                failedPrBranches.add(candidate.branchName);
-            reasons.push(applied.reasonCode);
-            receipts.push({
-                schemaVersion: 1, resourceId: candidate.resourceId, action: decision.action,
-                outcome: 'failed', idempotencyKey: receiptKey,
-                reasonCodes: [applied.reasonCode], recordedAt: now(), publicSafe: true,
-            });
-            continue;
-        }
-        receipts.push({
-            schemaVersion: 1, resourceId: candidate.resourceId, action: decision.action,
-            outcome: applied.outcome, idempotencyKey: receiptKey,
-            reasonCodes: decision.reasonCodes, recordedAt: now(), publicSafe: true,
-        });
-    }
-    return { ok, receipts, preserved, reasonCodes: unique(reasons) };
-}
-function baseReceipt(directive, snapshot, startedAt, override) {
-    return Object.freeze({
-        schemaVersion: 1,
-        epicId: directive.epicId,
-        executionBranch: directive.executionBranch,
-        originBranch: directive.originBranch,
-        baseSha: snapshot.originHeadSha,
-        executionHeadSha: snapshot.executionHeadSha,
-        localGateReceiptRefs: directive.localGates.receiptRefs,
-        idempotencyKey: directive.idempotencyKey,
-        attemptStartedAt: startedAt,
-        publicSafe: true,
-        ...override,
-    });
-}
-function failedBeforeSnapshot(directive, failure, startedAt) {
-    const placeholder = '0'.repeat(40);
-    const receipt = {
-        schemaVersion: 1, epicId: directive.epicId, executionBranch: directive.executionBranch, originBranch: directive.originBranch,
-        baseSha: placeholder, executionHeadSha: directive.expectedExecutionHeadSha, strategy: directive.strategy === 'single_pr' ? 'single_pr' : 'direct',
-        physicalStatus: failure.externalPolicy ? 'denied_external_gate' : 'blocked_local_or_repo',
-        localGateReceiptRefs: directive.localGates.receiptRefs, idempotencyKey: directive.idempotencyKey,
-        attemptStartedAt: startedAt, retryEligible: failure.retryEligible, reasonCodes: [failure.reasonCode], publicSafe: true,
-    };
-    return terminalResult(false, receipt, [], [], receipt.reasonCodes);
-}
-function terminalResult(ok, receipt, reconciliationReceipts, preservedDecisions, reasonCodes) {
-    return { ok, receipt, reconciliationReceipts, preservedDecisions, reasonCodes: unique(reasonCodes), publicSafe: true };
-}
-function unique(values) {
-    return [...new Set(values)];
-}
+import{createHash as K}from"node:crypto";import{EPIC_TERMINAL_GIT_REASON_CODES as x,classifyGitReconciliationCandidate as D,validateEpicTerminalGitDirective as $}from"../../../../shared/dist/yoloop/epic-terminal-git.js";import{consumeEpicTerminalReleaseAuthority as Q}from"../../git/git-lifecycle-store.js";import{verifiedEpicMergeCandidateReceipt as I}from"./epic-merge-candidate-qa.js";import{executeManagedEnvironmentCleanup as A}from"./managed-environment-cleanup.js";async function Y(e,n,t){const p=await n.inspectReconciliation(e);if(!p.ok)return{ok:!1,reconciliationReceipts:[],preservedDecisions:[],reasonCodes:[p.reasonCode],publicSafe:!0};const r=await B({idempotencyKey:e.idempotencyKey,enabled:!0,dryRun:e.dryRun},p.candidates,n,t),c=await n.persistReconciliation({epicId:e.epicId,reconciliationReceipts:r.receipts,preservedDecisions:r.preserved}),u=C([...r.reasonCodes,...c.ok?[]:[c.reasonCode]]);return{ok:r.ok&&c.ok,reconciliationReceipts:r.receipts,preservedDecisions:r.preserved,reasonCodes:u,publicSafe:!0}}async function V(e,n,t,p){const r=t();if(!n.prepareLifecycleEvidence)return S(e,{ok:!1,reasonCode:"epic-aggregate-qa-producer-required",retryEligible:!1,externalPolicy:!1},r);const c=p?{ok:!0,originBindingCaptured:!1,aggregateQaRecorded:!0,terminalAuthority:p}:await n.prepareLifecycleEvidence({epicId:e.epicId,nowIso:r});if(!c.ok)return S(e,c,r);const u=c.terminalAuthority??c.p205Authority;if(!u)return S(e,{ok:!1,reasonCode:"epic-aggregate-qa-authority-required",retryEligible:!1,externalPolicy:!1},r);const l=await n.inspect(e);if(!l.ok)return S(e,l,r);const a=l.snapshot,h=$(e,{...a,nowIso:r});if(!h.ready)return y(!1,m(e,a,r,{strategy:e.strategy==="single_pr"?"single_pr":"direct",physicalStatus:"blocked_local_or_repo",retryEligible:h.reasonCodes.some(s=>s.endsWith("mismatch")||s.endsWith("active")),reasonCodes:h.reasonCodes}),[],[],h.reasonCodes);if(!a.aggregateQaReceipt||!Q(u,{executionHeadSha:a.executionHeadSha,graphRevision:e.graphRevision,aggregateQaReceipt:a.aggregateQaReceipt,headReconciliationReceipt:a.headReconciliationReceipt}))return S(e,{ok:!1,reasonCode:"epic-aggregate-qa-authority-binding-mismatch",retryEligible:!1,externalPolicy:!1},r);if(h.reasonCodes.includes(x.ALREADY_COMPLETE)&&a.existingReceipt){const s=await n.verifyTerminalReceipt(e,a.existingReceipt,r);if(!s.ok)return y(!1,a.existingReceipt,[],[],[s.reasonCode]);const H=I(s.candidateAuthority,{mergeSha:a.existingReceipt.mergeSha,originHeadSha:a.existingReceipt.baseSha,executionHeadSha:a.existingReceipt.executionHeadSha,graphRevision:e.graphRevision});if(!H)return y(!1,a.existingReceipt,[],[],["epic-merge-candidate-authority-required"]);const G={...a.existingReceipt,candidateQa:H,...s.providerGuard?{providerGuard:s.providerGuard}:{}},f=await B({idempotencyKey:e.idempotencyKey,enabled:e.reconcile.enabled,dryRun:e.reconcile.dryRun},a.reconciliationCandidates,n,t),E=await A(a.managedEnvironmentCleanupRequests??[],n.managedEnvironmentCleanup,t),k=await n.persist({terminalReceipt:G,reconciliationReceipts:f.receipts,preservedDecisions:f.preserved,managedEnvironmentCleanupReceipts:E.receipts}),P=C([...h.reasonCodes,...f.reasonCodes,...E.reasonCodes,...k.ok?[]:[k.reasonCode]]);return y(k.ok&&f.ok&&E.ok,G,f.receipts,f.preserved,P,E)}let o;const i=await n.prepareMergeObject({originBranch:e.originBranch,executionBranch:e.executionBranch,originHeadSha:a.originHeadSha,executionHeadSha:a.executionHeadSha,graphRevision:e.graphRevision,nowIso:r,message:[`merge(${e.epicId}): integrate ${e.executionBranch} into ${e.originBranch}`,"",`Neocortex-Epic: ${e.epicId}`,`Neocortex-Origin-Branch: ${e.originBranch}`,`Neocortex-Execution-Branch: ${e.executionBranch}`,`Neocortex-Execution-Head: ${a.executionHeadSha}`,`Neocortex-Origin-Base: ${a.originHeadSha}`,`Neocortex-Graph-Revision: ${e.graphRevision}`,`Neocortex-Aggregate-QA: ${e.localGates.aggregateQaReceipt.receiptRef}`,`Neocortex-Idempotency: ${e.idempotencyKey}`].join(`
+`)});if(!i.ok)return o=m(e,a,r,{strategy:"direct",physicalStatus:"blocked_local_or_repo",retryEligible:i.retryEligible,reasonCodes:[i.reasonCode]}),await n.persist({terminalReceipt:o,reconciliationReceipts:[],preservedDecisions:[]}),y(!1,o,[],[],o.reasonCodes);const g=I(i.candidateAuthority,{originHeadSha:a.originHeadSha,executionHeadSha:a.executionHeadSha,mergeSha:i.mergeSha,graphRevision:e.graphRevision});if(!g)return S(e,{ok:!1,reasonCode:"epic-merge-candidate-authority-required",retryEligible:!1,externalPolicy:!1},r);if(e.strategy!=="single_pr"){const s=await n.pushMergeObject({epicId:e.epicId,originBranch:e.originBranch,executionBranch:e.executionBranch,executionHeadSha:a.executionHeadSha,expectedOriginSha:a.originHeadSha,mergeSha:i.mergeSha,graphRevision:e.graphRevision,candidateAuthority:i.candidateAuthority,storyCheckpointIds:e.storyCheckpointIds,aggregateQaReceipt:e.localGates.aggregateQaReceipt,nowIso:t()});s.ok?o=m(e,a,r,{strategy:"direct",mergeSha:i.mergeSha,pushedSha:s.pushedSha,candidateQa:g,physicalStatus:"pushed",retryEligible:!1,reasonCodes:[x.READY],completedAt:t()}):e.strategy==="direct_or_single_pr"&&s.externalPolicy?o=await q(e,a,n,r,t,g,i.candidateAuthority):o=m(e,a,r,{strategy:"direct",mergeSha:i.mergeSha,physicalStatus:s.externalPolicy?"denied_external_gate":"blocked_local_or_repo",retryEligible:s.retryEligible,reasonCodes:[s.reasonCode,...s.retryEligible?[x.RETRY_ELIGIBLE]:[]]})}else o=await q(e,a,n,r,t,g,i.candidateAuthority);const d=o.physicalStatus==="pushed"?await n.verifyTerminalReceipt(e,o,t()):null;if(d&&!d.ok){const s=m(e,a,r,{...o,physicalStatus:"blocked_local_or_repo",retryEligible:d.retryEligible,reasonCodes:[d.reasonCode]});return await n.persist({terminalReceipt:s,reconciliationReceipts:[],preservedDecisions:[]}),y(!1,s,[],[],s.reasonCodes)}if(d?.ok){const s=I(d.candidateAuthority,{mergeSha:o.mergeSha,originHeadSha:o.baseSha,executionHeadSha:o.executionHeadSha,graphRevision:e.graphRevision});if(!s)return y(!1,o,[],[],["epic-merge-candidate-authority-required"]);o={...o,candidateQa:s,...d.providerGuard?{providerGuard:d.providerGuard}:{}}}const R=o.physicalStatus==="pushed"?await B({idempotencyKey:e.idempotencyKey,enabled:e.reconcile.enabled,dryRun:e.reconcile.dryRun},a.reconciliationCandidates,n,t):{ok:!0,receipts:[],preserved:[],reasonCodes:[]},b=o.physicalStatus==="pushed"?await A(a.managedEnvironmentCleanupRequests??[],n.managedEnvironmentCleanup,t):w(),_=await n.persist({terminalReceipt:o,reconciliationReceipts:R.receipts,preservedDecisions:R.preserved,managedEnvironmentCleanupReceipts:b.receipts}),N=C([...o.reasonCodes,...R.reasonCodes,...b.reasonCodes,..._.ok?[]:[_.reasonCode]]);return y(o.physicalStatus==="pushed"&&R.ok&&b.ok&&_.ok,o,R.receipts,R.preserved,N,b)}async function q(e,n,t,p,r,c,u){const l=await t.ensureSingleEpicPullRequest({epicId:e.epicId,originBranch:e.originBranch,executionBranch:e.executionBranch,expectedStoryHeadSha:n.executionHeadSha,expectedPullRequestHeadSha:c.mergeSha,candidateQa:c,candidateAuthority:u,idempotencyKey:e.idempotencyKey,terminalBinding:{graphRevision:e.graphRevision,storyCheckpointIds:e.storyCheckpointIds,aggregateQaReceipt:e.localGates.aggregateQaReceipt,nowIso:r()}});if(!l.ok)return m(e,n,p,{strategy:"single_pr",physicalStatus:l.externalPolicy?"denied_external_gate":"blocked_local_or_repo",retryEligible:l.retryEligible,reasonCodes:[l.reasonCode]});const a=await t.mergeEpicPullRequest({epicId:e.epicId,prNumber:l.prNumber,originBranch:e.originBranch,executionBranch:e.executionBranch,expectedStoryHeadSha:n.executionHeadSha,expectedPullRequestHeadSha:c.mergeSha,expectedOriginHeadSha:n.originHeadSha,candidateQa:c,candidateAuthority:u,nowIso:r(),terminalBinding:{graphRevision:e.graphRevision,storyCheckpointIds:e.storyCheckpointIds,aggregateQaReceipt:e.localGates.aggregateQaReceipt}});return a.ok?m(e,n,p,{strategy:"single_pr",prNumber:l.prNumber,mergeSha:a.mergeSha,pushedSha:a.pushedSha,candidateQa:c,providerGuard:a.providerGuard,physicalStatus:"pushed",retryEligible:!1,reasonCodes:[x.READY],completedAt:r()}):m(e,n,p,{strategy:"single_pr",prNumber:l.prNumber,physicalStatus:a.externalPolicy?"denied_external_gate":"blocked_local_or_repo",retryEligible:a.retryEligible,reasonCodes:[a.reasonCode,...a.retryEligible?[x.RETRY_ELIGIBLE]:[]]})}async function B(e,n,t,p){if(!e.enabled)return{ok:!0,receipts:[],preserved:[],reasonCodes:[]};const r=[],c=[],u=[];let l=!0;const a=new Set,h={pull_request:0,local_branch:1,remote_branch:2};for(const o of[...n].sort((i,g)=>h[i.kind]-h[g.kind]||i.resourceId.localeCompare(g.resourceId))){const i=D(o);if(u.push(...i.reasonCodes),i.action==="preserve"){c.push(i);continue}if(o.kind!=="pull_request"&&a.has(o.branchName)){c.push({...i,action:"preserve",reasonCodes:["git-resource-related-pr-close-pending"]}),u.push("git-resource-related-pr-close-pending");continue}const g=`reconciliation:v2:${K("sha256").update([o.resourceId,i.action].join("\0")).digest("hex")}`,d=await t.applyReconciliation(o,i,e.dryRun);if(!d.ok){l=!1,o.kind==="pull_request"&&a.add(o.branchName),u.push(d.reasonCode),r.push({schemaVersion:1,resourceId:o.resourceId,action:i.action,outcome:"failed",idempotencyKey:g,reasonCodes:[d.reasonCode],recordedAt:p(),publicSafe:!0});continue}r.push({schemaVersion:1,resourceId:o.resourceId,action:i.action,outcome:d.outcome,idempotencyKey:g,reasonCodes:i.reasonCodes,recordedAt:p(),publicSafe:!0})}return{ok:l,receipts:r,preserved:c,reasonCodes:C(u)}}function m(e,n,t,p){return Object.freeze({schemaVersion:1,epicId:e.epicId,executionBranch:e.executionBranch,originBranch:e.originBranch,baseSha:n.originHeadSha,executionHeadSha:n.executionHeadSha,localGateReceiptRefs:e.localGates.receiptRefs,idempotencyKey:e.idempotencyKey,attemptStartedAt:t,publicSafe:!0,...p})}function S(e,n,t){const p="0".repeat(40),r={schemaVersion:1,epicId:e.epicId,executionBranch:e.executionBranch,originBranch:e.originBranch,baseSha:p,executionHeadSha:e.expectedExecutionHeadSha,strategy:e.strategy==="single_pr"?"single_pr":"direct",physicalStatus:n.externalPolicy?"denied_external_gate":"blocked_local_or_repo",localGateReceiptRefs:e.localGates.receiptRefs,idempotencyKey:e.idempotencyKey,attemptStartedAt:t,retryEligible:n.retryEligible,reasonCodes:[n.reasonCode],publicSafe:!0};return y(!1,r,[],[],r.reasonCodes)}function y(e,n,t,p,r,c=w()){return{ok:e,receipt:n,reconciliationReceipts:t,preservedDecisions:p,managedEnvironmentCleanupReceipts:c.receipts,managedEnvironmentCleanupPending:c.pending,reasonCodes:C(r),publicSafe:!0}}function w(){return{ok:!0,pending:!1,receipts:[],reasonCodes:[],publicSafe:!0}}function C(e){return[...new Set(e)]}export{Y as executeEpicGitReconciliation,V as executeEpicTerminalGit};

package/packages/client/dist/runner/headless/fake-adapter.js

@@ -1,62 +1 @@
-/**
- * @license FSL-1.1
- * Copyright (c) 2026 OrNexus AI
- *
- * P190.04 -- deterministic fake headless adapter for tests.
- */
-import { HEADLESS_REASON_CODES, adapterAvailabilitySuccess, createRejectedExecutionResult, hashPublicValue, redaction, renderHeadlessPrompt, validateHeadlessAdapterExecutionInput, } from './types.js';
-export function createFakeHeadlessAdapter(id = 'fake') {
-    return {
-        id,
-        displayName: id === 'test' ? 'Headless Test Adapter' : 'Headless Fake Adapter',
-        async checkAvailability() {
-            return adapterAvailabilitySuccess(id, 'neocortex-headless-fake', 'Fake headless adapter is available for deterministic tests.');
-        },
-        buildInvocation(input) {
-            const validation = validateHeadlessAdapterExecutionInput(input, id);
-            if (!validation.ok)
-                return validation;
-            return {
-                ok: true,
-                invocation: {
-                    adapterId: id,
-                    commandName: 'neocortex-headless-fake',
-                    args: [validation.input.promptKind, validation.input.targetRef],
-                    promptHash: validation.promptHash,
-                    ...(validation.input.modelId ? { modelId: validation.input.modelId } : {}),
-                    timeoutMs: validation.input.timeoutMs ?? 10 * 60 * 1000,
-                    publicSafe: true,
-                },
-                publicSafe: true,
-            };
-        },
-        async execute(input, _options) {
-            const validation = validateHeadlessAdapterExecutionInput(input, id);
-            if (!validation.ok)
-                return createRejectedExecutionResult(id, id, validation);
-            const prompt = renderHeadlessPrompt(validation.input);
-            return {
-                status: 'completed',
-                adapterId: id,
-                runtimeId: id,
-                ...(validation.input.modelId ? { modelId: validation.input.modelId } : {}),
-                ...(validation.input.runtimeSource ? { runtimeSource: validation.input.runtimeSource } : {}),
-                reasonCode: HEADLESS_REASON_CODES.EXECUTION_COMPLETED,
-                reasonCodes: [HEADLESS_REASON_CODES.EXECUTION_COMPLETED, HEADLESS_REASON_CODES.RECEIPT_REDACTED],
-                exitCode: 0,
-                signal: null,
-                durationMs: 0,
-                counts: { prompts: 1, syntheticRuns: 1 },
-                hashes: {
-                    prompt: hashPublicValue(prompt),
-                    receipt: hashPublicValue(`${id}:${validation.input.targetRef}:${validation.input.modelId ?? ''}`),
-                },
-                publicSummary: 'Fake headless adapter completed deterministic public-safe execution.',
-                redactionSummary: [redaction('prompt', 'prompt_body', hashPublicValue(prompt))],
-                relativePaths: [validation.input.targetRef],
-                ...(validation.input.receipt ? { receipt: validation.input.receipt } : {}),
-                publicSafe: true,
-            };
-        },
-    };
-}
+import{HEADLESS_REASON_CODES as i,adapterAvailabilitySuccess as u,createRejectedExecutionResult as s,hashPublicValue as n,redaction as d,renderHeadlessPrompt as c,validateHeadlessAdapterExecutionInput as p}from"./types.js";function m(t="fake"){return{id:t,displayName:t==="test"?"Headless Test Adapter":"Headless Fake Adapter",async checkAvailability(){return u(t,"neocortex-headless-fake","Fake headless adapter is available for deterministic tests.")},buildInvocation(r){const a=p(r,t);return a.ok?{ok:!0,invocation:{adapterId:t,commandName:"neocortex-headless-fake",args:[a.input.promptKind,a.input.targetRef],promptHash:a.promptHash,...a.input.modelId?{modelId:a.input.modelId}:{},timeoutMs:a.input.timeoutMs??600*1e3,publicSafe:!0},publicSafe:!0}:a},async execute(r,a){const e=p(r,t);if(!e.ok)return s(t,t,e);const o=c(e.input);return{status:"completed",adapterId:t,runtimeId:t,...e.input.modelId?{modelId:e.input.modelId}:{},...e.input.runtimeSource?{runtimeSource:e.input.runtimeSource}:{},reasonCode:i.EXECUTION_COMPLETED,reasonCodes:[i.EXECUTION_COMPLETED,i.RECEIPT_REDACTED],exitCode:0,signal:null,durationMs:0,counts:{prompts:1,syntheticRuns:1},hashes:{prompt:n(o),receipt:n(`${t}:${e.input.targetRef}:${e.input.modelId??""}`)},publicSummary:"Fake headless adapter completed deterministic public-safe execution.",redactionSummary:[d("prompt","prompt_body",n(o))],relativePaths:[e.input.targetRef],...e.input.receipt?{receipt:e.input.receipt}:{},publicSafe:!0}}}}export{m as createFakeHeadlessAdapter};

package/packages/client/dist/runner/headless/managed-environment-cleanup.d.ts

@@ -0,0 +1,95 @@
+/**
+ * P224.05 -- fail-closed cleanup of explicitly managed temporary resources.
+ *
+ * This module owns policy and replay ordering only. Concrete host, process and
+ * interface effects stay behind an injected adapter. Production callers that
+ * do not have a supported adapter preserve resources as pending.
+ */
+export type ManagedEnvironmentResourceKind = 'worktree' | 'process' | 'interface_entry';
+export type ManagedEnvironmentEffect = 'remove_managed_worktree' | 'stop_owned_process' | 'remove_interface_entry';
+export interface ManagedEnvironmentCleanupReceiptV1 {
+    readonly schemaVersion: 1;
+    readonly resourceId: string;
+    readonly effect: ManagedEnvironmentEffect;
+    readonly outcome: 'applied' | 'already_absent' | 'preserved' | 'failed';
+    readonly expectedOwnerDigest: string;
+    readonly expectedRevision: string;
+    readonly idempotencyKey: string;
+    readonly reasonCodes: readonly string[];
+    readonly checkedAt: string;
+    readonly recordedAt: string;
+    readonly publicSafe: true;
+}
+export interface ManagedEnvironmentCleanupRequestV1 {
+    readonly schemaVersion: 1;
+    readonly resourceId: string;
+    readonly epicId: string;
+    readonly expectedKind: ManagedEnvironmentResourceKind;
+    readonly expectedOwnerDigest: string;
+    readonly expectedRevision: string;
+    readonly effect: ManagedEnvironmentEffect;
+    readonly existingReceipt?: ManagedEnvironmentCleanupReceiptV1;
+    readonly publicSafe: true;
+}
+export interface ManagedEnvironmentSnapshotV1 {
+    readonly schemaVersion: 1;
+    readonly resourceId: string;
+    readonly epicId: string;
+    readonly ownerDigest: string;
+    readonly revision: string;
+    readonly kind: ManagedEnvironmentResourceKind;
+    readonly presence: 'present' | 'absent' | 'unknown';
+    readonly managed: boolean;
+    readonly active: boolean;
+    readonly clean: boolean | 'unknown';
+    readonly integrated: boolean;
+    readonly capability: 'supported' | 'unsupported';
+    readonly protected: boolean;
+    readonly primary: boolean;
+    readonly locked: boolean;
+    readonly submoduleActive: boolean;
+    readonly preservableIgnored: boolean;
+    readonly publicSafe: true;
+}
+export type ManagedEnvironmentEffectResult<T extends object> = ({
+    readonly ok: true;
+} & T) | {
+    readonly ok: false;
+    readonly reasonCode: string;
+};
+export interface ManagedEnvironmentCleanupAdapter {
+    inspect(request: ManagedEnvironmentCleanupRequestV1): Promise<ManagedEnvironmentEffectResult<{
+        readonly snapshot: ManagedEnvironmentSnapshotV1;
+    }>>;
+    apply(input: {
+        readonly request: ManagedEnvironmentCleanupRequestV1;
+        readonly snapshot: ManagedEnvironmentSnapshotV1;
+        readonly effect: ManagedEnvironmentEffect;
+        readonly idempotencyKey: string;
+    }): Promise<ManagedEnvironmentEffectResult<{
+        readonly receipt: ManagedEnvironmentCleanupReceiptV1;
+    }>>;
+    reconcile(input: {
+        readonly request: ManagedEnvironmentCleanupRequestV1;
+        readonly receipt: ManagedEnvironmentCleanupReceiptV1;
+    }): Promise<ManagedEnvironmentEffectResult<{
+        readonly receipt: ManagedEnvironmentCleanupReceiptV1;
+    }>>;
+}
+export interface ManagedEnvironmentCleanupResult {
+    readonly ok: boolean;
+    readonly pending: boolean;
+    readonly receipts: readonly ManagedEnvironmentCleanupReceiptV1[];
+    readonly reasonCodes: readonly string[];
+    readonly publicSafe: true;
+}
+interface Classification {
+    readonly action: 'apply' | 'already_absent' | 'preserve';
+    readonly pending: boolean;
+    readonly reasonCodes: readonly string[];
+}
+/** Reconcile durable evidence before any new effect, then apply at most once. */
+export declare function executeManagedEnvironmentCleanup(requests: readonly ManagedEnvironmentCleanupRequestV1[], adapter: ManagedEnvironmentCleanupAdapter | undefined, now: () => string): Promise<ManagedEnvironmentCleanupResult>;
+export declare function classifyManagedEnvironmentSnapshot(request: ManagedEnvironmentCleanupRequestV1, snapshot: ManagedEnvironmentSnapshotV1): Classification;
+export declare function managedEnvironmentCleanupIdempotencyKey(request: Pick<ManagedEnvironmentCleanupRequestV1, 'resourceId' | 'effect' | 'expectedOwnerDigest' | 'expectedRevision'>): string;
+export {};

package/packages/client/dist/runner/headless/managed-environment-cleanup.js

@@ -0,0 +1 @@
+import{createHash as E}from"node:crypto";const D={remove_managed_worktree:"worktree",stop_owned_process:"process",remove_interface_entry:"interface_entry"};async function M(e,n,c){const t=[],a=[],h=new Set;let d=!1,s=!1;for(const r of e){const R=`${r.resourceId}\0${r.effect}`;if(h.has(R)){const i=m(r,I(r),"managed-environment-request-duplicate",c());t.push(i),a.push(...i.reasonCodes),d=!0,s=!0;continue}h.add(R);const w=$(r);if(w){const i=m(r,I(r),w,c());t.push(i),a.push(w),d=!0,s=!0;continue}const u=I(r);if(!n){const i=x(r,u,"preserved",["managed-environment-capability-unsupported"],c());t.push(i),a.push(...i.reasonCodes),d=!0;continue}if(r.existingReceipt){if(!k(r.existingReceipt,r)||r.existingReceipt.idempotencyKey!==u){const b=m(r,u,"managed-environment-receipt-binding-mismatch",c());t.push(b),a.push(...b.reasonCodes),d=!0,s=!0;continue}const i=await n.reconcile({request:r,receipt:r.existingReceipt});if(!i.ok||!k(i.receipt,r)||i.receipt.idempotencyKey!==u){const b=i.ok?"managed-environment-receipt-binding-mismatch":i.reasonCode,A=m(r,u,b,c());t.push(A),a.push(b),d=!0,s=!0;continue}const f=K(i.receipt);if(f.failed||!f.pending){t.push(i.receipt),a.push(...i.receipt.reasonCodes),d||=f.pending,s||=f.failed;continue}}const y=await n.inspect(r);if(!y.ok){const i=m(r,u,y.reasonCode,c());t.push(i),a.push(y.reasonCode),d=!0,s=!0;continue}const l=V(r,y.snapshot);if(a.push(...l.reasonCodes),l.action==="preserve"){t.push(x(r,u,"preserved",l.reasonCodes,c())),d||=l.pending;continue}if(l.action==="already_absent"){t.push(x(r,u,"already_absent",l.reasonCodes,c()));continue}const g=await n.apply({request:r,snapshot:y.snapshot,effect:r.effect,idempotencyKey:u});if(!g.ok||!k(g.receipt,r)||g.receipt.idempotencyKey!==u){const i=g.ok?"managed-environment-receipt-binding-mismatch":g.reasonCode,f=m(r,u,i,c());t.push(f),a.push(i),d=!0,s=!0;continue}const p=await n.reconcile({request:r,receipt:g.receipt});if(!p.ok||!k(p.receipt,r)||p.receipt.idempotencyKey!==u){const i=p.ok?"managed-environment-receipt-binding-mismatch":p.reasonCode,f=m(r,u,i,c());t.push(f),a.push(i),d=!0,s=!0;continue}t.push(p.receipt),a.push(...p.receipt.reasonCodes);const _=K(p.receipt);d||=_.pending,s||=_.failed}return{ok:!s&&!d,pending:d,receipts:t,reasonCodes:S(a),publicSafe:!0}}function V(e,n){return N(n)?n.resourceId!==e.resourceId||n.epicId!==e.epicId?o(!1,"managed-environment-identity-mismatch"):n.kind!==e.expectedKind||D[e.effect]!==n.kind?o(!1,"managed-environment-kind-mismatch"):n.managed?n.ownerDigest!==e.expectedOwnerDigest?o(!1,"managed-environment-owner-replaced"):n.revision!==e.expectedRevision?o(!1,"managed-environment-revision-stale"):n.presence==="absent"?{action:"already_absent",pending:!1,reasonCodes:["managed-environment-already-absent"]}:n.presence!=="present"?o(!0,"managed-environment-presence-unknown"):n.capability!=="supported"?o(!0,"managed-environment-capability-unsupported"):n.primary?o(!0,"managed-environment-primary-preserved"):n.protected?o(!0,"managed-environment-protected"):n.active?o(!0,"managed-environment-active"):n.locked?o(!0,"managed-environment-locked"):n.submoduleActive?o(!0,"managed-environment-submodule-active"):n.clean==="unknown"?o(!0,"managed-environment-cleanliness-unknown"):n.clean?n.preservableIgnored?o(!0,"managed-environment-preservable-ignored"):n.integrated?{action:"apply",pending:!1,reasonCodes:[]}:o(!0,"managed-environment-integration-unproven"):o(!0,"managed-environment-dirty"):o(!1,"managed-environment-ownership-unproven"):o(!0,"managed-environment-snapshot-invalid")}function I(e){return`environment-cleanup:v1:${E("sha256").update([e.resourceId,e.effect,e.expectedOwnerDigest,e.expectedRevision].join("\0")).digest("hex")}`}function $(e){return e.schemaVersion!==1||e.publicSafe!==!0||!v(e.resourceId)||!v(e.epicId)||!C(e.expectedOwnerDigest)||!C(e.expectedRevision)||D[e.effect]!==e.expectedKind?"managed-environment-request-invalid":null}function N(e){return e.schemaVersion===1&&e.publicSafe===!0&&v(e.resourceId)&&v(e.epicId)&&C(e.ownerDigest)&&C(e.revision)&&["worktree","process","interface_entry"].includes(e.kind)&&["present","absent","unknown"].includes(e.presence)&&["supported","unsupported"].includes(e.capability)&&(typeof e.clean=="boolean"||e.clean==="unknown")&&[e.managed,e.active,e.integrated,e.protected,e.primary,e.locked,e.submoduleActive,e.preservableIgnored].every(n=>typeof n=="boolean")}function k(e,n){return e.schemaVersion===1&&e.publicSafe===!0&&e.resourceId===n.resourceId&&e.effect===n.effect&&e.expectedOwnerDigest===n.expectedOwnerDigest&&e.expectedRevision===n.expectedRevision&&["applied","already_absent","preserved","failed"].includes(e.outcome)&&v(e.idempotencyKey)&&e.reasonCodes.length<=128&&e.reasonCodes.every(v)&&O(e.checkedAt)&&O(e.recordedAt)}function K(e){return e.outcome==="failed"?{pending:!0,failed:!0}:e.outcome!=="preserved"?{pending:!1,failed:!1}:{pending:!e.reasonCodes.every(c=>["managed-environment-ownership-unproven","managed-environment-owner-replaced","managed-environment-revision-stale","managed-environment-kind-mismatch","managed-environment-identity-mismatch"].includes(c)),failed:!1}}function o(e,n){return{action:"preserve",pending:e,reasonCodes:[n]}}function x(e,n,c,t,a){return{schemaVersion:1,resourceId:e.resourceId,effect:e.effect,outcome:c,expectedOwnerDigest:e.expectedOwnerDigest,expectedRevision:e.expectedRevision,idempotencyKey:n,reasonCodes:S(t),checkedAt:a,recordedAt:a,publicSafe:!0}}function m(e,n,c,t){return x(e,n,"failed",[c],t)}function v(e){return typeof e=="string"&&e.length>0&&e.length<=240&&/^[A-Za-z0-9._:/@#-]+$/.test(e)}function C(e){return typeof e=="string"&&/^[a-f0-9]{64}$/.test(e)}function O(e){return typeof e=="string"&&Number.isFinite(Date.parse(e))}function S(e){return[...new Set(e)]}export{V as classifyManagedEnvironmentSnapshot,M as executeManagedEnvironmentCleanup,I as managedEnvironmentCleanupIdempotencyKey};