kiokuko-dsh 0.2.39 → 0.2.41

package/dist/dsh/host-adapter/admission.js

@@ -1,16 +1,14 @@
 import { nativeRequestProposals } from '../request-proposals.js';
 import { isNativeSubagent } from '../native-subagent.js';
 import { recordDiagnosticAdmission, observeDiagnostic, } from '../decisions/diagnostics.js';
-import { policyState } from '../host-adapter/turn-state.js';
 import { dshTurnRequestId } from '../intake-profile-resolver.js';
 import { classifyTaskForIntake, selectInstalledSkills, } from '../decisions/workflows.js';
 import { classifyRequestIntent, createRequestIntentContext, rebindRequestIntentDecision, requestIntentMessageRefs, requestIntentReferenceIds, requestIntentTaskType, requestIntentIsUnresolved, } from '../decisions/request-intent.js';
 import { ANSWER_REVIEW_FORM, hasHumanInput, } from '../answer-review/contracts.js';
 import { saveSessionNotice } from '../plugin-records.js';
-import { explicitExecutionMode, initializeExecutionSelection, readExecutionSelection, writeExecutionSelection, } from '../execution-selection.js';
+import { explicitExecutionMode, readExecutionSelection, writeExecutionSelection, } from '../execution-selection.js';
 import { getHeadWorkerForSession } from '../models/session-selection.js';
 import { selectExecution, ExecutionSelectionPending, } from '../model-selection-ui.js';
-import { ennoStateForPreparedTask } from '../../enno-oduno/service.js';
 import { realpathSync } from 'node:fs';
 import { withImmediateTransaction } from '../../db/transaction.js';
 import { DshIntakeGate, } from '../intake-gate.js';
@@ -22,11 +20,7 @@ import { dshTurnBoundarySeq, } from '../session-memory-finalizer.js';
 import { createDshIntakeAnswerer, } from '../user-interaction.js';
 import { canonicalContentHash } from '../../serialization/validate.js';
 import { KiokukoError } from '../../errors.js';
-import { answerEnno, stateForSnapshot, inapplicableEnnoState, } from '../../enno-oduno/service.js';
-import { claimExecutionLeaseInTransaction, readEnnoSnapshot, terminalizeLedgerRunInTransaction, } from '../../enno-oduno/store.js';
-import { decideDshContinuation } from '../continuation.js';
 import { resolveProjectWorkspaceReadOnly } from '../../memory/workspaces.js';
-import { ENNO_APPLICABLE_TASK_TYPES, } from '../../enno-oduno/types.js';
 import { supersedeBoundaryJobsAtOrBeforeRevisionInTransaction, supersedeOutboxAtOrBeforeRevisionInTransaction, } from '../turn-process.js';
 import { unexecutedRunInput } from '../input-claim.js';
 import { resetLoopGuardForUserInTransaction } from '../loop-guard.js';
@@ -42,24 +36,10 @@ import { claimExecutionOwner, readExecutionOwner, } from '../orchestration/execu
 import { initializeCodingWorkflow } from '../coding-workflow/store.js';
 import { codingWorkRequested } from '../coding-workflow/intent.js';
 import { initializeTaskCompletion } from '../task-completion.js';
