kiokuko-dsh 0.2.28 → 0.2.30

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

@@ -1,44 +1,44 @@
+import { nativeRequestProposals } from '../request-proposals.js';
 import { isNativeSubagent } from '../native-subagent.js';
-import { recordDiagnosticAdmission, observeDiagnostic } from '../decisions/diagnostics.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 { 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, initializeExecutionSelection, readExecutionSelection, writeExecutionSelection, } from '../execution-selection.js';
 import { getHeadWorkerForSession } from '../models/session-selection.js';
-import { selectExecution, ExecutionSelectionPending } from '../model-selection-ui.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';
+import { DshIntakeGate, } from '../intake-gate.js';
 import { resolveGroundedIntakeProfile } from '../intake-profile-resolver.js';
 import { deriveAkinatorReasoning } from '../../akinator/reasoning.js';
-import { resolveCapabilities, hasBlockingRequiredCapability } from '../../akinator/capabilities.js';
+import { resolveCapabilities, hasBlockingRequiredCapability, } from '../../akinator/capabilities.js';
 import { readAkinatorSession } from '../../akinator/store.js';
-import { dshTurnBoundarySeq } from '../session-memory-finalizer.js';
-import { createDshIntakeAnswerer } from '../user-interaction.js';
+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 { 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 { 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';
 import { readCodingWorkflow } from '../coding-workflow/store.js';
 import { markCodingScopeChange } from '../coding-workflow/service.js';
 import { readExecutionFrame } from '../execution-frame.js';
-import { createMemoryOwner, memoryOwnerKind } from '../memory-owner.js';
-import { findSecret } from '../../memory/secrets.js';
-import { executionClarification, isContinuationReference } from '../intake-clarification.js';
-import { authorizeTaskLease, bindTaskRepository, captureTaskLease, clearTaskUnresolved, findSessionTask, readTaskSnapshot, recordTaskUnresolved, taskCanExecute } from '../task-state.js';
+import { createMemoryOwner, memoryOwnerKind, } from '../memory-owner.js';
+import { executionClarification, isContinuationReference, } from '../intake-clarification.js';
+import { authorizeTaskLease, bindTaskRepository, captureTaskLease, clearTaskUnresolved, findSessionTask, readTaskSnapshot, recordTaskUnresolved, taskCanExecute, } from '../task-state.js';
 import { continueTaskIntake } from '../existing-task-intake.js';
 import { LedgerStore } from '../../ledger/store.js';
-import { claimExecutionOwner, readExecutionOwner } from '../orchestration/execution-owner.js';
+import { claimExecutionOwner, readExecutionOwner, } from '../orchestration/execution-owner.js';
 import { initializeCodingWorkflow } from '../coding-workflow/store.js';
 import { codingWorkRequested } from '../coding-workflow/intent.js';
 import { initializeTaskCompletion } from '../task-completion.js';
@@ -53,27 +53,39 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             task: event.task,
             cwd: event.cwd,
             deferTaskTypeInference: event.deferTaskTypeInference === true,
-            ...(event.profileHints === undefined ? {} : { profileHints: event.profileHints }),
+            ...(event.profileHints === undefined
+                ? {}
+                : { profileHints: event.profileHints }),
         }).profileHints.taskType;
