kiokuko-dsh 0.2.7 → 0.2.9

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

@@ -1,11 +1,9 @@
+import { isNativeSubagent } from '../native-subagent.js';
 import { policyState } from '../host-adapter/turn-state.js';
-import { bindMemoryApplication, memoryRetrievalStatus } from '../../memory/application.js';
-import { createMemoryReuseRuntime } from '../memory-reuse.js';
 import { dshTurnRequestId } from '../intake-profile-resolver.js';
 import { classifyTaskForIntake, selectInstalledSkills } from '../decisions/workflows.js';
-import { classifyRequestIntent, createRequestIntentContext, rebindRequestIntentDecision, requestIntentMessageRefs, requestIntentReferenceIds, requestIntentTaskType } from '../decisions/request-intent.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 { refreshContinuedTaskContext } from '../task-intake.js';
 import { saveSessionNotice } from '../plugin-records.js';
 import { explicitExecutionMode, initializeExecutionSelection, readExecutionSelection, writeExecutionSelection } from '../execution-selection.js';
 import { getHeadWorkerForSession } from '../models/session-selection.js';
@@ -16,8 +14,8 @@ import { withImmediateTransaction } from '../../db/transaction.js';
 import { DshIntakeGate } from '../intake-gate.js';
 import { resolveGroundedIntakeProfile } from '../intake-profile-resolver.js';
 import { deriveAkinatorReasoning } from '../../akinator/reasoning.js';
-import { resolveCapabilities } from '../../akinator/capabilities.js';
-import { readAkinatorSession, readRunIntakeLink } from '../../akinator/store.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 { canonicalContentHash } from '../../serialization/validate.js';
@@ -33,9 +31,16 @@ 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 { assertMemoryOwner, createMemoryOwner, memoryOwnerKind } from '../memory-owner.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 { continueTaskIntake } from '../existing-task-intake.js';
+import { LedgerStore } from '../../ledger/store.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';
 export function createAdmission({ native, skills, tools, userQuestions, sessions, agents, deepPlanning, modelCatalog, modelCompatibility, modelRoutes, now, runtime, decisions, answerReview, delegation, executionSupport, ennoMemory, memoryFinalizer, autoReview, sessionMirror, akinatorMemoryConfig, memoryRetrievalConfig, completionMode, turnState, getSelection, setSelection, refreshEnnoMemory, executionBinding, captureInitialInput, contextMessages, resolveIdleClose, retireSupersededRun, cancelBoundarySession, isSelectionBlocked, closeTurn, readStateForRun, capabilityCatalog, sessionEventSource, objectRecord, isHumanMessage, textFromMessages, pluginContinuationId, isLoopRecoveryMessage, }) {
     const currentSession = turnState.currentSession;
     const currentForAgentEvent = turnState.currentForAgentEvent;
@@ -65,25 +70,35 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
     const continuedTurns = new Map();
     const resumedTurns = new Map();
     const bindAndRecord = async (event, result, generation) => {
-        const sourceStartSeq = event.sourceStartSeq
-            ?? dshTurnBoundarySeq(sessionEventSource(event.nativeSession), event.turn, 'start');
-        await memoryFinalizer.bindRunStart({
-            runId: result.prepared.run.runId,
-            workspace: result.prepared.project.workspace,
-            dshSessionId: event.sessionId,
-            sourceStartSeq,
-            sourceStartTurn: event.turn,
+        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;
+            // A continued native turn can reuse an already Working task without a
+            // fresh admission. Capture its current lease from SQLite as well; never
+            // synthesize authority from the model or a cached turn record.
+            try {
+                return captureTaskLease(database, identity);
+            }
+            catch (error) {
+                if (result.admitted)
+                    throw error;
+                return undefined;
+            }
         });
-        turnState.record(event, result, generation);
+        if (authority)
+            await runtime.withDatabase(database => authorizeTaskLease(database, authority));
+        turnState.record(event, result, generation, authority);
         const reviewItem = currentSession(event.sessionId);
         const reviewAgent = event.nativeAgent;
         if (reviewItem && reviewAgent?.session && typeof reviewAgent.session.snapshotEvents === 'function') {
             const eligible = () => {
                 const item = currentSession(event.sessionId), selection = getSelection(reviewItem.runId)?.value;
-                const header = reviewAgent.session.header;
                 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) && !header?.parentSession && header?.origin !== 'subagent' && !header?.delegationDepth
+                    && !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,
@@ -99,26 +114,7 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 },
             });
         }