-export function createAdmission({ native, skills, tools, userQuestions, sessions, agents, deepPlanning, modelCatalog, modelCompatibility, modelRoutes, now, runtime, decisions, answerReview, delegation, executionSupport, ennoMemory, memoryFinalizer, autoReview, sessionMirror, akinatorMemoryConfig, memoryRetrievalConfig, completionMode, turnState, getSelection, setSelection, refreshEnnoMemory, executionBinding, captureInitialInput, contextMessages, resolveIdleClose, retireSupersededRun, cancelBoundarySession, isSelectionBlocked, closeTurn, readStateForRun, capabilityCatalog, sessionEventSource, objectRecord, isHumanMessage, textFromMessages, pluginContinuationId, isLoopRecoveryMessage, }) {
+export function createAdmission({ native, skills, tools, userQuestions, sessions, agents, deepPlanning, modelCatalog, modelCompatibility, modelRoutes, now, runtime, decisions, answerReview, executionSupport, memoryFinalizer, autoReview, sessionMirror, akinatorMemoryConfig, memoryRetrievalConfig, completionMode, turnState, getSelection, setSelection, executionBinding, captureInitialInput, contextMessages, resolveIdleClose, retireSupersededRun, cancelBoundarySession, isSelectionBlocked, closeTurn, capabilityCatalog, sessionEventSource, objectRecord, isHumanMessage, textFromMessages, pluginContinuationId, isLoopRecoveryMessage, }) {
     const currentSession = turnState.currentSession;
     const currentForAgentEvent = turnState.currentForAgentEvent;
     let resumeExistingRun;
-    function supersedesUnstartedEnno(event, state) {
-        if (state.status !== 'oduno_ideal')
-            return false;
-        const incomingType = resolveGroundedIntakeProfile({
-            task: event.task,
-            cwd: event.cwd,
-            deferTaskTypeInference: event.deferTaskTypeInference === true,
-            ...(event.profileHints === undefined
-                ? {}
-                : { profileHints: event.profileHints }),
-        }).profileHints.taskType;
-        return (incomingType !== null &&
-            !ENNO_APPLICABLE_TASK_TYPES.includes(incomingType));
-    }
     function eventTurn(event) {
         const data = typeof event.data === 'object' &&
             event.data !== null &&
@@ -89,6 +69,10 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             bindTaskRepository(database, identity);
             if (event.signal.aborted)
                 return undefined;
+            // Completion can settle while the final model response is streaming.
+            // Retain that response without issuing another execution lease.
+            if (readTaskSnapshot(database, identity).state === 'Done')
+                return undefined;
             // A continued native turn can reuse an already Working task without a
             // fresh admission. Capture its current lease from SQLite as well; never
             // synthesize authority from the model or a cached turn record.
@@ -125,11 +109,9 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                     !item.closed &&
                     !item.failed &&
                     item.prepared.run.status === 'active' &&
-                    !item.prepared.ennoOduno.applicable &&
                     !selection?.discussion &&
                     (!selection ||
                         (selection.mode === 'normal' && selection.status === 'ready')) &&
-                    !delegation.isChild(reviewAgent) &&
                     !deepPlanning.executor.isChild(reviewAgent) &&
                     !isNativeSubagent(reviewAgent) &&
                     !executionSupport.paused(event.sessionId));
@@ -183,37 +165,6 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 undefined);
         });
     }
-    const refreshContinuedWorkLease = async (item, expected) => {
-        const expectedWorkUnitId = expected.nextAction === 'execute_work_unit'
-            ? expected.directive?.workUnit?.id
-            : undefined;
-        if (expectedWorkUnitId === undefined)
-            return undefined;
-        return runtime.withDatabase((database) => withImmediateTransaction(database, () => {
-            const snapshot = readEnnoSnapshot(database, {
-                runId: item.runId,
-                workspace: item.workspace,
-                orchestrationId: item.orchestrationId,
-            });
-            const state = stateForSnapshot(snapshot);
-            const workUnitId = state.nextAction === 'execute_work_unit'
-                ? state.directive?.workUnit?.id
-                : undefined;
-            if (state.contractRevision !== expected.contractRevision ||
-                workUnitId !== expectedWorkUnitId) {
-                throw new KiokukoError('CONFLICT', 'Enno WorkUnit changed before DSH turn recovery');
-            }
-            if (snapshot.dshSessionId !== item.sessionId) {
-                throw new KiokukoError('CONFLICT', 'Enno DSH route changed before WorkUnit recovery');
-            }
-            return {
-                state,
-                lease: claimExecutionLeaseInTransaction(database, snapshot, workUnitId, {
-                    dshSessionId: item.sessionId,
-                }),
-            };
-        }));
-    };
     class CapturingGate extends DshIntakeGate {
         supersededChoices = new Map();
         async choose(event, result) {
@@ -223,7 +174,7 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             const inherited = this.supersededChoices.get(key);
             if (stored?.value.mode === 'pending' &&
                 inherited?.value.status === 'ready' &&
-                ['normal', 'enno'].includes(inherited.value.mode) &&
+                inherited.value.mode === 'normal' &&
                 (!explicitExecutionMode(event.task) ||
                     explicitExecutionMode(event.task) === inherited.value.mode)) {
                 const revision = stored.revision;
@@ -237,20 +188,6 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 }).task);
                 result.prepared.selectedSkills = await selectInstalledSkills(decisions, `run:${runId}`, task, [...event.capabilities.skills, ...event.capabilities.tools], result.prepared.capabilities, event.signal);
             }