-        return incomingType !== null && !ENNO_APPLICABLE_TASK_TYPES.includes(incomingType);
+        return (incomingType !== null &&
+            !ENNO_APPLICABLE_TASK_TYPES.includes(incomingType));
     }
     function eventTurn(event) {
-        const data = typeof event.data === 'object' && event.data !== null && !Array.isArray(event.data)
-            ? event.data : undefined;
+        const data = typeof event.data === 'object' &&
+            event.data !== null &&
+            !Array.isArray(event.data)
+            ? event.data
+            : undefined;
         return Number.isSafeInteger(data?.turn) ? data.turn : undefined;
     }
     function continuesCodingScope(event) {
         const intent = event.requestIntent;
-        return !!intent && (intent.relation === 'same_scope_continuation' || intent.relation === 'scope_change')
-            && intent.action !== 'answer' && intent.action !== 'unknown';
+        return (!!intent &&
+            (intent.relation === 'same_scope_continuation' ||
+                intent.relation === 'scope_change') &&
+            intent.action !== 'answer' &&
+            intent.action !== 'unknown');
     }
     let prepareGeneration = 0;
     const continuedTurns = new Map();
     const resumedTurns = new Map();
     const bindAndRecord = async (event, result, generation) => {
-        const authority = await runtime.withDatabase(database => {
-            const identity = { taskId: result.prepared.run.runId, sessionId: event.sessionId,
-                repositoryRoot: result.prepared.project.repositoryRoot };
+        const authority = await runtime.withDatabase((database) => {
+            const identity = {
+                taskId: result.prepared.run.runId,
+                sessionId: event.sessionId,
+                repositoryRoot: result.prepared.project.repositoryRoot,
+            };
             bindTaskRepository(database, identity);
             if (event.signal.aborted)
                 return undefined;
@@ -90,26 +102,61 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             }
         });
         if (authority)
-            await runtime.withDatabase(database => authorizeTaskLease(database, authority));
+            await runtime.withDatabase((database) => authorizeTaskLease(database, authority));
         turnState.record(event, result, generation, authority);
-        await observeDiagnostic(runtime, event.sessionId, db => recordDiagnosticAdmission(db, { sessionId: event.sessionId, turn: event.turn, runId: result.prepared.run.runId,
-            task: event.task, ...(event.requestIntentContext ? { context: event.requestIntentContext } : {}), ...(event.requestIntent ? { decision: event.requestIntent } : {}) }));
+        await observeDiagnostic(runtime, event.sessionId, (db) => recordDiagnosticAdmission(db, {
+            sessionId: event.sessionId,
+            turn: event.turn,
+            runId: result.prepared.run.runId,
+            task: event.task,
+            ...(event.requestIntentContext
+                ? { context: event.requestIntentContext }
+                : {}),
+            ...(event.requestIntent ? { decision: event.requestIntent } : {}),
+        }));
         const reviewItem = currentSession(event.sessionId);
         const reviewAgent = event.nativeAgent;
-        if (reviewItem && reviewAgent?.session && typeof reviewAgent.session.snapshotEvents === 'function') {
+        if (reviewItem &&
+            reviewAgent?.session &&
+            typeof reviewAgent.session.snapshotEvents === 'function') {
             const eligible = () => {
                 const item = currentSession(event.sessionId), selection = getSelection(reviewItem.runId)?.value;
-                return item?.runId === reviewItem.runId && !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);
+                return (item?.runId === reviewItem.runId &&
+                    !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));
             };
-            answerReview.bind({ runId: reviewItem.runId, workspace: reviewItem.workspace, requestId: `run:${reviewItem.runId}`, task: reviewItem.task,
-                catalogDigest: reviewItem.catalog.digest, turn: event.turn, agent: reviewAgent, eligible,
-                current: () => { const item = currentSession(event.sessionId); return item?.runId === reviewItem.runId && item.nativeAgent === reviewAgent && item.nativeSession === reviewAgent.session && agents?.get(reviewAgent.id) === reviewAgent && sessions?.get(event.sessionId) === reviewAgent.session; },
+            answerReview.bind({
+                runId: reviewItem.runId,
+                workspace: reviewItem.workspace,
+                requestId: `run:${reviewItem.runId}`,
+                task: reviewItem.task,
+                catalogDigest: reviewItem.catalog.digest,
+                turn: event.turn,
+                agent: reviewAgent,
+                eligible,
+                current: () => {
+                    const item = currentSession(event.sessionId);
+                    return (item?.runId === reviewItem.runId &&
+                        item.nativeAgent === reviewAgent &&
+                        item.nativeSession === reviewAgent.session &&
+                        agents?.get(reviewAgent.id) === reviewAgent &&
+                        sessions?.get(event.sessionId) === reviewAgent.session);
+                },
                 settled: async () => {
                     const item = currentSession(event.sessionId);
-                    if (!item || item.runId !== reviewItem.runId || item.closed || reviewAgent.status === 'running')
+                    if (!item ||
+                        item.runId !== reviewItem.runId ||
+                        item.closed ||
+                        reviewAgent.status === 'running')
                         return;
                     const intent = await resolveIdleClose(item.agentId, item.sessionId, item.nativeSession, item.nativeAgent);
                     if (intent)
@@ -121,14 +168,19 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
     };
     async function hasPendingExecutionDiscussion(sessionId, cwd) {
         return runtime.withDatabase(async (db) => {
-            const project = await resolveProjectWorkspaceReadOnly(db, cwd, { allowDirectory: true });
+            const project = await resolveProjectWorkspaceReadOnly(db, cwd, {
+                allowDirectory: true,
+            });
             if (!project)
                 return false;
-            const activeRuns = db.prepare(`SELECT run_id FROM ledger_runs
-        WHERE workspace=? AND dsh_session_id=? AND status='active'`).all(project.workspace, sessionId);
+            const activeRuns = db
+                .prepare(`SELECT run_id FROM ledger_runs
+        WHERE workspace=? AND dsh_session_id=? AND status='active'`)
+                .all(project.workspace, sessionId);
             if (activeRuns.length !== 1)
                 return false;
-            return readExecutionSelection(db, activeRuns[0].run_id)?.value.discussion !== undefined;
+            return (readExecutionSelection(db, activeRuns[0].run_id)?.value.discussion !==
+                undefined);
         });
     }
     const refreshContinuedWorkLease = async (item, expected) => {
@@ -147,7 +199,8 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             const workUnitId = state.nextAction === 'execute_work_unit'
                 ? state.directive?.workUnit?.id
                 : undefined;
-            if (state.contractRevision !== expected.contractRevision || workUnitId !== expectedWorkUnitId) {
+            if (state.contractRevision !== expected.contractRevision ||
+                workUnitId !== expectedWorkUnitId) {
                 throw new KiokukoError('CONFLICT', 'Enno WorkUnit changed before DSH turn recovery');
             }
             if (snapshot.dshSessionId !== item.sessionId) {
@@ -165,70 +218,98 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         supersededChoices = new Map();
         async choose(event, result) {
             const runId = result.prepared.run.runId;
-            let stored = await runtime.withDatabase(db => readExecutionSelection(db, runId));
+            let stored = await runtime.withDatabase((db) => readExecutionSelection(db, runId));
             const key = `${event.sessionId}\u0000${event.turn}`;
             const inherited = this.supersededChoices.get(key);
-            if (stored?.value.mode === 'pending' && inherited?.value.status === 'ready' && ['normal', 'enno'].includes(inherited.value.mode)
-                && (!explicitExecutionMode(event.task) || explicitExecutionMode(event.task) === inherited.value.mode)) {
+            if (stored?.value.mode === 'pending' &&
+                inherited?.value.status === 'ready' &&
+                ['normal', 'enno'].includes(inherited.value.mode) &&
+                (!explicitExecutionMode(event.task) ||
+                    explicitExecutionMode(event.task) === inherited.value.mode)) {
                 const revision = stored.revision;
-                stored = await runtime.withDatabase(db => writeExecutionSelection(db, runId, revision, inherited.value));
+                stored = await runtime.withDatabase((db) => writeExecutionSelection(db, runId, revision, inherited.value));
                 this.supersededChoices.delete(key);
             }
             if (result.admitted && result.prepared.selectedSkills === undefined) {
-                const task = await runtime.withDatabase(db => readAkinatorSession(db, { workspace: result.prepared.project.workspace, sessionId: result.prepared.intake.sessionId }).task);
+                const task = await runtime.withDatabase((db) => readAkinatorSession(db, {
+                    workspace: result.prepared.project.workspace,
+                    sessionId: result.prepared.intake.sessionId,
+                }).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 => {
+                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;
+                    return current.value.mode === 'pending'
+                        ? writeExecutionSelection(db, runId, current.revision, {
+                            mode: 'enno',
+                            status: 'selecting',
+                        })
+                        : current;
                 });
             }
             if (!stored)
                 return result;
             const discussion = stored.value.discussion;
             if (discussion && event.turn > discussion.turn) {
-                const incomingType = resolveGroundedIntakeProfile({ task: event.task, cwd: event.cwd, deferTaskTypeInference: event.deferTaskTypeInference === true,
-                    ...(event.profileHints === undefined ? {} : { profileHints: event.profileHints }),
+                const incomingType = resolveGroundedIntakeProfile({
+                    task: event.task,
+                    cwd: event.cwd,
+                    deferTaskTypeInference: event.deferTaskTypeInference === true,
+                    ...(event.profileHints === undefined
+                        ? {}
+                        : { profileHints: event.profileHints }),
                 }).profileHints.taskType;
                 const requestedMode = explicitExecutionMode(event.task);
-                if (requestedMode !== undefined || incomingType !== null && incomingType !== 'chat') {
+                if (requestedMode !== undefined ||
+                    (incomingType !== null && incomingType !== 'chat')) {
                     const { discussion: _answered, ...value } = stored.value;
                     const revision = stored.revision;
-                    stored = await runtime.withDatabase(db => writeExecutionSelection(db, runId, revision, requestedMode === undefined ? value : { ...value, mode: 'pending' }));
+                    stored = await runtime.withDatabase((db) => writeExecutionSelection(db, runId, revision, requestedMode === undefined
+                        ? value
+                        : { ...value, mode: 'pending' }));
                 }
             }
-            if (!ENNO_APPLICABLE_TASK_TYPES.includes(result.prepared.intake.profile.taskType)) {
+            if (!ENNO_APPLICABLE_TASK_TYPES.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);
             const savedHeadWorker = await getHeadWorkerForSession(native.get('llm', false), event.sessionId);
             const selected = await selectExecution({
-                task: event.task, turn: event.turn, signal: event.signal, stored, routes: modelRoutes ?? [],
+                task: event.task,
+                turn: event.turn,
+                signal: event.signal,
+                stored,
+                routes: modelRoutes ?? [],
                 ...(savedHeadWorker ? { savedHeadWorker } : {}),
                 ...(event.nativeAgent ? { agent: event.nativeAgent } : {}),
                 ...(userQuestions ? { questions: userQuestions } : {}),
                 ...(modelCatalog ? { llm: modelCatalog } : {}),
                 ...(modelCompatibility ? { compatibility: modelCompatibility } : {}),
                 save: async (revision, value) => {
-                    const saved = await runtime.withDatabase(db => writeExecutionSelection(db, runId, revision, value));
+                    const saved = await runtime.withDatabase((db) => writeExecutionSelection(db, runId, revision, value));
                     setSelection(runId, saved);
                     return saved;
                 },
             });
             setSelection(runId, selected);
-            const ennoOduno = selected.value.discussion ? result.prepared.ennoOduno
-                : await runtime.withDatabase(db => ennoStateForPreparedTask(db, result.prepared, event.sessionId));
+            const ennoOduno = selected.value.discussion
+                ? result.prepared.ennoOduno
+                : await runtime.withDatabase((db) => ennoStateForPreparedTask(db, result.prepared, event.sessionId));
             return { ...result, prepared: { ...result.prepared, ennoOduno } };
         }
         async prepare(event) {
-            if (event.requestIntent?.action === 'change' && event.requestIntent.changeScope === 'unknown') {
+            if (event.requestIntent?.action === 'change' &&
+                event.requestIntent.changeScope === 'unknown') {
                 throw new KiokukoError('CONFLICT', 'request_intent_change_scope_unresolved');
             }
             // Capture completion ordering before any asynchronous database or intake
@@ -243,41 +324,67 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             // task and opened a new run, so its source revision must not be treated as
             // the new run's execution authority. Human input still takes the source
             // revision check below; never refresh a stale interpretation implicitly.
-            const admittedStep = !!canonical && continuesCodingScope(event) && !hasHumanInput(event.nativeMessages ?? []) && prior?.turn === event.turn
-                && !prior.closed && !prior.failed && prior.task === event.task && !!prior.authority
-                && prior.requestIntent === event.requestIntent && prior.requestIntentContext === event.requestIntentContext;
+            const admittedStep = !!canonical &&
+                continuesCodingScope(event) &&
+                !hasHumanInput(event.nativeMessages ?? []) &&
+                prior?.turn === event.turn &&
+                !prior.closed &&
+                !prior.failed &&
+                prior.task === event.task &&
+                !!prior.authority &&
+                prior.requestIntent === event.requestIntent &&
+                prior.requestIntentContext === event.requestIntentContext;
             if (admittedStep)
-                await runtime.withDatabase(database => authorizeTaskLease(database, prior.authority));
+                await runtime.withDatabase((database) => authorizeTaskLease(database, prior.authority));
             if (canonical && continuesCodingScope(event) && !admittedStep) {
-                const current = await runtime.withDatabase(database => readTaskSnapshot(database, canonical));
-                if (current.revision !== canonical.revision || current.generation !== canonical.generation)
+                const current = await runtime.withDatabase((database) => readTaskSnapshot(database, canonical));
+                if (current.revision !== canonical.revision ||
+                    current.generation !== canonical.generation)
                     throw new KiokukoError('CONFLICT', 'Task continuation revision changed');
-                const canonicalContinuation = event.requestIntent?.relation === 'same_scope_continuation'
-                    && !!event.requestIntentContext && !!rebindRequestIntentDecision(event.requestIntent, event.requestIntentContext)
-                    && event.requestIntent.evidence.taskId === current.taskId && taskCanExecute(current)
-                    && prior?.runId === current.taskId && !!prior.authority
-                    && prior.authority.revision === current.revision && prior.authority.generation === current.generation;
+                const canonicalContinuation = event.requestIntent?.relation === 'same_scope_continuation' &&
+                    !!event.requestIntentContext &&
+                    !!rebindRequestIntentDecision(event.requestIntent, event.requestIntentContext) &&
+                    event.requestIntent.evidence.taskId === current.taskId &&
+                    taskCanExecute(current) &&
+                    prior?.runId === current.taskId &&
+                    !!prior.authority &&
+                    prior.authority.revision === current.revision &&
+                    prior.authority.generation === current.generation;
                 // An explicit resume invalidates the old in-memory preparation and memory
                 // delivery, even when the native session and logical run ID are unchanged.
                 // Reuse the existing resume path before advisory completion retires a
                 // normal task; it also initializes any newly required coding workflow.
-                const resumeCanonicalContinuation = canonicalContinuation && prior && !prior.closed && !prior.failed
-                    && prior.turn < event.turn && !prior.prepared.ennoOduno.applicable
-                    && !await runtime.withDatabase(db => readCodingWorkflow(db, current.taskId));
-                if (resumeCanonicalContinuation || !taskCanExecute(current) || prior?.runId === current.taskId && prior.authority
-                    && (prior.authority.revision !== current.revision || prior.authority.generation !== current.generation)) {
+                const resumeCanonicalContinuation = canonicalContinuation &&
+                    prior &&
+                    !prior.closed &&
+                    !prior.failed &&
+                    prior.turn < event.turn &&
+                    !prior.prepared.ennoOduno.applicable &&
+                    !(await runtime.withDatabase((db) => readCodingWorkflow(db, current.taskId)));
+                if (resumeCanonicalContinuation ||
+                    !taskCanExecute(current) ||
+                    (prior?.runId === current.taskId &&
+                        prior.authority &&
+                        (prior.authority.revision !== current.revision ||
+                            prior.authority.generation !== current.generation))) {
                     const refreshed = await resumeExistingRun?.(event);
                     if (!refreshed)
                         throw new KiokukoError('CONFLICT', 'Current task could not be resumed');
                     continuedTurns.delete(`${event.sessionId}\u0000${event.turn}`);
                     resumedTurns.delete(`${event.sessionId}\u0000${event.turn}`);
-                    const selected = refreshed.admitted ? await this.choose(event, refreshed) : refreshed;
+                    const selected = refreshed.admitted
+                        ? await this.choose(event, refreshed)
+                        : refreshed;
                     await bindAndRecord(event, selected, generation);
                     return selected;
                 }
             }
-            if (prior && prior.turn === event.turn && !prior.closed && prior.task !== event.task && hasHumanInput(event.nativeMessages ?? [])
-                && event.requestIntent?.relation === 'new') {
+            if (prior &&
+                prior.turn === event.turn &&
+                !prior.closed &&
+                prior.task !== event.task &&
+                hasHumanInput(event.nativeMessages ?? []) &&
+                event.requestIntent?.relation === 'new') {
                 const choice = getSelection(prior.runId);
                 if (choice?.value.status === 'ready')
                     this.supersededChoices.set(`${event.sessionId}\u0000${event.turn}`, choice);
@@ -286,7 +393,9 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 continuedTurns.delete(`${event.sessionId}\u0000${event.turn}`);
                 resumedTurns.delete(`${event.sessionId}\u0000${event.turn}`);
             }
-            const reviewProject = await runtime.withDatabase((database) => resolveProjectWorkspaceReadOnly(database, event.cwd, { allowDirectory: true }));
+            const reviewProject = await runtime.withDatabase((database) => resolveProjectWorkspaceReadOnly(database, event.cwd, {
+                allowDirectory: true,
+            }));
             if (reviewProject)
                 await autoReview.acceptInput(reviewProject.workspace, event.sessionId, event.task);
             const cacheKey = `${event.sessionId}\u0000${event.turn}`;
@@ -298,80 +407,177 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 task: event.task,
                 cwd: event.cwd,
                 profileHints: event.profileHints ?? null,
-                ...(event.deferTaskTypeInference ? { deferTaskTypeInference: true } : {}),
+                ...(event.deferTaskTypeInference
+                    ? { deferTaskTypeInference: true }
+                    : {}),
                 evidence: event.evidence ?? null,
                 requestIntent: event.requestIntent ?? null,
-                requestIntentContextDigest: event.requestIntentContext ? canonicalContentHash(event.requestIntentContext) : null,
+                requestIntentContextDigest: event.requestIntentContext
+                    ? canonicalContentHash(event.requestIntentContext)
+                    : null,
                 memoryOwner: event.memoryOwner ?? null,
                 skillDiscoveryMode: event.skillDiscoveryMode ?? null,
                 catalogDigest: event.capabilities.digest,
             });
-            const unresolvedBinding = canonicalContentHash({ sessionId: event.sessionId, agentId: event.agent.id,
-                turn: event.turn, sourceStartSeq: event.sourceStartSeq ?? null, task: event.task, cwd: event.cwd,
-                evidence: event.evidence ?? null, context: event.requestIntentContext ?? null, catalogDigest: event.capabilities.digest,
-                skillDiscoveryMode: event.skillDiscoveryMode ?? null });
+            const unresolvedBinding = canonicalContentHash({
+                sessionId: event.sessionId,
+                agentId: event.agent.id,
+                turn: event.turn,
+                sourceStartSeq: event.sourceStartSeq ?? null,
+                task: event.task,
+                cwd: event.cwd,
+                evidence: event.evidence ?? null,
+                context: event.requestIntentContext ?? null,
+                catalogDigest: event.capabilities.digest,
+                skillDiscoveryMode: event.skillDiscoveryMode ?? null,
+            });
             const cached = continuedTurns.get(cacheKey) ?? resumedTurns.get(cacheKey);
             if (cached !== undefined) {
-                if (cached.fingerprint !== fingerprint && 'unresolvedBinding' in cached && cached.unresolvedBinding === unresolvedBinding
-                    && cached.nativeAgent === event.nativeAgent && cached.nativeSession === event.nativeSession
-                    && event.requestIntentContext && event.requestIntent
-                    && continuesCodingScope(event) && rebindRequestIntentDecision(event.requestIntent, event.requestIntentContext)) {
+                if (cached.fingerprint !== fingerprint &&
+                    'unresolvedBinding' in cached &&
+                    cached.unresolvedBinding === unresolvedBinding &&
+                    cached.nativeAgent === event.nativeAgent &&
+                    cached.nativeSession === event.nativeSession &&
+                    event.requestIntentContext &&
+                    event.requestIntent &&
+                    continuesCodingScope(event) &&
+                    rebindRequestIntentDecision(event.requestIntent, event.requestIntentContext)) {
                     // A host-owned confirmation may resume before optional interpretation.
                     // Resolve that exact unresolved input once; changing resolved input still conflicts.
                     const kind = memoryOwnerKind(event.requestIntent, event.profileHints?.taskType);
-                    const prepared = { ...cached.result.prepared,
-                        memoryOwner: createMemoryOwner(kind, { agentId: event.agent.id, sessionId: event.sessionId, turn: event.turn,
-                            requestDigest: canonicalContentHash(event.task), runId: cached.result.prepared.run.runId }) };
-                    const resolved = await this.choose(event, { ...cached.result, prepared });
-                    continuedTurns.set(cacheKey, { fingerprint, result: resolved, ...(event.nativeAgent ? { nativeAgent: event.nativeAgent } : {}), ...(event.nativeSession ? { nativeSession: event.nativeSession } : {}) });
+                    const prepared = {
+                        ...cached.result.prepared,
+                        memoryOwner: createMemoryOwner(kind, {
+                            agentId: event.agent.id,
+                            sessionId: event.sessionId,
+                            turn: event.turn,
+                            requestDigest: canonicalContentHash(event.task),
+                            runId: cached.result.prepared.run.runId,
+                        }),
+                    };
+                    const resolved = await this.choose(event, {
+                        ...cached.result,
+                        prepared,
+                    });
+                    continuedTurns.set(cacheKey, {
+                        fingerprint,
+                        result: resolved,
+                        ...(event.nativeAgent ? { nativeAgent: event.nativeAgent } : {}),
+                        ...(event.nativeSession
+                            ? { nativeSession: event.nativeSession }
+                            : {}),
+                    });
                     await bindAndRecord(event, resolved, generation);
                     return resolved;
                 }
-                if (cached.fingerprint !== fingerprint
-                    || cached.nativeAgent !== event.nativeAgent
-                    || cached.nativeSession !== event.nativeSession) {
+                if (cached.fingerprint !== fingerprint ||
+                    cached.nativeAgent !== event.nativeAgent ||
+                    cached.nativeSession !== event.nativeSession) {
                     throw new KiokukoError('CONFLICT', 'dsh continued turn was reused with different bound input');
                 }
                 this.assertCatalog(cached.result.catalog, event.capabilities);
-                if (!hasHumanInput(event.nativeMessages ?? []) && event.nativeMessages?.some(message => objectRecord(objectRecord(message)?.source)?.form === ANSWER_REVIEW_FORM)) {
-                    if (!event.nativeAgent || !await answerReview.accept(event.nativeAgent, event.nativeMessages, event.turn, event.capabilities.digest))
+                if (!hasHumanInput(event.nativeMessages ?? []) &&
+                    event.nativeMessages?.some((message) => objectRecord(objectRecord(message)?.source)?.form ===
+                        ANSWER_REVIEW_FORM)) {
+                    if (!event.nativeAgent ||
+                        !(await answerReview.accept(event.nativeAgent, event.nativeMessages, event.turn, event.capabilities.digest)))
                         throw new Error('Stale answer review continuation');
                 }
-                return event.signal.aborted ? { ...cached.result, admitted: false } : this.choose(event, cached.result);
+                return event.signal.aborted
+                    ? { ...cached.result, admitted: false }
+                    : this.choose(event, cached.result);
             }
             const previous = currentForAgentEvent(event.agent.id, event.sessionId, undefined, event.nativeSession, event.nativeAgent);
             const reviewMessages = event.nativeMessages ?? [];
             if (hasHumanInput(reviewMessages))
                 answerReview.humanInput(event.sessionId, event.turn);
-            if (!hasHumanInput(reviewMessages) && reviewMessages.some(message => objectRecord(objectRecord(message)?.source)?.form === ANSWER_REVIEW_FORM)) {
-                if (!previous || !event.nativeAgent || !await answerReview.accept(event.nativeAgent, reviewMessages, event.turn, event.capabilities.digest))
+            if (!hasHumanInput(reviewMessages) &&
+                reviewMessages.some((message) => objectRecord(objectRecord(message)?.source)?.form ===
+                    ANSWER_REVIEW_FORM)) {
+                if (!previous ||
+                    !event.nativeAgent ||
+                    !(await answerReview.accept(event.nativeAgent, reviewMessages, event.turn, event.capabilities.digest)))
                     throw new Error('Unbound answer review continuation');
                 // Only the coordinator's exact reserved message may carry this owner
                 // into another native turn; the request and run remain unchanged.
                 const owner = previous.prepared.memoryOwner;
-                const prepared = owner ? { ...previous.prepared,
-                    memoryOwner: createMemoryOwner(owner.kind, { ...owner, turn: event.turn }) } : previous.prepared;
-                const continued = { admitted: true, prepared, catalog: previous.catalog };
-                continuedTurns.set(cacheKey, { fingerprint, result: continued, nativeAgent: event.nativeAgent, ...(event.nativeSession === undefined ? {} : { nativeSession: event.nativeSession }) });
+                const prepared = owner
+                    ? {
+                        ...previous.prepared,
+                        memoryOwner: createMemoryOwner(owner.kind, {
+                            ...owner,
+                            turn: event.turn,
+                        }),
+                    }
+                    : previous.prepared;
+                const continued = {
+                    admitted: true,
+                    prepared,
+                    catalog: previous.catalog,
+                };
+                continuedTurns.set(cacheKey, {
+                    fingerprint,
+                    result: continued,
+                    nativeAgent: event.nativeAgent,
+                    ...(event.nativeSession === undefined
+                        ? {}
+                        : { nativeSession: event.nativeSession }),
+                });
                 await bindAndRecord(event, continued, generation);
                 return continued;
             }
-            if (previous !== undefined && previous.turn === event.turn && !previous.closed) {
-                if (previous.task !== event.task && hasHumanInput(event.nativeMessages ?? [])) {
+            if (previous !== undefined &&
+                previous.turn === event.turn &&
+                !previous.closed) {
+                if (previous.task !== event.task &&
+                    hasHumanInput(event.nativeMessages ?? [])) {
                     if (!continuesCodingScope(event))
-                        return { admitted: false, prepared: previous.prepared, catalog: event.capabilities };
-                    const workflow = await runtime.withDatabase(db => readCodingWorkflow(db, previous.runId));
+                        return {
+                            admitted: false,
+                            prepared: previous.prepared,
+                            catalog: event.capabilities,
+                        };
+                    const workflow = await runtime.withDatabase((db) => readCodingWorkflow(db, previous.runId));
                     const scopeChanging = !!workflow && event.requestIntent?.relation === 'scope_change';
                     if (scopeChanging && event.requestIntent) {
-                        const evidenceRefs = event.requestIntentContext ? requestIntentReferenceIds(event.requestIntentContext) : [];
-                        await runtime.withDatabase(db => markCodingScopeChange(db, { runId: previous.runId, sessionId: previous.sessionId, repositoryRoot: previous.repositoryRoot }, `request-intent:${event.sessionId}:${event.turn}:${event.requestIntent.evidence.requestDigest}`, event.requestIntent.evidence.requestDigest, evidenceRefs));
+                        const evidenceRefs = event.requestIntentContext
+                            ? requestIntentReferenceIds(event.requestIntentContext)
+                            : [];
+                        await runtime.withDatabase((db) => markCodingScopeChange(db, {
+                            runId: previous.runId,
+                            sessionId: previous.sessionId,
+                            repositoryRoot: previous.repositoryRoot,
+                        }, `request-intent:${event.sessionId}:${event.turn}:${event.requestIntent.evidence.requestDigest}`, event.requestIntent.evidence.requestDigest, evidenceRefs));
                     }
-                    const ownerKind = event.memoryOwner ?? memoryOwnerKind(event.requestIntent, event.profileHints?.taskType ?? previous.prepared.intake.profile.taskType);
-                    const prepared = { ...previous.prepared,
-                        ...(scopeChanging ? { context: null, memoryPolicy: { memoryReasoningRequired: false, contextWithheld: false, withheldReason: null, deliveryEmpty: true } } : {}),
-                        memoryOwner: createMemoryOwner(ownerKind, { agentId: event.agent.id, sessionId: event.sessionId, turn: event.turn,
-                            requestDigest: canonicalContentHash(event.task), runId: previous.runId }) };
-                    const selected = await this.choose(event, { admitted: !event.signal.aborted, prepared, catalog: event.capabilities });
+                    const ownerKind = event.memoryOwner ??
+                        memoryOwnerKind(event.requestIntent, event.profileHints?.taskType ??
+                            previous.prepared.intake.profile.taskType);
+                    const prepared = {
+                        ...previous.prepared,
+                        ...(scopeChanging
+                            ? {
+                                context: null,
+                                memoryPolicy: {
+                                    memoryReasoningRequired: false,
+                                    contextWithheld: false,
+                                    withheldReason: null,
+                                    deliveryEmpty: true,
+                                },
+                            }
+                            : {}),
+                        memoryOwner: createMemoryOwner(ownerKind, {
+                            agentId: event.agent.id,
+                            sessionId: event.sessionId,
+                            turn: event.turn,
+                            requestDigest: canonicalContentHash(event.task),
+                            runId: previous.runId,
+                        }),
+                    };
+                    const selected = await this.choose(event, {
+                        admitted: !event.signal.aborted,
+                        prepared,
+                        catalog: event.capabilities,
+                    });
                     if (selected.admitted)
                         await bindAndRecord(event, selected, generation);
                     return selected;
@@ -389,13 +595,18 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             }
             if (previous !== undefined && previous.turn < event.turn) {
                 if (event.signal.aborted)
-                    return { admitted: false, prepared: previous.prepared, catalog: event.capabilities };
+                    return {
+                        admitted: false,
+                        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) {
+                if (previousState.nextAction === 'ask_user_confirmation' &&
+                    previousState.contractRevision !== null) {
                     const expectedRevision = previousState.contractRevision;
                     const requestedChanges = event.task.trim();
                     if (requestedChanges.length === 0)
@@ -415,73 +626,140 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                         action: 'revise',
                         requestedChanges,
                     }));
-                    previous.prepared = { ...previous.prepared, ennoOduno: revised.ennoOduno };
+                    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 superseded = previous.prepared.ennoOduno.applicable &&
+                    supersedesUnstartedEnno(event, previousState);
                 const selection = getSelection(previous.runId)?.value;
-                const coding = await runtime.withDatabase(db => readCodingWorkflow(db, previous.runId));
+                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)
-                    && (!hasHumanInput(event.nativeMessages ?? []) || continuesCodingScope(event));
-                const continuePrevious = resumeCoding || selection && (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));
+                const resumeCoding = coding &&
+                    !['completed', 'cancelled', 'superseded'].includes(coding.state) &&
+                    (!hasHumanInput(event.nativeMessages ?? []) ||
+                        continuesCodingScope(event));
+                const continuePrevious = resumeCoding ||
+                    (selection &&
+                        (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));
                 if (continuePrevious) {
                     this.assertCatalog(previous.catalog, event.capabilities);
                     const intent = event.requestIntent;
-                    const scopeChanging = !!coding && intent?.relation === 'scope_change' && intent.action !== 'answer' && intent.action !== 'unknown';
+                    const scopeChanging = !!coding &&
+                        intent?.relation === 'scope_change' &&
+                        intent.action !== 'answer' &&
+                        intent.action !== 'unknown';
                     if (scopeChanging && intent) {
-                        const evidenceRefs = event.requestIntentContext ? requestIntentReferenceIds(event.requestIntentContext) : [];
-                        await runtime.withDatabase(db => markCodingScopeChange(db, { runId: previous.runId, sessionId: previous.sessionId, repositoryRoot: previous.repositoryRoot }, `request-intent:${event.sessionId}:${event.turn}:${intent.evidence.requestDigest}`, intent.evidence.requestDigest, evidenceRefs));
+                        const evidenceRefs = event.requestIntentContext
+                            ? requestIntentReferenceIds(event.requestIntentContext)
+                            : [];
+                        await runtime.withDatabase((db) => markCodingScopeChange(db, {
+                            runId: previous.runId,
+                            sessionId: previous.sessionId,
+                            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 };
+                        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: { memoryReasoningRequired: false, contextWithheld: false, withheldReason: null, deliveryEmpty: true } };
-                    const ownerKind = event.memoryOwner ?? memoryOwnerKind(intent, event.profileHints?.taskType ?? previous.prepared.intake.profile.taskType);
-                    const continuedPrepared = { ...previous.prepared, ...(continuedMemory ?? {}),
-                        memoryOwner: createMemoryOwner(ownerKind, { agentId: event.agent.id, sessionId: event.sessionId, turn: event.turn,
-                            requestDigest: canonicalContentHash(event.task), runId: previous.runId }) };
-                    const continued = await this.choose(event, { admitted: !event.signal.aborted, prepared: continuedPrepared, catalog: event.capabilities });
+                    const continuedMemory = {
+                        context: null,
+                        memoryPolicy: {
+                            memoryReasoningRequired: false,
+                            contextWithheld: false,
+                            withheldReason: null,
+                            deliveryEmpty: true,
+                        },
+                    };
+                    const ownerKind = event.memoryOwner ??
+                        memoryOwnerKind(intent, event.profileHints?.taskType ??
+                            previous.prepared.intake.profile.taskType);
+                    const continuedPrepared = {
+                        ...previous.prepared,
+                        ...(continuedMemory ?? {}),
+                        memoryOwner: createMemoryOwner(ownerKind, {
+                            agentId: event.agent.id,
+                            sessionId: event.sessionId,
+                            turn: event.turn,
+                            requestDigest: canonicalContentHash(event.task),
+                            runId: previous.runId,
+                        }),
+                    };
+                    const continued = await this.choose(event, {
+                        admitted: !event.signal.aborted,
+                        prepared: continuedPrepared,
+                        catalog: event.capabilities,
+                    });
                     if (continued.admitted) {
                         continuedTurns.set(cacheKey, {
                             fingerprint,
-                            ...(event.requestIntent?.relation === 'unknown' || event.requestIntent?.action === 'unknown' ? { unresolvedBinding } : {}),
+                            ...(event.requestIntent?.relation === 'unknown' ||
+                                event.requestIntent?.action === 'unknown'
+                                ? { unresolvedBinding }
+                                : {}),
                             result: continued,
-                            ...(event.profileHints === undefined ? {} : { profileHints: event.profileHints }),
-                            ...(event.nativeAgent === undefined ? {} : { nativeAgent: event.nativeAgent }),
-                            ...(event.nativeSession === undefined ? {} : { nativeSession: event.nativeSession }),
+                            ...(event.profileHints === undefined
+                                ? {}
+                                : { profileHints: event.profileHints }),
+                            ...(event.nativeAgent === undefined
+                                ? {}
+                                : { nativeAgent: event.nativeAgent }),
+                            ...(event.nativeSession === undefined
+                                ? {}
+                                : { nativeSession: event.nativeSession }),
                         });
                         await bindAndRecord(event, continued, generation);
                     }
                     return continued;
                 }
                 if (event.signal.aborted)
-                    return { admitted: false, prepared: previous.prepared, catalog: event.capabilities };
-                await retireSupersededRun(previous, superseded || previousState.status === 'cancelled' ? 'cancelled' : previousState.status === 'blocked' ? 'failed' : 'completed');
+                    return {
+                        admitted: false,
+                        prepared: previous.prepared,
+                        catalog: event.capabilities,
+                    };
+                await retireSupersededRun(previous, superseded || previousState.status === 'cancelled'
+                    ? 'cancelled'
+                    : previousState.status === 'blocked'
+                        ? 'failed'
+                        : 'completed');
             }
             const resumed = await resumeExistingRun?.(event);
             if (resumed !== undefined) {
                 resumedTurns.set(cacheKey, {
                     fingerprint,
                     result: resumed,
-                    ...(event.profileHints === undefined ? {} : { profileHints: event.profileHints }),
-                    ...(event.nativeAgent === undefined ? {} : { nativeAgent: event.nativeAgent }),
-                    ...(event.nativeSession === undefined ? {} : { nativeSession: event.nativeSession }),
+                    ...(event.profileHints === undefined
+                        ? {}
+                        : { profileHints: event.profileHints }),
+                    ...(event.nativeAgent === undefined
+                        ? {}
+                        : { nativeAgent: event.nativeAgent }),
+                    ...(event.nativeSession === undefined
+                        ? {}
+                        : { nativeSession: event.nativeSession }),
                 });
                 await bindAndRecord(event, resumed, generation);
                 const selected = await this.choose(event, resumed);
@@ -502,7 +780,9 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             const previous = currentSession(event.sessionId);
             if (previous)
                 ennoMemory.invalidate(previous.runId);
-            const state = previous === undefined ? undefined : turnState.policyState(previous.runId);
+            const state = previous === undefined
+                ? undefined
+                : turnState.policyState(previous.runId);
             if (previous !== undefined) {
                 try {
                     await runtime.withDatabase((database) => withImmediateTransaction(database, () => {
@@ -529,12 +809,23 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             const item = currentSession(event.sessionId);
             if (!item)
                 return;
-            const task = human ? textFromMessages(messages.filter(isHumanMessage), event.task) : undefined;
+            const task = human
+                ? textFromMessages(messages.filter(isHumanMessage), event.task)
+                : undefined;
             if (task !== undefined)
                 item.memoryInput = task;
-            await executionSupport.refresh({ ...executionBinding(item), ...(task === undefined ? {} : {
-                    task, humanInput: canonicalContentHash({ turn: event.turn, messages: messages.filter(isHumanMessage) }),
-                }) }, human);
+            await executionSupport.refresh({
+                ...executionBinding(item),
+                ...(task === undefined
+                    ? {}
+                    : {
+                        task,
+                        humanInput: canonicalContentHash({
+                            turn: event.turn,
+                            messages: messages.filter(isHumanMessage),
+                        }),
+                    }),
+            }, human);
         }
         /** The public preparation tool uses the same human boundary as native pre-step. */
         async prepareRequestedWork(event) {
@@ -560,7 +851,8 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 return { kind: 'reject' };
             const nativeMessages = Object.freeze([...(event.nativeMessages ?? [])]);
             await captureInitialInput(event.sessionId, event.turn, nativeMessages);
-            const humanPresent = nativeMessages.some(isHumanMessage) || downstream.messages.some(isHumanMessage);
+            const humanPresent = nativeMessages.some(isHumanMessage) ||
+                downstream.messages.some(isHumanMessage);
             const seenContinuations = new Set();
             let nativeDecision = {
                 ...downstream,
@@ -576,7 +868,11 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             };
             if (humanPresent) {
                 await this.acceptHumanInput(event);
-                nativeDecision = { ...nativeDecision, messages: nativeDecision.messages.filter(message => objectRecord(objectRecord(message)?.source)?.form !== ANSWER_REVIEW_FORM) };
+                nativeDecision = {
+                    ...nativeDecision,
+                    messages: nativeDecision.messages.filter((message) => objectRecord(objectRecord(message)?.source)?.form !==
+                        ANSWER_REVIEW_FORM),
+                };
             }
             try {
                 const result = await this.prepare(event);
@@ -584,33 +880,59 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                     return nativeDecision;
                 const item = currentSession(event.sessionId);
                 if (item !== undefined) {
-                    if (getSelection(item.runId)?.value.status === 'ready' || getSelection(item.runId)?.value.discussion) {
-                        const original = await runtime.withDatabase(db => unexecutedRunInput(db, item.runId, item.sessionId));
-                        const deliveredIds = new Set(sessionEventSource(event.nativeSession).snapshotEvents()
-                            .filter(e => e.type === 'user/message').map(e => objectRecord(e.data)?.id));
-                        const currentIds = new Set(nativeDecision.messages.map(m => objectRecord(m)?.id));
-                        const missing = original.filter(m => {
+                    if (getSelection(item.runId)?.value.status === 'ready' ||
+                        getSelection(item.runId)?.value.discussion) {
+                        const original = await runtime.withDatabase((db) => unexecutedRunInput(db, item.runId, item.sessionId));
+                        const deliveredIds = new Set(sessionEventSource(event.nativeSession)
+                            .snapshotEvents()
+                            .filter((e) => e.type === 'user/message')
+                            .map((e) => objectRecord(e.data)?.id));
+                        const currentIds = new Set(nativeDecision.messages.map((m) => objectRecord(m)?.id));
+                        const missing = original.filter((m) => {
                             const id = objectRecord(m)?.id;
-                            return typeof id === 'string' && !deliveredIds.has(id) && !currentIds.has(id);
+                            return (typeof id === 'string' &&
+                                !deliveredIds.has(id) &&
+                                !currentIds.has(id));
                         });
                         if (missing.length)
-                            nativeDecision = { ...nativeDecision, messages: [...missing, ...nativeDecision.messages] };
+                            nativeDecision = {
+                                ...nativeDecision,
+                                messages: [...missing, ...nativeDecision.messages],
+                            };
                     }
-                    const humanMessages = [...new Map([...nativeMessages, ...nativeDecision.messages].filter(isHumanMessage)
-                            .map(message => [objectRecord(message)?.id ?? canonicalContentHash(message), message])).values()];
+                    const humanMessages = [
+                        ...new Map([...nativeMessages, ...nativeDecision.messages]
+                            .filter(isHumanMessage)
+                            .map((message) => [
+                            objectRecord(message)?.id ?? canonicalContentHash(message),
+                            message,
+                        ])).values(),
+                    ];
                     await this.refreshExecutionInput(event, humanMessages, humanPresent);
                     // Only an empty, automatic step can be deliberately paused. Human,
                     // attachment and other pending inputs must never be consumed here.
-                    if (!humanPresent && event.nativeMessages?.length === 0 && nativeDecision.messages.every(message => {
-                        const source = objectRecord(objectRecord(message)?.source);
-                        return (source?.kind === 'runtime-context' || source?.kind === 'plugin' && source.plugin === '@deepseek-ai/dsh-system-prompt') && source.form === 'snapshot';
-                    })) {
+                    if (!humanPresent &&
+                        event.nativeMessages?.length === 0 &&
+                        nativeDecision.messages.every((message) => {
+                            const source = objectRecord(objectRecord(message)?.source);
+                            return ((source?.kind === 'runtime-context' ||
+                                (source?.kind === 'plugin' &&
+                                    source.plugin === '@deepseek-ai/dsh-system-prompt')) &&
+                                source.form === 'snapshot');
+                        })) {
                         const paused = await executionSupport.pauseAtBoundary(event.sessionId, async (id, text) => {
                             const session = event.nativeSession;
                             if (!session?.snapshotEvents || !sessions?.flush)
                                 throw new Error('Pause notice delivery unavailable');
-                            await runtime.withDatabase(db => saveSessionNotice(db, { id, runId: item.runId, sessionId: item.sessionId,
-                                rootPath: item.cwd, kind: 'status', text, anchorSeq: session.snapshotEvents().at(-1)?.seq ?? 0 }));
+                            await runtime.withDatabase((db) => saveSessionNotice(db, {
+                                id,
+                                runId: item.runId,
+                                sessionId: item.sessionId,
+                                rootPath: item.cwd,
+                                kind: 'status',
+                                text,
+                                anchorSeq: session.snapshotEvents().at(-1)?.seq ?? 0,
+                            }));
                             await sessions.flush(session);
                             event.signal.throwIfAborted();
                             // A human can arrive while the native log flush is in flight.
@@ -626,12 +948,20 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 if (item !== undefined && !getSelection(item.runId)?.value.discussion)
                     await refreshEnnoMemory(item, event.signal);
                 const messages = await contextMessages(event, nativeDecision.messages);
-                return { ...nativeDecision, messages: [...executionSupport.projectMessages(event.sessionId, nativeDecision.messages), ...messages] };
+                return {
+                    ...nativeDecision,
+                    messages: [
+                        ...executionSupport.projectMessages(event.sessionId, nativeDecision.messages),
+                        ...messages,
+                    ],
+                };
             }
             catch (error) {
                 if (error instanceof ExecutionSelectionPending)
                     return { kind: 'reject' };
-                if (!humanPresent && nativeMessages.some(message => objectRecord(objectRecord(message)?.source)?.form === ANSWER_REVIEW_FORM))
+                if (!humanPresent &&
+                    nativeMessages.some((message) => objectRecord(objectRecord(message)?.source)?.form ===
+                        ANSWER_REVIEW_FORM))
                     return { kind: 'reject' };
                 // The native message array is authoritative. Kiokuko degradation must
                 // not turn a claimed user prompt into a rejected/empty DSH step.
@@ -645,26 +975,44 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             resumedTurns.delete(`${sessionId}\u0000${turn}`);
         }
     }
-    const gate = new CapturingGate(runtime, userQuestions === undefined ? undefined : createDshIntakeAnswerer(userQuestions), (context) => capabilityCatalog(skills, tools, context), true, akinatorMemoryConfig, decisions, completionMode, memoryRetrievalConfig);
+    const gate = new CapturingGate(runtime, userQuestions === undefined
+        ? undefined
+        : createDshIntakeAnswerer(userQuestions), (context) => capabilityCatalog(skills, tools, context), true, akinatorMemoryConfig, decisions, completionMode, memoryRetrievalConfig);
     const refreshMemoryOwner = async (item, signal) => {
         signal.throwIfAborted();
-        item.prepared = { ...item.prepared, context: null, memoryPolicy: { memoryReasoningRequired: false, contextWithheld: false, withheldReason: null, deliveryEmpty: true } };
+        item.prepared = {
+            ...item.prepared,
+            context: null,
+            memoryPolicy: {
+                memoryReasoningRequired: false,
+                contextWithheld: false,
+                withheldReason: null,
+                deliveryEmpty: true,
+            },
+        };
     };
     resumeExistingRun = async (event) => runtime.withDatabase(async (database) => {
         const project = await resolveProjectWorkspaceReadOnly(database, event.cwd, { allowDirectory: true });
         if (project === undefined)
             return undefined;
-        const task = findSessionTask(database, { sessionId: event.sessionId, repositoryRoot: project.repositoryRoot });
+        const task = findSessionTask(database, {
+            sessionId: event.sessionId,
+            repositoryRoot: project.repositoryRoot,
+        });
         if (!task)
             return undefined;
         const context = event.requestIntentContext;
         if (hasHumanInput(event.nativeMessages ?? [])) {
-            if (!event.requestIntent || !context || !rebindRequestIntentDecision(event.requestIntent, context))
+            if (!event.requestIntent ||
+                !context ||
+                !rebindRequestIntentDecision(event.requestIntent, context))
                 throw new KiokukoError('CONFLICT', 'A source-bound interpretation is required for the current task');
             if (event.requestIntent.relation === 'new')
                 return undefined;
-            if (!continuesCodingScope(event) || context.activeTask?.taskId !== task.taskId
-                || context.activeTask.revision !== task.revision || context.activeTask.generation !== task.generation)
+            if (!continuesCodingScope(event) ||
+                context.activeTask?.taskId !== task.taskId ||
+                context.activeTask.revision !== task.revision ||
+                context.activeTask.generation !== task.generation)
                 throw new KiokukoError('CONFLICT', 'The current task continuation is unresolved or stale');
         }
         const runId = task.taskId;
@@ -676,16 +1024,26 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         // Enno selection can recover Enno ownership instead of ordinary execution.
         const executionMode = selection?.mode === 'enno' ? 'enno' : 'normal';
         const owner = readExecutionOwner(database, event.sessionId);
-        if (owner && (owner.run_id !== runId || owner.workspace !== project.workspace || owner.mode !== executionMode))
+        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=?')
+        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,
-        });
+        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))) {
+        if (snapshot &&
+            !event.signal.aborted &&
+            supersedesUnstartedEnno(event, stateForSnapshot(snapshot))) {
             terminalizeLedgerRunInTransaction(database, runId, 'cancelled');
             return undefined;
         }
@@ -693,28 +1051,56 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             const continuationId = pluginContinuationId(message);
             if (continuationId === undefined)
                 return false;
-            const outbox = database.prepare(`
+            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';
+      `)
+                .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;
+        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');
+            throw new KiokukoError('CONFLICT', decision.warning ??
+                'The active run cannot be resumed by this DSH session');
         }
-        const capabilityEntries = [...event.capabilities.skills, ...event.capabilities.tools];
+        const capabilityEntries = [
+            ...event.capabilities.skills,
+            ...event.capabilities.tools,
+        ];
         const { state: intakeState, link: intakeLink } = await continueTaskIntake(database, {
-            ...task, workspace: project.workspace, expectedRevision: task.revision, expectedGeneration: task.generation,
-            capabilities: capabilityEntries, signal: event.signal,
-            answerer: userQuestions ? createDshIntakeAnswerer(userQuestions) : undefined,
+            ...task,
+            workspace: project.workspace,
+            expectedRevision: task.revision,
+            expectedGeneration: task.generation,
+            capabilities: capabilityEntries,
+            signal: event.signal,
+            answerer: userQuestions
+                ? createDshIntakeAnswerer(userQuestions)
+                : undefined,
             agent: event.nativeAgent,
-            validateCapabilities: async () => gate.assertCatalog(event.capabilities, await capabilityCatalog(skills, tools, { agent: event.agent, ...(event.nativeAgent ? { nativeAgent: event.nativeAgent } : {}), cwd: event.cwd, signal: event.signal })),
+            validateCapabilities: async () => gate.assertCatalog(event.capabilities, await capabilityCatalog(skills, tools, {
+                agent: event.agent,
+                ...(event.nativeAgent
+                    ? { nativeAgent: event.nativeAgent }
+                    : {}),
+                cwd: event.cwd,
+                signal: event.signal,
+            })),
         });
         const intake = intakeState.session;
         const capabilityResolution = resolveCapabilities({
@@ -725,24 +1111,46 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             memoryUse: 'none',
         });
         const canonicalCwd = realpathSync(event.cwd);
-        const admitted = !event.signal.aborted && intakeState.status !== 'needs_answer'
-            && taskCanExecute(readTaskSnapshot(database, task)) && !hasBlockingRequiredCapability(capabilityResolution);
+        const admitted = !event.signal.aborted &&
+            intakeState.status !== 'needs_answer' &&
+            taskCanExecute(readTaskSnapshot(database, task)) &&
+            !hasBlockingRequiredCapability(capabilityResolution);
         const runStatus = new LedgerStore(database).readRun(runId).status;
         if (runStatus !== 'active' && runStatus !== 'intake')
             throw new KiokukoError('CONFLICT', 'Task requires an explicit resume');
         if (admitted) {
             if (!owner)
-                claimExecutionOwner(database, { sessionId: event.sessionId, workspace: project.workspace,
-                    mode: executionMode, startId: typeof run.metadata.requestId === 'string' ? run.metadata.requestId : `run:${runId}`, runId });
+                claimExecutionOwner(database, {
+                    sessionId: event.sessionId,
+                    workspace: project.workspace,
+                    mode: executionMode,
+                    startId: typeof run.metadata.requestId === 'string'
+                        ? run.metadata.requestId
+                        : `run:${runId}`,
+                    runId,
+                });
             initializeTaskCompletion(database, runId, completionMode);
-            if (executionMode === 'normal' && !readCodingWorkflow(database, runId) && codingWorkRequested(intake.task, event.requestIntent, intake.profile.taskType))
-                initializeCodingWorkflow(database, { runId, sessionId: event.sessionId, repositoryRoot: project.repositoryRoot,
-                    requestId: typeof run.metadata.requestId === 'string' ? run.metadata.requestId : `run:${runId}`, task: intake.task });
+            if (executionMode === 'normal' &&
+                !readCodingWorkflow(database, runId) &&
+                codingWorkRequested(intake.task, event.requestIntent, intake.profile.taskType))
+                initializeCodingWorkflow(database, {
+                    runId,
+                    sessionId: event.sessionId,
+                    repositoryRoot: project.repositoryRoot,
+                    requestId: typeof run.metadata.requestId === 'string'
+                        ? run.metadata.requestId
+                        : `run:${runId}`,
+                    task: intake.task,
+                });
         }
         const prepared = {
-            memoryOwner: createMemoryOwner(event.memoryOwner ?? memoryOwnerKind(event.requestIntent, intake.profile.taskType), {
-                agentId: event.agent.id, sessionId: event.sessionId, turn: event.turn,
-                requestDigest: canonicalContentHash(event.task), runId,
+            memoryOwner: createMemoryOwner(event.memoryOwner ??
+                memoryOwnerKind(event.requestIntent, intake.profile.taskType), {
+                agentId: event.agent.id,
+                sessionId: event.sessionId,
+                turn: event.turn,
+                requestDigest: canonicalContentHash(event.task),
+                runId,
             }),
             project,
             executionContext: {
@@ -762,14 +1170,33 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             },
             capabilities: capabilityResolution,
             run: { runId, status: runStatus },
-            skillDiscovery: { attempted: false, mode: 'off', requirements: [], queries: [], cacheHits: 0, candidates: 0, selected: [], failures: [] },
+            skillDiscovery: {
+                attempted: false,
+                mode: 'off',
+                requirements: [],
+                queries: [],
+                cacheHits: 0,
+                candidates: 0,
+                selected: [],
+                failures: [],
+            },
             context: null,
-            memoryPolicy: { memoryReasoningRequired: false, contextWithheld: false, withheldReason: null, deliveryEmpty: true },
+            memoryPolicy: {
+                memoryReasoningRequired: false,
+                contextWithheld: false,
+                withheldReason: null,
+                deliveryEmpty: true,
+            },
             warnings: capabilityResolution.warnings,
-            nextAction: admitted ? 'proceed' : hasBlockingRequiredCapability(capabilityResolution)
-                ? 'required_capability_unavailable' : 'answer_from_evidence_or_ask_user',
+            nextAction: admitted
+                ? 'proceed'
+                : 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(),
+            ennoOduno: snapshot
+                ? stateForSnapshot(snapshot)
+                : inapplicableEnnoState(),
         };
         if (decision?.executionLease)
             turnState.stageLease(runId, decision.executionLease);
@@ -785,17 +1212,32 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             return undefined;
         const messageRefs = requestIntentMessageRefs(human, task);
         const activeTask = await runtime.withDatabase(async (database) => {
-            const project = await resolveProjectWorkspaceReadOnly(database, cwd, { allowDirectory: true });
-            return project ? findSessionTask(database, { sessionId, repositoryRoot: project.repositoryRoot }) : undefined;
+            const project = await resolveProjectWorkspaceReadOnly(database, cwd, {
+                allowDirectory: true,
+            });
+            return project
+                ? findSessionTask(database, {
+                    sessionId,
+                    repositoryRoot: project.repositoryRoot,
+                })
+                : undefined;
         });
         let activeGoal;
         let proposals = [];
-        const sameOwner = previous && previous.sessionId === sessionId && previous.nativeAgent === input.agent && previous.nativeSession === nativeSession;
-        const persistedRun = sameOwner ? undefined : await runtime.withDatabase(async (database) => {
-            const project = await resolveProjectWorkspaceReadOnly(database, cwd, { allowDirectory: true });
-            if (!project)
-                return undefined;
-            const candidates = database.prepare(`SELECT lr.run_id AS runId,
+        const sameOwner = previous &&
+            previous.sessionId === sessionId &&
+            previous.nativeAgent === input.agent &&
+            previous.nativeSession === nativeSession;
+        const persistedRun = sameOwner
+            ? undefined
+            : await runtime.withDatabase(async (database) => {
+                const project = await resolveProjectWorkspaceReadOnly(database, cwd, {
+                    allowDirectory: true,
+                });
+                if (!project)
+                    return undefined;
+                const candidates = database
+                    .prepare(`SELECT lr.run_id AS runId,
           ec.orchestration_session_id AS orchestrationId
         FROM ledger_runs AS lr
         LEFT JOIN dsh_coding_workflows AS cw ON cw.run_id = lr.run_id
@@ -807,69 +1249,112 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
               AND json_extract(cw.snapshot_json, '$.state') NOT IN ('completed', 'cancelled', 'superseded'))
             OR (ec.repository_root = ? AND ec.status NOT IN ('completed', 'cancelled', 'blocked')))
         ORDER BY lr.created_at, lr.run_id LIMIT 2`)
-                .all(project.workspace, sessionId, project.repositoryRoot, sessionId, project.repositoryRoot);
-            if (candidates.length > 1)
-                throw new KiokukoError('CONFLICT', 'Multiple active tasks match this session; refusing to guess');
-            return candidates[0] === undefined ? undefined : { ...candidates[0], workspace: project.workspace };
-        });
+                    .all(project.workspace, sessionId, project.repositoryRoot, sessionId, project.repositoryRoot);
+                if (candidates.length > 1)
+                    throw new KiokukoError('CONFLICT', 'Multiple active tasks match this session; refusing to guess');
+                return candidates[0] === undefined
+                    ? undefined
+                    : { ...candidates[0], workspace: project.workspace };
+            });
         const runId = sameOwner ? previous.runId : persistedRun?.runId;
         if (runId) {
-            const state = await runtime.withDatabase(database => {
+            const state = await runtime.withDatabase((database) => {
                 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 })
+                const enno = !workflow &&
+                    persistedRun?.runId === runId &&
+                    persistedRun.orchestrationId !== null
+                    ? readEnnoSnapshot(database, {
+                        runId,
+                        workspace: persistedRun.workspace,
+                        orchestrationId: persistedRun.orchestrationId,
+                    })
                     : undefined;
-                const active = definition ? {
-                    runId, workflowRevision: workflow.revision, goalId: definition.goal.goalId,
-                    goalRevision: definition.goal.revision, scopeRevision: workflow.scopeVersion, ideal: definition.goal.ideal,
-                    target: definition.goal.target, outOfScope: [...definition.goal.outOfScope], constraints: [...definition.goal.constraints],
-                } : workflow ? { runId, workflowRevision: workflow.revision, scopeRevision: workflow.scopeVersion, 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],
+                const active = definition
+                    ? {
+                        runId,
+                        workflowRevision: workflow.revision,
+                        goalId: definition.goal.goalId,
+                        goalRevision: definition.goal.revision,
+                        scopeRevision: workflow.scopeVersion,
+                        ideal: definition.goal.ideal,
+                        target: definition.goal.target,
+                        outOfScope: [...definition.goal.outOfScope],
+                        constraints: [...definition.goal.constraints],
                     }
-                        : sameOwner && previous.prepared.ennoOduno.applicable ? {
+                    : workflow
+                        ? {
                             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 } : {}),
+                            workflowRevision: workflow.revision,
+                            scopeRevision: workflow.scopeVersion,
                             outOfScope: [],
-                            constraints: previous.prepared.intake.profile.constraints ? [previous.prepared.intake.profile.constraints] : [],
-                        } : undefined;
-                const candidates = (frame?.conditions ?? []).filter(condition => condition.approval === 'proposed').slice(0, 7)
-                    .map(condition => ({ id: `condition-${canonicalContentHash([runId, frame.revision, condition.field, condition.text, condition.planRevision])}`,
-                    revision: condition.planRevision ?? frame.revision, digest: canonicalContentHash(condition),
-                    text: `${condition.field}: ${condition.text}`, field: condition.field }));
+                            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;
+                const candidates = (frame?.conditions ?? [])
+                    .filter((condition) => condition.approval === 'proposed')
+                    .slice(0, 7)
+                    .map((condition) => ({
+                    id: `condition-${canonicalContentHash([runId, frame.revision, condition.field, condition.text, condition.planRevision])}`,
+                    revision: condition.planRevision ?? frame.revision,
+                    digest: canonicalContentHash(condition),
+                    text: `${condition.field}: ${condition.text}`,
+                    field: condition.field,
+                }));
                 return { active, candidates };
             });
             activeGoal = state.active;
             proposals = state.candidates;
         }
         const eventSource = sessionEventSource(nativeSession);
-        const precedingAssistant = [...eventSource.snapshotEvents()].reverse().find(event => event.type === 'assistant/message'
-            && (eventTurn(event) ?? Number.MAX_SAFE_INTEGER) < input.turn);
-        if (precedingAssistant && proposals.length < 8) {
-            const data = objectRecord(precedingAssistant.data);
-            const message = objectRecord(data?.message) ?? data;
-            const content = Array.isArray(message?.content) ? message.content : [];
-            const text = content.filter((block) => objectRecord(block)?.type === 'text')
-                .map((block) => objectRecord(block)?.text).filter((value) => typeof value === 'string').join('\n').trim();
-            const messageId = typeof message?.id === 'string' ? message.id : `seq:${precedingAssistant.seq}`;
-            if (message?.role === 'assistant' && text && text.length <= 8192 && findSecret(text) === undefined) {
-                proposals = [...proposals, { id: `assistant-${canonicalContentHash([sessionId, messageId])}`, revision: null,
-                        digest: canonicalContentHash(text), text }];
-            }
-        }
-        return createRequestIntentContext({ task, messageRefs, ...(activeGoal ? { activeGoal } : {}),
-            ...(activeTask ? { activeTask } : {}), proposals: proposals.slice(0, 8) });
+        proposals = [
+            ...proposals,
+            ...nativeRequestProposals(eventSource.snapshotEvents(), input.turn, sessionId),
+        ].slice(0, 8);
+        return createRequestIntentContext({
+            task,
+            messageRefs,
+            ...(activeGoal ? { activeGoal } : {}),
+            ...(activeTask ? { activeTask } : {}),
+            proposals: proposals.slice(0, 8),
+        });
     };
     const mapPreStep = async (payload, advisoryType, suppliedIntent, interpretationOnly = false) => {
         const nativeSession = payload.agent.session;
@@ -886,11 +1371,17 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         const cwd = boundSession?.header?.cwd;
         if (typeof cwd !== 'string' || cwd.length === 0)
             throw new Error('kiokuko-dsh native session cwd is unavailable');
-        if (!currentSession(sessionId) && boundSession && !delegation.isChild(payload.agent))
+        if (!currentSession(sessionId) &&
+            boundSession &&
+            !delegation.isChild(payload.agent))
             await answerReview.recover(payload.agent, async (row) => {
                 await sessions?.flush?.(boundSession);
                 await sessionMirror.checkpointAfterNativeFlush(boundSession);
-                await closeTurn({ runId: row.runId, status: row.status, ...(row.endSeq === undefined ? {} : { sourceEndSeq: row.endSeq }) });
+                await closeTurn({
+                    runId: row.runId,
+                    status: row.status,
+                    ...(row.endSeq === undefined ? {} : { sourceEndSeq: row.endSeq }),
+                });
             });
         const sourceStartSeq = dshTurnBoundarySeq(sessionEventSource(boundSession), payload.turn, 'start');
         const bound = currentForAgentEvent(payload.agent.id, sessionId, payload.turn, boundSession, payload.agent);
@@ -907,9 +1398,18 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         // 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.
-        const reviewing = !hasHumanInput(payload.messages) && payload.messages.some(message => objectRecord(objectRecord(message)?.source)?.form === ANSWER_REVIEW_FORM);
-        const intentTask = hasHumanInput(payload.messages) ? textFromMessages(payload.messages.filter(isHumanMessage), '') : '';
-        const task = intentTask.trim() ? intentTask : bound?.task ?? (reviewing && previous ? previous.task : textFromMessages(payload.messages, previous?.task));
+        const reviewing = !hasHumanInput(payload.messages) &&
+            payload.messages.some((message) => objectRecord(objectRecord(message)?.source)?.form ===
+                ANSWER_REVIEW_FORM);
+        const intentTask = hasHumanInput(payload.messages)
+            ? textFromMessages(payload.messages.filter(isHumanMessage), '')
+            : '';
+        const task = intentTask.trim()
+            ? intentTask
+            : (bound?.task ??
+                (reviewing && previous
+                    ? previous.task
+                    : textFromMessages(payload.messages, previous?.task)));
         let profile = (() => {
             if (bound !== undefined)
                 return bound.profileHints;
@@ -919,19 +1419,35 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 return previous.profileHints;
             if (previous === undefined)
                 return undefined;
-            const inferred = resolveGroundedIntakeProfile({ task, cwd }).profileHints.taskType;
-            const previousType = getSelection(previous.runId)?.value.discussion ? 'chat' : previous.prepared.intake.profile.taskType;
-            return inferred === null || previousType === 'chat' && inferred === 'chat' ? { taskType: previousType } : undefined;
+            const inferred = resolveGroundedIntakeProfile({ task, cwd }).profileHints
+                .taskType;
+            const previousType = getSelection(previous.runId)?.value.discussion
+                ? 'chat'
+                : previous.prepared.intake.profile.taskType;
+            return inferred === null ||
+                (previousType === 'chat' && inferred === 'chat')
+                ? { taskType: previousType }
+                : undefined;
         })();
-        let deferTaskTypeInference = bound?.deferTaskTypeInference ?? (reviewing ? previous?.deferTaskTypeInference : false) ?? false;
+        let deferTaskTypeInference = bound?.deferTaskTypeInference ??
+            (reviewing ? previous?.deferTaskTypeInference : false) ??
+            false;
         let requestIntentContext;
         let requestIntent;
         const activeRecord = bound ?? previous;
-        if (!reviewing && hasHumanInput(payload.messages) && !delegation.isChild(payload.agent) && intentTask.trim()) {
+        if (!reviewing &&
+            hasHumanInput(payload.messages) &&
+            !delegation.isChild(payload.agent) &&
+            intentTask.trim()) {
             requestIntentContext = await requestIntentContextFor(payload, sessionId, boundSession, activeRecord, intentTask);
-            const requestId = dshTurnRequestId({ dshSessionId: sessionId, turn: payload.turn });
-            const establishedConversation = profile?.taskType === 'chat' && !requestIntentContext?.activeGoal
-                && (!requestIntentContext?.activeTask || requestIntentContext.activeTask.type === 'chat');
+            const requestId = dshTurnRequestId({
+                dshSessionId: sessionId,
+                turn: payload.turn,
+            });
+            const establishedConversation = profile?.taskType === 'chat' &&
+                !requestIntentContext?.activeGoal &&
+                (!requestIntentContext?.activeTask ||
+                    requestIntentContext.activeTask.type === 'chat');
             if (requestIntentContext && !establishedConversation) {
                 requestIntent = await classifyRequestIntent(decisions, requestId, requestIntentContext, payload.signal);
             }
@@ -939,7 +1455,11 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             // This profile is inherited from a previous turn, not a current user choice.
             // Let Laya assess new work, but retain the user's chat choice for an
             // ambiguous continuation instead of asking the same classification again.
-            const explicit = advisoryType ?? (configuration?.provider === 'laya-coreml' && profile?.taskType !== 'chat' ? undefined : profile?.taskType);
+            const explicit = advisoryType ??
+                (configuration?.provider === 'laya-coreml' &&
+                    profile?.taskType !== 'chat'
+                    ? undefined
+                    : profile?.taskType);
             const classification = await classifyTaskForIntake(decisions, requestId, intentTask, explicit, payload.signal);
             deferTaskTypeInference = classification.deferInference;
             if (classification.taskType)
@@ -957,40 +1477,66 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             const rebound = rebindRequestIntentDecision(suppliedIntent, requestIntentContext);
             if (!rebound)
                 throw new KiokukoError('CONFLICT', 'request_intent_evidence_stale');
-            if (requestIntent?.source === 'decision-provider' && requestIntent.relation !== 'unknown' && requestIntent.action !== 'unknown'
-                && (requestIntent.relation !== rebound.relation || requestIntent.action !== rebound.action)) {
+            if (requestIntent?.source === 'decision-provider' &&
+                requestIntent.relation !== 'unknown' &&
+                requestIntent.action !== 'unknown' &&
+                (requestIntent.relation !== rebound.relation ||
+                    requestIntent.action !== rebound.action)) {
                 throw new KiokukoError('CONFLICT', 'request_intent_provider_conflict');
             }
-            requestIntent = requestIntent?.source === 'decision-provider' && requestIntent.relation !== 'unknown' && requestIntent.action !== 'unknown'
-                ? { ...requestIntent, evidence: rebound.evidence } : rebound;
+            requestIntent =
+                requestIntent?.source === 'decision-provider' &&
+                    requestIntent.relation !== 'unknown' &&
+                    requestIntent.action !== 'unknown'
+                    ? { ...requestIntent, evidence: rebound.evidence }
+                    : rebound;
         }
         if (requestIntentContext?.activeTask && hasHumanInput(payload.messages)) {
             const identity = requestIntentContext.activeTask;
             const contextDigest = canonicalContentHash(requestIntentContext);
-            const requestId = dshTurnRequestId({ dshSessionId: sessionId, turn: payload.turn });
-            await runtime.withDatabase(db => {
+            const requestId = dshTurnRequestId({
+                dshSessionId: sessionId,
+                turn: payload.turn,
+            });
+            await runtime.withDatabase((db) => {
                 if (requestIntentIsUnresolved(requestIntent))
                     return recordTaskUnresolved(db, identity, {
                         operationId: `intent:${canonicalContentHash([requestId, contextDigest, requestIntent?.unresolvedReason ?? 'request_intent_unresolved'])}`,
-                        expectedRevision: identity.revision, requestId, contextDigest,
+                        expectedRevision: identity.revision,
+                        requestId,
+                        contextDigest,
                         reason: requestIntent?.unresolvedReason ?? 'request_intent_unresolved',
                         evidence: requestIntentReferenceIds(requestIntentContext),
                     });
                 const current = readTaskSnapshot(db, identity);
-                return current.unresolved?.requestId === requestId && current.unresolved.contextDigest === contextDigest
-                    ? clearTaskUnresolved(db, identity, { requestId, contextDigest, expectedRevision: identity.revision }) : undefined;
+                return current.unresolved?.requestId === requestId &&
+                    current.unresolved.contextDigest === contextDigest
+                    ? clearTaskUnresolved(db, identity, {
+                        requestId,
+                        contextDigest,
+                        expectedRevision: identity.revision,
+                    })
+                    : undefined;
             });
         }
-        const pendingDiscussion = isContinuationReference(intentTask)
-            && await hasPendingExecutionDiscussion(sessionId, cwd);
-        const establishedConversation = profile?.taskType === 'chat' && !requestIntentContext?.activeGoal && !requestIntentContext?.activeTask;
-        if (!interpretationOnly && intentTask.trim() && !pendingDiscussion && !establishedConversation) {
+        const pendingDiscussion = isContinuationReference(intentTask) &&
+            (await hasPendingExecutionDiscussion(sessionId, cwd));
+        const establishedConversation = profile?.taskType === 'chat' &&
+            !requestIntentContext?.activeGoal &&
+            !requestIntentContext?.activeTask;
+        if (!interpretationOnly &&
+            intentTask.trim() &&
+            !pendingDiscussion &&
+            !establishedConversation) {
             const clarification = executionClarification(intentTask, requestIntent, requestIntentContext);
             if (clarification)
                 throw new KiokukoError('VALIDATION_ERROR', clarification);
         }
-        const legacyTaskType = advisoryType !== undefined && advisoryType !== 'chat'
-            && !requestIntentContext?.activeGoal && !requestIntentContext?.activeTask && (requestIntentContext?.proposals.length ?? 0) === 0;
+        const legacyTaskType = advisoryType !== undefined &&
+            advisoryType !== 'chat' &&
+            !requestIntentContext?.activeGoal &&
+            !requestIntentContext?.activeTask &&
+            (requestIntentContext?.proposals.length ?? 0) === 0;
         if (requestIntent?.source === 'unresolved' && legacyTaskType)
             requestIntent = undefined;
         if (requestIntent?.source !== 'unresolved') {
@@ -1001,13 +1547,18 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         // Coding Lisp choice belongs to the admitted Goal, after all criteria exist.
         // Task intake never starts Lisp or interrupts an explanation with a mode question.
         const catalog = await capabilityCatalog(skills, tools, {
-            agent: { id: payload.agent.id }, nativeAgent: payload.agent, cwd, signal: payload.signal,
+            agent: { id: payload.agent.id },
+            nativeAgent: payload.agent,
+            cwd,
+            signal: payload.signal,
         });
         return {
             agent: { id: payload.agent.id },
             nativeAgent: payload.agent,
             sessionId,
-            ...(boundSession === undefined ? {} : { nativeSession: boundSession }),
+            ...(boundSession === undefined
+                ? {}
+                : { nativeSession: boundSession }),
             turn: payload.turn,
             sourceStartSeq,
             step: payload.step,
@@ -1026,14 +1577,28 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
     return {
         gate,
         mapPreStep,
+        requestContext: async (payload, task) => {
+            const session = payload.agent.session;
+            if (!session)
+                return undefined;
+            const previous = currentForAgentEvent(payload.agent.id, session.id, payload.turn, session, payload.agent) ??
+                currentForAgentEvent(payload.agent.id, session.id, undefined, session, payload.agent);
+            return requestIntentContextFor(payload, session.id, session, previous, task);
+        },
         interpret: async (payload) => {
             const event = await mapPreStep(payload, undefined, undefined, true);
             if (!event.requestIntentContext || !event.requestIntent)
                 return undefined;
-            return { context: event.requestIntentContext, decision: event.requestIntent };
+            return {
+                context: event.requestIntentContext,
+                decision: event.requestIntent,
+            };
         },
         refreshMemoryOwner,
-        clear: () => { continuedTurns.clear(); resumedTurns.clear(); },
+        clear: () => {
+            continuedTurns.clear();
+            resumedTurns.clear();
+        },
     };
 }
 //# sourceMappingURL=admission.js.map