-        if (result.admitted && event.requestIntent?.relation !== 'scope_change' && result.prepared.run.status === 'active'
-            && result.prepared.memoryOwner?.kind === 'execution'
-            && currentSession(event.sessionId)?.prepareGeneration === generation && !delegation.isChild(event.nativeAgent ?? {})) {
-            assertMemoryOwner(result.prepared.memoryOwner, { agentId: event.agent.id, sessionId: event.sessionId, turn: event.turn,
-                requestDigest: canonicalContentHash(event.task), runId: result.prepared.run.runId }, 'execution');
-            await runtime.withDatabase(db => {
-                if (currentSession(event.sessionId)?.prepareGeneration !== generation)
-                    return;
-                bindMemoryApplication(db, {
-                    runId: result.prepared.run.runId, workspace: result.prepared.project.workspace,
-                    sessionId: event.sessionId, repositoryRoot: result.prepared.project.repositoryRoot,
-                }, result.prepared.intake.profile, result.prepared.context, memoryRetrievalStatus(db, result.prepared.project.workspace, result.prepared.context, result.prepared.memoryPolicy.contextWithheld));
-            });
-        }
-        if (event.nativeSession && !delegation.isChild(event.nativeAgent ?? {})) {
-            try {
-                await autoReview.bind({ workspace: result.prepared.project.workspace, runId: result.prepared.run.runId, session: event.nativeSession, startSeq: sourceStartSeq });
-            }
-            catch { /* Unsupported or unavailable review source must not veto a native request. */ }
-        }
+        // Memory delivery/binding is not an admission prerequisite.
     };
     async function hasPendingExecutionDiscussion(sessionId, cwd) {
         return runtime.withDatabase(async (db) => {
@@ -234,6 +230,25 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             // context deliveries that finish out of order.
             const generation = ++prepareGeneration;
             const prior = currentForAgentEvent(event.agent.id, event.sessionId, undefined, event.nativeSession, event.nativeAgent);
+            const canonical = event.requestIntentContext?.activeTask;
+            if (canonical && continuesCodingScope(event)) {
+                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');
+                // An explicit resume invalidates the old in-memory preparation and memory
+                // delivery, even when the native session and logical run ID are unchanged.
+                if (!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;
+                    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') {
                 const choice = getSelection(prior.runId);
@@ -408,37 +423,8 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                         const next = policyState(refreshedWork.state, previous, previous.sessionId, refreshedWork.lease);
                         turnState.applyPolicy(previous.runId, next);
                     }
-                    let continuedMemory;
-                    if (scopeChanging)
-                        continuedMemory = { context: null,
-                            memoryPolicy: { memoryReasoningRequired: false, contextWithheld: false, withheldReason: null, deliveryEmpty: true } };
-                    else if (!ennoMemory.ownsActiveRefresh(previous.prepared.ennoOduno)) {
-                        const captured = previous.prepared, started = performance.now();
-                        const inboxIdentity = () => canonicalContentHash([...(event.nativeAgent?.inbox?.nextStep ?? []), ...(event.nativeAgent?.inbox?.nextTurn ?? [])].filter(isHumanMessage));
-                        const pendingInput = inboxIdentity();
-                        const assertCurrent = () => {
-                            event.signal.throwIfAborted();
-                            if (inboxIdentity() !== pendingInput || previous.closed || previous.prepared !== captured || currentSession(event.sessionId) !== previous || prepareGeneration !== generation)
-                                throw new KiokukoError('CONFLICT', 'continued_memory_stale');
-                            if (event.nativeSession !== previous.nativeSession || event.nativeAgent !== previous.nativeAgent)
-                                throw new KiokukoError('CONFLICT', 'continued_memory_owner_changed');
-                            if (performance.now() - started > 1000 + (decisions.memoryReuse.mode === 'auto' ? decisions.memoryReuse.budgetMs : 0))
-                                throw new Error('continued_memory_deadline');
-                        };
-                        try {
-                            continuedMemory = await runtime.withDatabase(async (database, embedding) => {
-                                if (embedding.mode === 'required')
-                                    throw new Error('required_embedding_unavailable');
-                                return refreshContinuedTaskContext({ database, memoryReuse: await createMemoryReuseRuntime(decisions, `run:${captured.run.runId}`, event.signal), memoryRetrieval: memoryRetrievalConfig, prepared: captured, task: event.task, capabilities: [...event.capabilities.skills, ...event.capabilities.tools], assertCurrent,
-                                    validateCapabilities: async () => { const fresh = await capabilityCatalog(skills, tools, { agent: event.agent, ...(event.nativeAgent ? { nativeAgent: event.nativeAgent } : {}), cwd: event.cwd, signal: event.signal }); this.assertCatalog(event.capabilities, fresh); assertCurrent(); } });
-                            });
-                        }
-                        catch (error) {
-                            if (event.signal.aborted || error instanceof KiokukoError && ['CONFLICT', 'SECURITY_REJECTION', 'AUTHENTICATION_ERROR', 'INTEGRITY_ERROR'].includes(error.code))
-                                throw error;
-                            /* Optional retrieval failure retains the previous delivery, whose state is validated before injection. */
-                        }
-                    }
+                    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,
@@ -634,74 +620,44 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
     }
     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) => {
-        const prepared = item.prepared;
-        const owner = prepared.memoryOwner;
-        if (!owner || owner.kind !== 'execution')
-            throw new KiokukoError('CONFLICT', 'memory_owner_unavailable');
-        const ownerIdentity = { agentId: item.agentId, sessionId: item.sessionId, turn: item.turn,
-            requestDigest: canonicalContentHash(item.task), runId: item.runId };
-        assertMemoryOwner(owner, ownerIdentity, 'execution');
-        const started = performance.now();
-        const refreshed = await runtime.withDatabase(async (database, embedding) => {
-            const assertCurrent = () => {
-                signal.throwIfAborted();
-                if (currentSession(item.sessionId) !== item || item.prepared !== prepared || item.closed || item.failed
-                    || item.nativeAgent === undefined || agents?.get(item.nativeAgent.id) !== item.nativeAgent
-                    || item.nativeSession === undefined || sessions?.get(item.sessionId) !== item.nativeSession) {
-                    throw new KiokukoError('CONFLICT', 'memory_owner_changed');
-                }
-                assertMemoryOwner(owner, ownerIdentity, 'execution');
-                if (performance.now() - started > 1000 + (decisions.memoryReuse.mode === 'auto' ? decisions.memoryReuse.budgetMs : 0)) {
-                    throw new KiokukoError('CONFLICT', 'memory_owner_rebuild_deadline');
-                }
-            };
-            if (embedding.mode === 'required')
-                throw new KiokukoError('SERVICE_UNAVAILABLE', 'required_embedding_unavailable');
-            const capabilities = [...item.catalog.skills, ...item.catalog.tools];
-            const memoryReuse = await createMemoryReuseRuntime(decisions, `run:${item.runId}`, signal);
-            return refreshContinuedTaskContext({ database, memoryReuse, memoryRetrieval: memoryRetrievalConfig, prepared,
-                task: item.memoryInput ?? item.task, capabilities, assertCurrent,
-                validateCapabilities: async () => {
-                    const fresh = await capabilityCatalog(skills, tools, { agent: { id: item.agentId },
-                        ...(item.nativeAgent ? { nativeAgent: item.nativeAgent } : {}), cwd: item.cwd, signal });
-                    gate.assertCatalog(item.catalog, fresh);
-                    assertCurrent();
-                } });
-        });
         signal.throwIfAborted();
-        if (currentSession(item.sessionId) !== item || item.prepared !== prepared)
-            throw new KiokukoError('CONFLICT', 'memory_owner_changed');
-        item.prepared = { ...prepared, ...refreshed };
-        await runtime.withDatabase(database => bindMemoryApplication(database, {
-            runId: item.runId, workspace: item.workspace, sessionId: item.sessionId, repositoryRoot: item.repositoryRoot,
-        }, item.prepared.intake.profile, item.prepared.context, memoryRetrievalStatus(database, item.workspace, item.prepared.context, item.prepared.memoryPolicy.contextWithheld)));
+        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 candidates = database.prepare(`
-      SELECT lr.run_id AS runId, ec.orchestration_session_id AS orchestrationId
-      FROM ledger_runs AS lr
-      LEFT JOIN enno_contracts AS ec ON ec.run_id = lr.run_id
-      LEFT JOIN dsh_exploration_states AS es ON es.run_id = lr.run_id
-      LEFT JOIN dsh_execution_selections AS xs ON xs.run_id = lr.run_id
-      LEFT JOIN dsh_coding_workflows AS cw ON cw.run_id = lr.run_id
-      WHERE lr.workspace = ? AND lr.dsh_session_id = ? AND lr.status = 'active'
-        AND ((ec.repository_root = ? AND ec.status NOT IN ('completed', 'cancelled', 'blocked'))
-          OR (ec.run_id IS NULL AND (json_extract(es.state_json, '$.paused') = 1 OR xs.run_id IS NOT NULL)))
-        AND (cw.run_id IS NULL OR (? = 1 AND json_extract(cw.snapshot_json, '$.state') NOT IN ('completed', 'cancelled', 'superseded')))
-      ORDER BY lr.created_at, lr.run_id LIMIT 2
-    `).all(project.workspace, event.sessionId, project.repositoryRoot, continuesCodingScope(event) ? 1 : 0);
-        if (candidates.length === 0)
+        const task = findSessionTask(database, { sessionId: event.sessionId, repositoryRoot: project.repositoryRoot });
+        if (!task)
             return undefined;
-        if (candidates.length !== 1)
-            throw new KiokukoError('CONFLICT', 'Multiple active runs match this session; refusing to guess');
-        const candidate = candidates[0];
-        const runId = candidate.runId;
-        const snapshot = candidate.orchestrationId === null ? undefined : readEnnoSnapshot(database, {
-            runId, workspace: project.workspace, orchestrationId: candidate.orchestrationId,
+        const context = event.requestIntentContext;
+        if (hasHumanInput(event.nativeMessages ?? [])) {
+            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)
+                throw new KiokukoError('CONFLICT', 'The current task continuation is unresolved or stale');
+        }
+        const runId = task.taskId;
+        const run = new LedgerStore(database).readRun(runId);
+        const selection = readExecutionSelection(database, runId)?.value;
+        if (selection?.mode === 'deep-thinker')
+            throw new KiokukoError('CONFLICT', 'Deep Thinker recovery requires its own execution lane');
+        // Pending selection still goes through choose(); only an explicit persisted
+        // Enno selection can recover Enno ownership instead of ordinary execution.
+        const executionMode = selection?.mode === 'enno' ? 'enno' : 'normal';
+        const owner = readExecutionOwner(database, event.sessionId);
+        if (owner && (owner.run_id !== runId || owner.workspace !== project.workspace || owner.mode !== executionMode))
+            throw new KiokukoError('CONFLICT', 'Task execution owner changed');
+        const orchestration = database.prepare('SELECT orchestration_session_id AS id FROM enno_contracts WHERE run_id=?')
+            .get(runId);
+        const snapshot = !orchestration ? undefined : readEnnoSnapshot(database, {
+            runId, workspace: project.workspace, orchestrationId: orchestration.id,
         });
+        if (executionMode === 'enno' && !snapshot)
+            throw new KiokukoError('CONFLICT', 'Persisted Enno selection has no matching execution contract');
         if (snapshot && !event.signal.aborted && supersedesUnstartedEnno(event, stateForSnapshot(snapshot))) {
             terminalizeLedgerRunInTransaction(database, runId, 'cancelled');
             return undefined;
@@ -725,11 +681,15 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         if (decision && (!decision.continue || decision.runId !== runId)) {
             throw new KiokukoError('CONFLICT', decision.warning ?? 'The active run cannot be resumed by this DSH session');
         }
-        const intakeLink = readRunIntakeLink(database, { workspace: project.workspace, runId });
-        const intake = readAkinatorSession(database, { workspace: project.workspace, sessionId: intakeLink.sessionId });
-        if (intake.status === 'active')
-            throw new KiokukoError('INTEGRITY_ERROR', 'Resumable Enno-Oduno run has unfinished intake');
         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,
+            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 })),
+        });
+        const intake = intakeState.session;
         const capabilityResolution = resolveCapabilities({
             task: intake.task,
             profile: intake.profile,
@@ -738,6 +698,20 @@ 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 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 });
+            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 });
+        }
         const prepared = {
             memoryOwner: createMemoryOwner(event.memoryOwner ?? memoryOwnerKind(event.requestIntent, intake.profile.taskType), {
                 agentId: event.agent.id, sessionId: event.sessionId, turn: event.turn,
@@ -751,27 +725,28 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                 pathPolicy: 'canonical_absolute_under_repository_root',
             },
             intake: {
-                status: intake.status,
+                status: intakeState.status,
                 sessionId: intake.id,
                 profile: intake.profile,
-                question: null,
-                missingFields: [],
+                question: intakeState.question,
+                missingFields: intakeState.missingFields,
                 recommendedTags: intakeLink.recommendedTags,
                 reasoning: deriveAkinatorReasoning(intake.task, intake.profile),
             },
             capabilities: capabilityResolution,
-            run: { runId, status: 'active' },
+            run: { runId, status: runStatus },
             skillDiscovery: { attempted: false, mode: 'off', requirements: [], queries: [], cacheHits: 0, candidates: 0, selected: [], failures: [] },
             context: null,
             memoryPolicy: { memoryReasoningRequired: false, contextWithheld: false, withheldReason: null, deliveryEmpty: true },
             warnings: capabilityResolution.warnings,
-            nextAction: 'proceed',
+            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(),
         };
         if (decision?.executionLease)
             turnState.stageLease(runId, decision.executionLease);
-        return { admitted: !event.signal.aborted, prepared, catalog: event.capabilities };
+        return { admitted, prepared, catalog: event.capabilities };
     });
     const requestIntentContextFor = async (input, sessionId, nativeSession, previous, task) => {
         const human = input.messages.filter(isHumanMessage);
@@ -782,6 +757,10 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         if (!cwd)
             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;
+        });
         let activeGoal;
         let proposals = [];
         const sameOwner = previous && previous.sessionId === sessionId && previous.nativeAgent === input.agent && previous.nativeSession === nativeSession;