-            // Legacy accepted plans keep their original execution contract. A draft
-            // awaiting the new review gate must first acquire an explicit check binding.
-            if (!stored && result.prepared.ennoOduno.status === 'zenki_planning') {
-                stored = await runtime.withDatabase((db) => {
-                    initializeExecutionSelection(db, runId);
-                    const current = readExecutionSelection(db, runId);
-                    return current.value.mode === 'pending'
-                        ? writeExecutionSelection(db, runId, current.revision, {
-                            mode: 'enno',
-                            status: 'selecting',
-                        })
-                        : current;
-                });
-            }
             if (!stored)
                 return result;
             const discussion = stored.value.discussion;
@@ -273,13 +210,13 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                         : { ...value, mode: 'pending' }));
                 }
             }
-            if (!ENNO_APPLICABLE_TASK_TYPES.includes(result.prepared.intake.profile
-                .taskType)) {
+            if (stored.value.mode === 'pending' &&
+                !explicitExecutionMode(event.task) &&
+                !['build', 'debug', 'review', 'devops'].includes(result.prepared.intake.profile.taskType ?? '')) {
                 const revision = stored.revision;
-                if (stored.value.mode === 'pending')
-                    await runtime.withDatabase((db) => db
-                        .prepare('DELETE FROM dsh_execution_selections WHERE run_id = ? AND revision = ?')
-                        .run(runId, revision));
+                await runtime.withDatabase((db) => db
+                    .prepare('DELETE FROM dsh_execution_selections WHERE run_id = ? AND revision = ?')
+                    .run(runId, revision));
                 return result;
             }
             setSelection(runId, stored);
@@ -302,10 +239,7 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 },
             });
             setSelection(runId, selected);