@@ -794,7 +773,8 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         FROM ledger_runs AS lr
         LEFT JOIN dsh_coding_workflows AS cw ON cw.run_id = lr.run_id
         LEFT JOIN enno_contracts AS ec ON ec.run_id = lr.run_id
-        WHERE lr.workspace = ? AND lr.dsh_session_id = ? AND lr.status = 'active'
+        WHERE lr.workspace = ? AND COALESCE(lr.task_owner_session_id, lr.dsh_session_id) = ? AND lr.status = 'active'
+          AND lr.task_state NOT IN ('Done', 'Ignore')
           AND ((json_extract(cw.snapshot_json, '$.repositoryRoot') = ?
               AND json_extract(cw.snapshot_json, '$.sessionId') = ?
               AND json_extract(cw.snapshot_json, '$.state') NOT IN ('completed', 'cancelled', 'superseded'))
@@ -861,7 +841,8 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
                         digest: canonicalContentHash(text), text }];
             }
         }
-        return createRequestIntentContext({ task, messageRefs, ...(activeGoal ? { activeGoal } : {}), proposals: proposals.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;
@@ -922,7 +903,8 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
         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;
+            const establishedConversation = profile?.taskType === 'chat' && !requestIntentContext?.activeGoal
+                && (!requestIntentContext?.activeTask || requestIntentContext.activeTask.type === 'chat');
             if (requestIntentContext && !establishedConversation) {
                 requestIntent = await classifyRequestIntent(decisions, requestId, requestIntentContext, payload.signal);
             }
@@ -955,16 +937,33 @@ export function createAdmission({ native, skills, tools, userQuestions, sessions
             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 => {
+                if (requestIntentIsUnresolved(requestIntent))
+                    return recordTaskUnresolved(db, identity, {
+                        operationId: `intent:${canonicalContentHash([requestId, contextDigest, requestIntent?.unresolvedReason ?? 'request_intent_unresolved'])}`,
+                        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;
+            });
+        }
         const pendingDiscussion = isContinuationReference(intentTask)
             && await hasPendingExecutionDiscussion(sessionId, cwd);
-        const establishedConversation = profile?.taskType === 'chat' && !requestIntentContext?.activeGoal;
+        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?.proposals.length ?? 0) === 0;
+            && !requestIntentContext?.activeGoal && !requestIntentContext?.activeTask && (requestIntentContext?.proposals.length ?? 0) === 0;
         if (requestIntent?.source === 'unresolved' && legacyTaskType)
             requestIntent = undefined;
         if (requestIntent?.source !== 'unresolved') {