-            const ennoOduno = selected.value.discussion
-                ? result.prepared.ennoOduno
-                : await runtime.withDatabase((db) => ennoStateForPreparedTask(db, result.prepared, event.sessionId));
-            return { ...result, prepared: { ...result.prepared, ennoOduno } };
+            return result;
         }
         async prepare(event) {
             if (event.requestIntent?.action === 'change' &&
@@ -359,7 +293,6 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                     !prior.closed &&
                     !prior.failed &&
                     prior.turn < event.turn &&
-                    !prior.prepared.ennoOduno.applicable &&
                     !(await runtime.withDatabase((db) => readCodingWorkflow(db, current.taskId)));
                 if (resumeCanonicalContinuation ||
                     !taskCanExecute(current) ||
@@ -600,64 +533,34 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                         prepared: previous.prepared,
                         catalog: event.capabilities,
                     };
-                let previousState = await readStateForRun(previous);
-                // DSH's dedicated plan-review card returns the composer to the user
-                // when they choose "Chat about it". The next human message is the
-                // requested plan revision; settle it host-side before Zenki resumes.
-                // This keeps enno_answer host-only and avoids reopening Akinator.
-                if (previousState.nextAction === 'ask_user_confirmation' &&
-                    previousState.contractRevision !== null) {
-                    const expectedRevision = previousState.contractRevision;
-                    const requestedChanges = event.task.trim();
-                    if (requestedChanges.length === 0)
-                        throw new KiokukoError('VALIDATION_ERROR', 'Plan revision feedback is empty');
-                    const revised = await runtime.withDatabase((database) => answerEnno(database, {
-                        runId: previous.runId,
-                        workspace: previous.workspace,
-                        orchestrationId: previous.orchestrationId,
-                        expectedRevision,
-                        idempotencyKey: `dsh-confirmation-feedback:${canonicalContentHash({
-                            runId: previous.runId,
-                            revision: expectedRevision,
-                            sessionId: event.sessionId,
-                            turn: event.turn,
-                            requestedChanges,
-                        })}`,
-                        action: 'revise',
-                        requestedChanges,
-                    }));
-                    previous.prepared = {
-                        ...previous.prepared,
-                        ennoOduno: revised.ennoOduno,
-                    };
-                    const next = policyState(revised.ennoOduno, previous, previous.sessionId, revised.executionLease);
-                    turnState.applyPolicy(previous.runId, next);
-                    previousState = revised.ennoOduno;
-                }
-                const previousWasChat = previous.prepared.intake.profile.taskType === 'chat';
-                const superseded = previous.prepared.ennoOduno.applicable &&
-                    supersedesUnstartedEnno(event, previousState);
+                const previousWasChat = previous.prepared.intake.profile.taskType === "chat";
                 const selection = getSelection(previous.runId)?.value;
                 const coding = await runtime.withDatabase((db) => readCodingWorkflow(db, previous.runId));
                 // Child results and other generated turns continue the admitted Goal.
                 // Only a new human request can replace it without an explicit continuation.
                 const resumeCoding = coding &&
-                    !['completed', 'cancelled', 'superseded'].includes(coding.state) &&
+                    !["completed", "cancelled", "superseded"].includes(coding.state) &&
                     (!hasHumanInput(event.nativeMessages ?? []) ||
                         continuesCodingScope(event));
+                // Durable ledger state owns run liveness; an in-memory active record
+                // cannot resurrect a failed, cancelled or missing run.
+                const durableStatus = await runtime.withDatabase((db) => new LedgerStore(db).readRun(previous.runId)?.status);
+                const durableOpen = durableStatus === "intake" || durableStatus === "active";
                 const continuePrevious = resumeCoding ||
                     (selection &&
-                        (selection.status !== 'ready' ||
-                            (selection.mode === 'normal' && previous.failed)))
+                        (selection.status !== "ready" ||
+                            (selection.mode === "normal" && previous.failed)))
                     ? true
                     : previousWasChat
-                        ? event.profileHints?.taskType === 'chat'
-                        : !superseded &&
-                            previousState.status !== 'completed' &&
-                            previousState.status !== 'blocked' &&
-                            previousState.status !== 'cancelled' &&
-                            (previousState.nextAction !== 'complete' ||
-                                executionSupport.paused(previous.sessionId));
+                        ? event.profileHints?.taskType === "chat"
+                        : event.requestIntent?.relation !== 'new' &&
+                            (!coding || !['completed', 'cancelled', 'superseded'].includes(coding.state)) &&
+                            durableOpen &&
+                            !previous.failed &&
+                            previous.prepared.run.status === "active" &&
+                            (event.profileHints?.taskType ??
+                                previous.prepared.intake.profile.taskType) ===
+                                previous.prepared.intake.profile.taskType;
                 if (continuePrevious) {
                     this.assertCatalog(previous.catalog, event.capabilities);
                     const intent = event.requestIntent;
@@ -675,15 +578,6 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                             repositoryRoot: previous.repositoryRoot,
                         }, `request-intent:${event.sessionId}:${event.turn}:${intent.evidence.requestDigest}`, intent.evidence.requestDigest, evidenceRefs));
                     }
-                    const refreshedWork = await refreshContinuedWorkLease(previous, previousState);
-                    if (refreshedWork !== undefined) {
-                        previous.prepared = {
-                            ...previous.prepared,
-                            ennoOduno: refreshedWork.state,
-                        };
-                        const next = policyState(refreshedWork.state, previous, previous.sessionId, refreshedWork.lease);
-                        turnState.applyPolicy(previous.runId, next);
-                    }
                     const continuedMemory = {
                         context: null,
                         memoryPolicy: {
@@ -740,11 +634,16 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                         prepared: previous.prepared,
                         catalog: event.capabilities,
                     };
-                await retireSupersededRun(previous, superseded || previousState.status === 'cancelled'
-                    ? 'cancelled'
-                    : previousState.status === 'blocked'
-                        ? 'failed'
-                        : 'completed');
+                // The durable ledger status owns the retire outcome: a directly
+                // failed/cancelled run must close with its recorded status (idempotent
+                // close), never as 'completed' (which would fake verified completion
+                // or collide with the immutable close-status ledger guard).
+                const priorLedgerStatus = await runtime.withDatabase((db) => new LedgerStore(db).readRun(previous.runId)?.status);
+                const priorStatus = priorLedgerStatus === 'failed' || priorLedgerStatus === 'cancelled'
+                    ? priorLedgerStatus
+                    : 'completed';
+                await retireSupersededRun(previous, priorStatus);
+                this.supersedeTurn(event.sessionId, event.turn);
             }
             const resumed = await resumeExistingRun?.(event);
             if (resumed !== undefined) {
@@ -778,8 +677,6 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             answerReview.humanInput(event.sessionId, event.turn);
             cancelBoundarySession(event.sessionId);
             const previous = currentSession(event.sessionId);
-            if (previous)
-                ennoMemory.invalidate(previous.runId);
             const state = previous === undefined
                 ? undefined
                 : turnState.policyState(previous.runId);
@@ -839,7 +736,7 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             return result;
         }
         async preStep(event, next) {
-            if (event.nativeAgent && delegation.isChild(event.nativeAgent))
+            if (event.nativeAgent && deepPlanning.executor.isChild(event.nativeAgent))
                 return next();
             // The native chain owns admission and the original message ordering.
             // Run it before any Kiokuko storage or classification work so an
@@ -945,8 +842,6 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                             return { kind: 'reject' };
                     }
                 }
-                if (item !== undefined && !getSelection(item.runId)?.value.discussion)
-                    await refreshEnnoMemory(item, event.signal);
                 const messages = await contextMessages(event, nativeDecision.messages);
                 return {
                     ...nativeDecision,
@@ -1020,64 +915,13 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         const selection = readExecutionSelection(database, runId)?.value;
         if (selection?.mode === 'deep-thinker')
             throw new KiokukoError('CONFLICT', 'Deep Thinker recovery requires its own execution lane');
-        // Pending selection still goes through choose(); only an explicit persisted
-        // Enno selection can recover Enno ownership instead of ordinary execution.
-        const executionMode = selection?.mode === 'enno' ? 'enno' : 'normal';
+        const executionMode = 'normal';
         const owner = readExecutionOwner(database, event.sessionId);
         if (owner &&
             (owner.run_id !== runId ||
                 owner.workspace !== project.workspace ||
                 owner.mode !== executionMode))
             throw new KiokukoError('CONFLICT', 'Task execution owner changed');
-        const orchestration = database
-            .prepare('SELECT orchestration_session_id AS id FROM enno_contracts WHERE run_id=?')
-            .get(runId);
-        const snapshot = !orchestration
-            ? undefined
-            : readEnnoSnapshot(database, {
-                runId,
-                workspace: project.workspace,
-                orchestrationId: orchestration.id,
-            });
-        if (executionMode === 'enno' && !snapshot)
-            throw new KiokukoError('CONFLICT', 'Persisted Enno selection has no matching execution contract');
-        if (snapshot &&
-            !event.signal.aborted &&
-            supersedesUnstartedEnno(event, stateForSnapshot(snapshot))) {
-            terminalizeLedgerRunInTransaction(database, runId, 'cancelled');
-            return undefined;
-        }
-        const automaticMessage = event.nativeMessages?.find((message) => {
-            const continuationId = pluginContinuationId(message);
-            if (continuationId === undefined)
-                return false;
-            const outbox = database
-                .prepare(`
-        SELECT message_form AS messageForm
-          FROM dsh_continuation_outbox
-         WHERE continuation_id = ?
-      `)
-                .get(continuationId);
-            return outbox === undefined
-                ? !isLoopRecoveryMessage(message)
-                : outbox.messageForm !== 'loop-recovery';
-        });
-        const automaticClaimId = automaticMessage === undefined
-            ? undefined
-            : pluginContinuationId(automaticMessage);
-        const decision = snapshot
-            ? decideDshContinuation(database, {
-                dshSessionId: event.sessionId,
-                cwd: event.cwd,
-                ...(automaticClaimId === undefined
-                    ? {}
-                    : { claimId: automaticClaimId }),
-            }, runId)
-            : undefined;
-        if (decision && (!decision.continue || decision.runId !== runId)) {
-            throw new KiokukoError('CONFLICT', decision.warning ??
-                'The active run cannot be resumed by this DSH session');
-        }
         const capabilityEntries = [
             ...event.capabilities.skills,
             ...event.capabilities.tools,
@@ -1193,13 +1037,8 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 : hasBlockingRequiredCapability(capabilityResolution)
                     ? 'required_capability_unavailable'
                     : 'answer_from_evidence_or_ask_user',
-            securityNotice: 'This resumed DSH run uses only current repository evidence and the current host capability catalog; previously delivered ordinary memory is not replayed implicitly. Active ennoMemory may make a new bounded selection under current authority.',
-            ennoOduno: snapshot
-                ? stateForSnapshot(snapshot)
-                : inapplicableEnnoState(),
+            securityNotice: 'This resumed DSH run uses only current repository evidence and the current host capability catalog; previously delivered ordinary memory is not replayed implicitly.',
         };
-        if (decision?.executionLease)
-            turnState.stageLease(runId, decision.executionLease);
         return { admitted, prepared, catalog: event.capabilities };
     });
     const requestIntentContextFor = async (input, sessionId, nativeSession, previous, task) => {
@@ -1237,19 +1076,16 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 if (!project)
                     return undefined;
                 const candidates = database
-                    .prepare(`SELECT lr.run_id AS runId,
-          ec.orchestration_session_id AS orchestrationId
+                    .prepare(`SELECT lr.run_id AS runId
         FROM ledger_runs AS lr
         LEFT JOIN dsh_coding_workflows AS cw ON cw.run_id = lr.run_id
-        LEFT JOIN enno_contracts AS ec ON ec.run_id = lr.run_id
         WHERE lr.workspace = ? AND COALESCE(lr.task_owner_session_id, lr.dsh_session_id) = ? AND lr.status = 'active'
           AND lr.task_state NOT IN ('Done', 'Ignore')
           AND ((json_extract(cw.snapshot_json, '$.repositoryRoot') = ?
               AND json_extract(cw.snapshot_json, '$.sessionId') = ?
-              AND json_extract(cw.snapshot_json, '$.state') NOT IN ('completed', 'cancelled', 'superseded'))
-            OR (ec.repository_root = ? AND ec.status NOT IN ('completed', 'cancelled', 'blocked')))
+              AND json_extract(cw.snapshot_json, '$.state') NOT IN ('completed', 'cancelled', 'superseded')))
         ORDER BY lr.created_at, lr.run_id LIMIT 2`)
-                    .all(project.workspace, sessionId, project.repositoryRoot, sessionId, project.repositoryRoot);
+                    .all(project.workspace, sessionId, project.repositoryRoot, sessionId);
                 if (candidates.length > 1)
                     throw new KiokukoError('CONFLICT', 'Multiple active tasks match this session; refusing to guess');
                 return candidates[0] === undefined
@@ -1262,15 +1098,6 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 const workflow = readCodingWorkflow(database, runId);
                 const definition = workflow?.definition;
                 const frame = readExecutionFrame(database, runId);
-                const enno = !workflow &&
-                    persistedRun?.runId === runId &&
-                    persistedRun.orchestrationId !== null
-                    ? readEnnoSnapshot(database, {
-                        runId,
-                        workspace: persistedRun.workspace,
-                        orchestrationId: persistedRun.orchestrationId,
-                    })
-                    : undefined;
                 const active = definition
                     ? {
                         runId,
@@ -1291,43 +1118,7 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                             outOfScope: [],
                             constraints: [],
                         }
-                        : enno
-                            ? {
-                                runId,
-                                workflowRevision: enno.revision,
-                                goalRevision: enno.revision,
-                                scopeRevision: enno.revision,
-                                ideal: enno.ideal?.objective ?? enno.handoff.objective,
-                                ...(enno.handoff.target === null
-                                    ? {}
-                                    : { target: enno.handoff.target }),
-                                outOfScope: [...enno.contract.exclusions],
-                                constraints: [...enno.handoff.constraints],
-                            }
-                            : sameOwner && previous.prepared.ennoOduno.applicable
-                                ? {
-                                    runId,
-                                    ...(previous.prepared.ennoOduno.contractRevision === null
-                                        ? {}
-                                        : {
-                                            workflowRevision: previous.prepared.ennoOduno.contractRevision,
-                                            goalRevision: previous.prepared.ennoOduno.contractRevision,
-                                            scopeRevision: previous.prepared.ennoOduno.contractRevision,
-                                        }),
-                                    ...(previous.prepared.ennoOduno.directive?.objective
-                                        ? {
-                                            ideal: previous.prepared.ennoOduno.directive.objective,
-                                        }
-                                        : {}),
-                                    ...(previous.prepared.intake.profile.target
-                                        ? { target: previous.prepared.intake.profile.target }
-                                        : {}),
-                                    outOfScope: [],
-                                    constraints: previous.prepared.intake.profile.constraints
-                                        ? [previous.prepared.intake.profile.constraints]
-                                        : [],
-                                }
-                                : undefined;
+                        : undefined;
                 const candidates = (frame?.conditions ?? [])
                     .filter((condition) => condition.approval === 'proposed')
                     .slice(0, 7)
@@ -1373,7 +1164,7 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             throw new Error('kiokuko-dsh native session cwd is unavailable');
         if (!currentSession(sessionId) &&
             boundSession &&
-            !delegation.isChild(payload.agent))
+            !deepPlanning.executor.isChild(payload.agent))
             await answerReview.recover(payload.agent, async (row) => {
                 await sessions?.flush?.(boundSession);
                 await sessionMirror.checkpointAfterNativeFlush(boundSession);
@@ -1394,7 +1185,7 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         // the authoritative task projection.
         // After a turn was deliberately paused, DSH may consume the next-turn
         // inbox item before pre-step and expose an empty step-local message batch.
-        // The durable Enno run is still authoritative, so fall back to its last
+        // The durable resumed run is still authoritative, so fall back to its last
         // human task. The native conversation retains the new user message for the
         // model, while any supplied step-local user text still replaces this
         // fallback and is recorded as the continuation instruction.
@@ -1437,7 +1228,7 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         const activeRecord = bound ?? previous;
         if (!reviewing &&
             hasHumanInput(payload.messages) &&
-            !delegation.isChild(payload.agent) &&
+            !deepPlanning.executor.isChild(payload.agent) &&
             intentTask.trim()) {
             requestIntentContext = await requestIntentContextFor(payload, sessionId, boundSession, activeRecord, intentTask);
             const requestId = dshTurnRequestId({