kiokuko-dsh 0.2.28 → 0.2.30

package/dist/dsh/on-demand-intake.js

@@ -1,9 +1,9 @@
 import { isCodingWorkflowStatus } from './coding-workflow/host.js';
 import { symbols } from '@deepseek-ai/cordis';
-import { requestInterpretationError, requestInterpretationRecovery } from './request-interpretation-guidance.js';
-import { collectClarificationContext, clarificationReply, reusableClarificationAnswer } from './clarification-context.js';
+import { requestInterpretationError, requestInterpretationRecovery, } from './request-interpretation-guidance.js';
+import { collectClarificationContext, clarificationReply, reusableClarificationAnswer, } from './clarification-context.js';
 import { abortable } from './boundary-worker.js';
-import { isLispImplementation, isLispNativeCommand, withRootLispAdmission, rememberLispConversation } from './lisp-tool-identity.js';
+import { isLispImplementation, isLispNativeCommand, withRootLispAdmission, rememberLispConversation, } from './lisp-tool-identity.js';
 import { ExecutionSelectionPending } from './execution-pending.js';
 import { executionClarification } from './intake-clarification.js';
 import { randomUUID } from 'node:crypto';
@@ -11,36 +11,56 @@ import { z } from 'zod';
 import { TASK_TYPES } from '../akinator/types.js';
 import { canonicalContentHash } from '../serialization/validate.js';
 import { KIOKUKO_DSH_SOURCE_KIND } from './plugin-source.js';
-import { taskAllowedOperations, taskCanExecute } from './task-state.js';
-import { createRequestIntentContext, unresolvedRequestIntent, validateMainModelRequestIntent, requestIntentReferenceIds, requestIntentRequiredReferenceIds, requestIntentIsUnresolved, requestIntentMessageRefs, requestIntentTaskType, RequestIntentSubmissionSchema } from './decisions/request-intent.js';
-import { memoryOwnerKind } from './memory-owner.js';
+import { taskAllowedOperations, taskCanExecute, } from './task-state.js';
+import { createRequestIntentContext, unresolvedRequestIntent, validateMainModelRequestIntent, requestIntentReferenceIds, requestIntentRequiredReferenceIds, requestIntentIsUnresolved, requestIntentMessageRefs, requestIntentTaskType, RequestIntentSubmissionSchema, } from './decisions/request-intent.js';
+import { memoryOwnerKind, } from './memory-owner.js';
 class RequestClarification extends Error {
     assessment;
-    constructor(message, assessment = false) {
+    interpretation;
+    candidate;
+    constructor(message, assessment = false, interpretation = false, candidate) {
         super(message);
         this.assessment = assessment;
+        this.interpretation = interpretation;
+        this.candidate = candidate;
     }
 }
 export const TASK_PREPARE_TOOL = 'prepare_requested_work';
 export const ON_DEMAND_GUIDANCE = 'The original user request may be answered now without selecting a task category. Ordinary native Bash needs no memory, Goal or prepare_requested_work round trip, including when optional workflow metadata exists; native permissions and human Stop remain authoritative. Registered root Lisp tools delegate to the Lisp runtime without an optional preparation round trip; foreground processes use native Bash permissions, sandbox, approval and Stop. Explicitly prepared or protected workflow effects retain their task, Plan and coding-choice checks. Owned or explicitly enrolled work retains its authority checks. Preserve the original utterance, every requested action, negation, quotation, target uncertainty, and current-session references; never replace it with a model rewrite. Use only the supplied active Goal and proposal references from this exact native session, never another chat. Classify relation as new, same_scope_continuation, scope_change, or unknown, and action as answer, research, verify, change, operate, or unknown; do not infer either from a fixed phrase or tool name. “Check how it behaves” is verification/research even when the next tool is Bash. This interpretation grants no native permission. When the decision provider is unavailable, abstains, or returns unknown, interpret the same context in the main model; ask the user only if the action or referenced target remains unclear, and preserve active work while waiting. Native read, glob, grep, web_search and web_fetch demands can gather evidence without preparation. Do not call prepare_requested_work merely to read a plan or inspect files. prepare_requested_work accepts either the legacy taskType alone or a requestIntent with exact evidenceRefs from the supplied context. taskOperation is optional and describes a transition of an existing activeTask, not starting the requested work itself. Omit taskOperation when activeTask is null or the request does not ask for a state transition; it never accepts a rewritten task or target and never changes native permissions. Installed Skill reads need no preparation and do not activate execution. Do not prepare work merely to load a skill. Plan, Goal, cancellation, memory-owner and execution ownership still apply. If only run_code is exposed, use the exact preparation-only carrier returned by this tool contract; the host intercepts it without evaluating code.';
-const ACTION_TYPES = TASK_TYPES.filter(type => type !== 'chat');
-const NO_ACTIVE_GOAL_GUIDANCE = 'The current context has no active Goal. same_scope_continuation may refer to the exact current-session conversation without a formal Goal; it grants no execution permission. scope_change requires an active Goal or task. If the original request clearly specifies a self-contained task, use relation=new and the action it requests (verify for verification), with the exact current evidenceRefs. Otherwise clarify the intended target with the user. Preserve the original scope, constraints and native permissions.';
-const preparationFieldsSchema = z.object({
+const ACTION_TYPES = TASK_TYPES.filter((type) => type !== 'chat');
+const NO_ACTIVE_GOAL_GUIDANCE = 'The current context has no active Goal. same_scope_continuation may refer to the exact current-session conversation without a formal Goal; it grants no execution permission. scope_change requires an active Goal, task, or an explicitly selected current-session proposal. A proposal is evidence, never approval by itself. If the original request clearly specifies a self-contained task, use relation=new and the action it requests (verify for verification), with the exact current evidenceRefs. Otherwise clarify the intended target with the user. Preserve the original scope, constraints and native permissions.';
+const preparationFieldsSchema = z
+    .object({
     taskType: z.enum(ACTION_TYPES).optional(),
     requestIntent: RequestIntentSubmissionSchema.optional(),
-}).strict();
+})
+    .strict();
 function parsePreparationRequest(value) {
     const parsed = preparationFieldsSchema.safeParse(value);
-    return parsed.success && (parsed.data.taskType !== undefined || parsed.data.requestIntent !== undefined) ? parsed.data : undefined;
+    return parsed.success &&
+        (parsed.data.taskType !== undefined ||
+            parsed.data.requestIntent !== undefined)
+        ? parsed.data
+        : undefined;
 }
 function humanMessages(messages) {
     return messages.filter((value) => value?.role === 'user' && (!value.source || value.source.kind === 'user'));
 }
 function humanTask(messages) {
-    return humanMessages(messages).flatMap(message => typeof message.content === 'string' ? [message.content]
-        : (message.content ?? []).filter((block) => block.type === 'text').map((block) => block.text)).join('\n').trim();
+    return humanMessages(messages)
+        .flatMap((message) => typeof message.content === 'string'
+        ? [message.content]
+        : (message.content ?? [])
+            .filter((block) => block.type === 'text')
+            .map((block) => block.text))
+        .join('\n')
+        .trim();
+}
+function humanId(message) {
+    return typeof message.id === 'string'
+        ? message.id
+        : canonicalContentHash(message);
 }
-function humanId(message) { return typeof message.id === 'string' ? message.id : canonicalContentHash(message); }
 function eventTurn(event) {
     const data = event?.data;
     return Number.isSafeInteger(data?.turn) ? data.turn : undefined;
@@ -50,7 +70,9 @@ function automaticPreparationType(intent, requestIntent, name) {
     if (requestIntent !== undefined && requestIntentIsUnresolved(requestIntent)) {
         // Gathering evidence grants no change/process authority. An active Goal
         // still requires its reference to be resolved before opening another run.
-        return ['read', 'glob', 'grep', 'web_search', 'web_fetch'].includes(name) ? 'research' : undefined;
+        return ['read', 'glob', 'grep', 'web_search', 'web_fetch'].includes(name)
+            ? 'research'
+            : undefined;
     }
     if (requestIntent?.action === 'answer')
         return undefined;
@@ -59,18 +81,39 @@ function automaticPreparationType(intent, requestIntent, name) {
         return interpreted;
     if (intent.taskType && intent.taskType !== 'chat')
         return intent.taskType;
-    return ['read', 'glob', 'grep', 'web_search', 'web_fetch'].includes(name) ? 'research' : undefined;
+    return ['read', 'glob', 'grep', 'web_search', 'web_fetch'].includes(name)
+        ? 'research'
+        : undefined;
+}
+const NATIVE_EVIDENCE_READS = new Set([
+    'read',
+    'glob',
+    'grep',
+    'web_search',
+    'web_fetch',
+]);
+const UNOWNED_NATIVE_TOOLS = new Set([
+    'bash',
+    'read',
+    'glob',
+    'grep',
+    'web_search',
+    'web_fetch',
+    'skill',
+]);
+function denied(reason) {
+    return { kind: 'deny', reason };
 }
-const NATIVE_EVIDENCE_READS = new Set(['read', 'glob', 'grep', 'web_search', 'web_fetch']);
-const UNOWNED_NATIVE_TOOLS = new Set(['bash', 'read', 'glob', 'grep', 'web_search', 'web_fetch', 'skill']);
-function denied(reason) { return { kind: 'deny', reason }; }
 /** A protocol carrier, not JavaScript evaluation. Only this exact JSON-literal call is recognized. */
 export function preparationCarrier(value) {
     if (!value || typeof value !== 'object' || Array.isArray(value))
         return undefined;
     const args = value;
-    if (Object.keys(args).sort().join(',') !== 'code,description' || typeof args.description !== 'string' || !args.description.trim()
-        || typeof args.code !== 'string' || args.code.length > 8192)
+    if (Object.keys(args).sort().join(',') !== 'code,description' ||
+        typeof args.description !== 'string' ||
+        !args.description.trim() ||
+        typeof args.code !== 'string' ||
+        args.code.length > 8192)
         return undefined;
     const code = args.code.trim().replace(/;$/u, '');
     const prefix = 'return await tools.prepare_requested_work(';
@@ -93,9 +136,17 @@ export class OnDemandIntake {
     options;
     async diagnose(state, observation) {
         try {
-            await this.host.diagnostic?.(state.input, { ...observation, ...(state.requestIntentContext ? { context: state.requestIntentContext } : {}), ...(state.requestIntent ? { decision: state.requestIntent } : {}) });
+            await this.host.diagnostic?.(state.input, {
+                ...observation,
+                ...(state.requestIntentContext
+                    ? { context: state.requestIntentContext }
+                    : {}),
+                ...(state.requestIntent ? { decision: state.requestIntent } : {}),
+            });
+        }
+        catch {
+            /* Diagnostic loss cannot authorize or veto work. */
         }
-        catch { /* Diagnostic loss cannot authorize or veto work. */ }
     }
     #turns = new Map();
     #clarificationContexts = new WeakMap();
@@ -111,6 +162,7 @@ export class OnDemandIntake {
     #startupSkillReader;
     #startupQuestionTool;
     #questionTools = new WeakMap();
+    #planTools = new WeakMap();
     #skillReaders = new WeakMap();
     #stopped = false;
     constructor(host, options = {}) {
@@ -120,35 +172,63 @@ export class OnDemandIntake {
     /** Exact host-owned implementations, never a name-only execution bypass. */
     registerControlTool(definition) {
         this.#controlTools.set(definition.name, definition.execute);
-        return () => { if (this.#controlTools.get(definition.name) === definition.execute)
-            this.#controlTools.delete(definition.name); };
+        return () => {
+            if (this.#controlTools.get(definition.name) === definition.execute)
+                this.#controlTools.delete(definition.name);
+        };
     }
     isControl(execution) {
         const proof = this.#controlExecutions.get(execution);
-        return !this.#stopped && !execution.signal.aborted && !!proof
-            && (!proof.turn || this.bound(execution) === proof.turn && !proof.turn.input.signal.aborted && !['closed', 'stale'].includes(proof.turn.status))
-            && this.definition(execution)?.execute === proof.execute && canonicalContentHash(execution.arguments) === proof.digest
-            && (proof.invoke ? [...this.#controlTools].some(([name, invoke]) => invoke === proof.invoke
-                && this.#tools?.get(name, execution.agent)?.execute === invoke) : this.#controlTools.get(execution.name) === proof.execute || this.conversationControl(execution, this.definition(execution)));
+        return (!this.#stopped &&
+            !execution.signal.aborted &&
+            !!proof &&
+            (!proof.turn ||
+                (this.bound(execution) === proof.turn &&
+                    !proof.turn.input.signal.aborted &&
+                    !['closed', 'stale'].includes(proof.turn.status))) &&
+            this.definition(execution)?.execute === proof.execute &&
+            canonicalContentHash(execution.arguments) === proof.digest &&
+            (proof.invoke
+                ? [...this.#controlTools].some(([name, invoke]) => invoke === proof.invoke &&
+                    this.#tools?.get(name, execution.agent)?.execute === invoke)
+                : this.#controlTools.get(execution.name) === proof.execute ||
+                    this.conversationControl(execution, this.definition(execution))));
     }
     controlTask(execution) {
-        return this.isControl(execution) ? this.#controlExecutions.get(execution)?.turn?.task : undefined;
+        return this.isControl(execution)
+            ? this.#controlExecutions.get(execution)?.turn?.task
+            : undefined;
     }
     /** Observational/conversational calls still traverse native policy; never grant effect authority. */
     conversationControl(execution, actual) {
         const state = this.bound(execution);
-        return !!state && state.status === 'answer' && execution.parent === undefined
-            && (execution.name === 'ask_user_question' && actual.execute === this.#questionTools.get(state.input.agent)
-                || isCodingWorkflowStatus(actual, execution.arguments));
+        return (!!state &&
+            state.status === 'answer' &&
+            execution.parent === undefined &&
+            ((execution.name === 'ask_user_question' &&
+                actual.execute === this.#questionTools.get(state.input.agent)) ||
+                (execution.name === 'exit_plan_mode' &&
+                    actual.execute === this.#planTools.get(state.input.agent)) ||
+                isCodingWorkflowStatus(actual, execution.arguments)));
     }
     controlCall(execution, actual) {
-        if (this.#controlTools.get(execution.name) === actual.execute || this.conversationControl(execution, actual))
-            return { execute: actual.execute, digest: canonicalContentHash(execution.arguments) };
-        if (execution.name !== 'run_code' || !execution.arguments || typeof execution.arguments !== 'object' || Array.isArray(execution.arguments))
+        if (this.#controlTools.get(execution.name) === actual.execute ||
+            this.conversationControl(execution, actual))
+            return {
+                execute: actual.execute,
+                digest: canonicalContentHash(execution.arguments),
+            };
+        if (execution.name !== 'run_code' ||
+            !execution.arguments ||
+            typeof execution.arguments !== 'object' ||
+            Array.isArray(execution.arguments))
             return undefined;
         const value = execution.arguments;
-        if (Object.keys(value).sort().join(',') !== 'code,description' || typeof value.code !== 'string' || value.code.length > 8192
-            || typeof value.description !== 'string' || !value.description.trim())
+        if (Object.keys(value).sort().join(',') !== 'code,description' ||
+            typeof value.code !== 'string' ||
+            value.code.length > 8192 ||
+            typeof value.description !== 'string' ||
+            !value.description.trim())
             return undefined;
         const code = value.code.trim().replace(/;$/u, '');
         for (const [name, invoke] of this.#controlTools) {
@@ -160,9 +240,16 @@ export class OnDemandIntake {
             try {
                 const args = JSON.parse(code.slice(prefix.length, -1));
                 if (code === prefix + JSON.stringify(args) + ')')
-                    return { execute: actual.execute, digest: canonicalContentHash(execution.arguments), invoke, args };
+                    return {
+                        execute: actual.execute,
+                        digest: canonicalContentHash(execution.arguments),
+                        invoke,
+                        args,
+                    };
+            }
+            catch {
+                /* Nonliteral programs keep ordinary execution admission. */
             }
-            catch { /* Nonliteral programs keep ordinary execution admission. */ }
         }
         return undefined;
     }
@@ -172,7 +259,10 @@ export class OnDemandIntake {
         return promise;
     }
     existingTurn(execution) {
-        const last = execution.agent?.session?.snapshotEvents?.().filter(event => event.type === 'turn/start' || event.type === 'turn/end').at(-1);
+        const last = execution.agent?.session
+            ?.snapshotEvents?.()
+            .filter((event) => event.type === 'turn/start' || event.type === 'turn/end')
+            .at(-1);
         return last?.type === 'turn/start' ? eventTurn(last) : undefined;
     }
     acknowledgeExisting(state) {
@@ -182,42 +272,57 @@ export class OnDemandIntake {
         const taskType = requestIntentTaskType(state.requestIntent, state.intent.taskType);
         if (taskType !== undefined)
             state.taskType = taskType;
-        state.preparedIntentDigest = canonicalContentHash({ taskType: state.taskType ?? null, requestIntent: state.requestIntent ?? null });
+        state.preparedIntentDigest = canonicalContentHash({
+            taskType: state.taskType ?? null,
+            requestIntent: state.requestIntent ?? null,
+        });
     }
     /** True means ordinary text may continue; false leaves an existing execution on its original path. */
     async capture(input) {
         input.signal.throwIfAborted();
         if (!this.#stopped && this.host.nativeChild?.(input.agent))
             return false;
-        if (this.#stopped || !input.agent.session || !Number.isSafeInteger(input.turn) || input.turn < 1)
+        if (this.#stopped ||
+            !input.agent.session ||
+            !Number.isSafeInteger(input.turn) ||
+            input.turn < 1)
             throw new Error('Invalid on-demand intake identity');
-        input = { ...input, signal: AbortSignal.any([input.signal, this.#lifecycle.signal]) };
+        input = {
+            ...input,
+            signal: AbortSignal.any([input.signal, this.#lifecycle.signal]),
+        };
         const sessionId = input.agent.session.id;
         const previous = this.#turns.get(sessionId);
         if (previous) {
-            if (previous.input.agent !== input.agent || previous.input.agent.session !== input.agent.session || input.turn < previous.input.turn)
+            if (previous.input.agent !== input.agent ||
+                previous.input.agent.session !== input.agent.session ||
+                input.turn < previous.input.turn)
                 throw new Error('Stale on-demand intake identity');
             if (previous.input.turn === input.turn) {
                 if (previous.status === 'closed')
                     throw new Error('On-demand turn is closed');
-                const fresh = humanMessages(input.messages).filter(message => previous.humanContents.get(humanId(message)) !== canonicalContentHash(message));
+                const fresh = humanMessages(input.messages).filter((message) => previous.humanContents.get(humanId(message)) !==
+                    canonicalContentHash(message));
                 if (!fresh.length) {
-                    if (previous.capture && !await previous.capture)
+                    if (previous.capture && !(await previous.capture))
                         return false;
                     if (previous.status === 'stale')
-                        throw previous.captureError ?? new Error('Previous on-demand request is stale');
+                        throw (previous.captureError ??
+                            new Error('Previous on-demand request is stale'));
                     return previous.status !== 'prepared';
                 }
                 previous.status = 'stale';
                 previous.controller.abort(new Error('Human instructions changed'));
                 // A new native batch can contain only the steering message. Preserve
                 // the original request while replacing changed messages by identity.
-                const merged = new Map(previous.input.messages.map(message => [humanId(message), message]));
+                const merged = new Map(previous.input.messages.map((message) => [humanId(message), message]));
                 for (const message of input.messages)
                     merged.set(humanId(message), message);
                 input = { ...input, messages: [...merged.values()] };
             }
-            if (previous.input.turn !== input.turn && !humanMessages(input.messages).length && this.host.ready(input.agent)) {
+            if (previous.input.turn !== input.turn &&
+                !humanMessages(input.messages).length &&
+                this.host.ready(input.agent)) {
                 // A host-driven next turn may carry no new human message. Leave its
                 // active execution bound to the host instead of creating an empty intake.
                 if (previous.status === 'closed') {
@@ -229,11 +334,13 @@ export class OnDemandIntake {
                     return false;
                 }
             }
-            if (previous.input.turn !== input.turn && !['closed', 'prepared'].includes(previous.status))
+            if (previous.input.turn !== input.turn &&
+                !['closed', 'prepared'].includes(previous.status))
                 throw new Error('Previous on-demand turn has not ended');
             previous.controller.abort(new Error('A newer native turn superseded this request'));
         }
-        else if (!humanMessages(input.messages).length && this.host.ready(input.agent)) {
+        else if (!humanMessages(input.messages).length &&
+            this.host.ready(input.agent)) {
             await this.host.validate(input);
             input.signal.throwIfAborted();
             await this.host.advance?.(input);
@@ -242,28 +349,56 @@ export class OnDemandIntake {
         this.host.answerContext?.retire(input.agent);
         // Install the pending state synchronously, before any host or classifier awaits.
         const controller = new AbortController();
-        const state = { input: { ...input, signal: AbortSignal.any([input.signal, controller.signal]), messages: Object.freeze(structuredClone([...input.messages])) }, task: humanTask(input.messages),
-            humanContents: new Map(humanMessages(input.messages).map(message => [humanId(message), canonicalContentHash(message)])),
-            status: 'capturing', intent: { deferInference: true }, memoryOwner: 'none', preparationCalls: new Set(), controller };
+        const state = {
+            input: {
+                ...input,
+                signal: AbortSignal.any([input.signal, controller.signal]),
+                messages: Object.freeze(structuredClone([...input.messages])),
+            },
+            task: humanTask(input.messages),
+            humanContents: new Map(humanMessages(input.messages).map((message) => [
+                humanId(message),
+                canonicalContentHash(message),
+            ])),
+            status: 'capturing',
+            intent: { deferInference: true },
+            memoryOwner: 'none',
+            preparationCalls: new Set(),
+            controller,
+        };
         this.#turns.set(sessionId, state);
-        rememberLispConversation(input.agent, () => !this.options.onlyWhenDeferred && !this.#stopped && this.#turns.get(sessionId) === state
-            && state.status === 'answer' && !state.input.signal.aborted && this.host.nativeChild?.(input.agent) !== true);
+        rememberLispConversation(input.agent, () => !this.options.onlyWhenDeferred &&
+            !this.#stopped &&
+            this.#turns.get(sessionId) === state &&
+            state.status === 'answer' &&
+            !state.input.signal.aborted &&
+            this.host.nativeChild?.(input.agent) !== true);
         const promise = (async () => {
             await this.host.validate(input);
             this.assertCurrent(state);
             // Presets and later host plugins register readers after mount. Pin the
             // validated owner's first reader once, including absence; never rebind it.
             if (!this.#skillReaders.has(input.agent))
-                this.#skillReaders.set(input.agent, this.#startupSkillReader ?? this.#tools?.get('skill', input.agent)?.execute);
+                this.#skillReaders.set(input.agent, this.#startupSkillReader ??
+                    this.#tools?.get('skill', input.agent)?.execute);
             if (!this.#questionTools.has(input.agent))
-                this.#questionTools.set(input.agent, this.#startupQuestionTool ?? this.#tools?.get('ask_user_question', input.agent)?.execute);
+                this.#questionTools.set(input.agent, this.#startupQuestionTool ??
+                    this.#tools?.get('ask_user_question', input.agent)?.execute);
+            if (!this.#planTools.has(input.agent))
+                this.#planTools.set(input.agent, this.#tools?.get('exit_plan_mode', input.agent)?.execute);
             if (!humanMessages(input.messages).length)
                 throw new Error('Original human input is required before on-demand intake');
             // Native authority is independent of optional memory, Skills and model
             // classification. Never manufacture an owned task merely to run Bash.
-            if (!this.options.onlyWhenDeferred && await this.host.nativeOwnership?.(state.input) === 'unowned') {
+            if (!this.options.onlyWhenDeferred &&
+                (await this.host.nativeOwnership?.(state.input)) === 'unowned') {
+                this.assertCurrent(state);
+                const context = (await this.host.requestContext?.(state.input, state.task)) ??
+                    createRequestIntentContext({
+                        task: state.task,
+                        messageRefs: requestIntentMessageRefs(state.input.messages, state.task),
+                    });
                 this.assertCurrent(state);
-                const context = createRequestIntentContext({ task: state.task, messageRefs: requestIntentMessageRefs(state.input.messages, state.task) });
                 await this.host.prepareNativeCoding?.(state.input, state.task, context);
                 this.assertCurrent(state);
                 state.nativeUnowned = true;
@@ -298,8 +433,10 @@ export class OnDemandIntake {
             const pendingClarification = this.#clarifications.get(sessionId);
             await this.diagnose(state, { kind: 'interpretation' });
             await this.diagnose(state, { kind: 'resume' });
-            if (pendingClarification?.agent === input.agent && state.requestIntent && !requestIntentIsUnresolved(state.requestIntent)
-                && !executionClarification(state.task, state.requestIntent, state.requestIntentContext))
+            if (pendingClarification?.agent === input.agent &&
+                state.requestIntent &&
+                !requestIntentIsUnresolved(state.requestIntent) &&
+                !executionClarification(state.task, state.requestIntent, state.requestIntentContext))
                 this.#clarifications.delete(sessionId);
             state.memoryOwner = memoryOwnerKind(state.requestIntent, state.intent.taskType);
             this.assertCurrent(state);
@@ -307,10 +444,16 @@ export class OnDemandIntake {
                 await this.host.advance?.(input, state.requestIntent);
             this.assertCurrent(state);
             const resumeConfirmation = previous?.input.turn !== input.turn && state.task
-                ? await this.host.resumeConfirmation?.(input) ?? false : false;
-            if (process.env.KIOKUKO_INTENT_DEBUG === '1' && previous?.input.turn !== input.turn) {
-                console.error('on-demand confirmation route', { turn: input.turn, previousTurn: previous?.input.turn,
-                    hasTask: state.task.length > 0, resumeConfirmation });
+                ? ((await this.host.resumeConfirmation?.(input)) ?? false)
+                : false;
+            if (process.env.KIOKUKO_INTENT_DEBUG === '1' &&
+                previous?.input.turn !== input.turn) {
+                console.error('on-demand confirmation route', {
+                    turn: input.turn,
+                    previousTurn: previous?.input.turn,
+                    hasTask: state.task.length > 0,
+                    resumeConfirmation,
+                });
             }
             if (resumeConfirmation) {
                 this.assertCurrent(state);
@@ -321,19 +464,27 @@ export class OnDemandIntake {
                 this.host.answerContext?.retire(input.agent);
                 return false;
             }
-            if (process.env.KIOKUKO_INTENT_DEBUG === '1' && previous?.input.turn !== input.turn && state.task && this.host.resumeConfirmation) {
+            if (process.env.KIOKUKO_INTENT_DEBUG === '1' &&
+                previous?.input.turn !== input.turn &&
+                state.task &&
+                this.host.resumeConfirmation) {
                 console.error('confirmation resume not selected', input.turn, state.task.length);
             }
-            if (state.task && await this.host.replay?.(state.input)) {
+            if (state.task && (await this.host.replay?.(state.input))) {
                 this.acknowledgeExisting(state);
                 return false;
             }
             const assessmentConsistent = state.requestIntent && state.requestIntent.action !== 'answer'
-                ? await this.assess(state, state.requestIntent) : true;
-            const canContinue = assessmentConsistent && state.requestIntent?.relation === 'same_scope_continuation'
-                && !requestIntentIsUnresolved(state.requestIntent) && state.requestIntent.action !== 'answer';
-            if (previous?.input.turn !== input.turn && state.task && canContinue
-                && await this.host.existing(input, state.requestIntent)) {
+                ? await this.assess(state, state.requestIntent)
+                : true;
+            const canContinue = assessmentConsistent &&
+                state.requestIntent?.relation === 'same_scope_continuation' &&
+                !requestIntentIsUnresolved(state.requestIntent) &&
+                state.requestIntent.action !== 'answer';
+            if (previous?.input.turn !== input.turn &&
+                state.task &&
+                canContinue &&
+                (await this.host.existing(input, state.requestIntent))) {
                 // Persisted ownership is only an acknowledgement when this exact native
                 // agent/session/turn is already bound. A cold resume stays conversational
                 // until explicit preparation reconstructs that binding.
@@ -344,16 +495,25 @@ export class OnDemandIntake {
             }
             // Eager mode still binds known work before generation. Classifier uncertainty
             // instead reaches ordinary reasoning, with no execution grant or purpose UI.
-            const requestIntentUnresolved = state.requestIntent !== undefined
-                && requestIntentIsUnresolved(state.requestIntent);
+            const requestIntentUnresolved = state.requestIntent !== undefined &&
+                requestIntentIsUnresolved(state.requestIntent);
             const requestAsAnswer = state.requestIntent?.action === 'answer';
             const knownIntent = this.host.interpret === undefined
-                ? !state.intent.deferInference && state.intent.taskType !== undefined && state.intent.taskType !== 'chat'
-                : state.requestIntent !== undefined && !requestIntentUnresolved && !requestAsAnswer
-                    && state.requestIntent.relation !== 'unknown' && state.requestIntent.action !== 'unknown';
-            const missingExecutionDetail = executionClarification(state.task, state.requestIntent, state.requestIntentContext)
-                || state.requestIntentContext?.activeTask && !taskCanExecute(state.requestIntentContext.activeTask);
-            if (this.options.onlyWhenDeferred && knownIntent && !missingExecutionDetail && assessmentConsistent) {
+                ? !state.intent.deferInference &&
+                    state.intent.taskType !== undefined &&
+                    state.intent.taskType !== 'chat'
+                : state.requestIntent !== undefined &&
+                    !requestIntentUnresolved &&
+                    !requestAsAnswer &&
+                    state.requestIntent.relation !== 'unknown' &&
+                    state.requestIntent.action !== 'unknown';
+            const missingExecutionDetail = executionClarification(state.task, state.requestIntent, state.requestIntentContext) ||
+                (state.requestIntentContext?.activeTask &&
+                    !taskCanExecute(state.requestIntentContext.activeTask));
+            if (this.options.onlyWhenDeferred &&
+                knownIntent &&
+                !missingExecutionDetail &&
+                assessmentConsistent) {
                 this.#turns.delete(sessionId);
                 state.status = 'closed';
                 controller.abort(new Error('Known intent continues through eager admission'));
@@ -391,16 +551,22 @@ export class OnDemandIntake {
     }
     assertCurrent(state) {
         state.input.signal.throwIfAborted();
-        if (this.#stopped || this.#turns.get(state.input.agent.session.id) !== state || ['closed', 'stale'].includes(state.status))
+        if (this.#stopped ||
+            this.#turns.get(state.input.agent.session.id) !== state ||
+            ['closed', 'stale'].includes(state.status))
             throw new Error('On-demand request changed or closed');
     }
     bound(execution) {
         const agent = execution.agent, state = agent?.session && this.#turns.get(agent.session.id);
-        if (!state || state.input.agent !== agent || state.input.agent.session !== agent.session)
+        if (!state ||
+            state.input.agent !== agent ||
+            state.input.agent.session !== agent.session)
             return undefined;
         if (state.existing && this.existingTurn(execution) !== state.input.turn)
             return undefined;
-        const starts = agent.session.snapshotEvents?.().filter(event => event.type === 'turn/start');
+        const starts = agent.session
+            .snapshotEvents?.()
+            .filter((event) => event.type === 'turn/start');
         const latest = eventTurn(starts?.at(-1));
         if (latest !== undefined && latest !== state.input.turn)
             return undefined;
@@ -408,8 +574,12 @@ export class OnDemandIntake {
     }
     ownerIdentity(state) {
         const session = state.input.agent.session;
-        return { agentId: state.input.agent.id, sessionId: session.id, turn: state.input.turn,
-            requestDigest: canonicalContentHash(state.task) };
+        return {
+            agentId: state.input.agent.id,
+            sessionId: session.id,
+            turn: state.input.turn,
+            requestDigest: canonicalContentHash(state.task),
+        };
     }
     definition(execution) {
         try {
@@ -417,8 +587,11 @@ export class OnDemandIntake {
             if (registered)
                 return registered;
             const transport = this.#executorTransports.get(execution);
-            return transport && transport.current() === transport.runtime && transport.runtime.run === transport.definition.execute
-                ? transport.definition : undefined;
+            return transport &&
+                transport.current() === transport.runtime &&
+                transport.runtime.run === transport.definition.execute
+                ? transport.definition
+                : undefined;
         }
         catch {
             return undefined;
@@ -428,31 +601,51 @@ export class OnDemandIntake {
      * The runtime function is an identity check; dispatch still belongs to DSH.
      * A native or missing executor cannot obtain a preparation-only carrier here. */
     async bindExecutorTransport(execution, context) {
-        if (execution.name !== 'run_code' || execution.parent !== undefined || typeof execution.token !== 'symbol'
-            || typeof this.#tools?.setExecutor !== 'function' || !context.get)
+        if (execution.name !== 'run_code' ||
+            execution.parent !== undefined ||
+            typeof execution.token !== 'symbol' ||
+            typeof this.#tools?.setExecutor !== 'function' ||
+            !context.get)
             return;
         // Cordis returns fresh contextual proxies; compare the underlying service,
         // never invoke it outside the selected executor's dispatch.
         const owner = execution.agent?.ctx;
         const services = typeof owner?.get === 'function' ? owner : context;
-        const current = () => { const value = services.get('ptcRuntime', false); return value?.[symbols.original] ?? value; };
+        const current = () => {
+            const value = services.get('ptcRuntime', false);
+            return value?.[symbols.original] ?? value;
+        };
         const runtime = current(), prompt = services.get('systemPrompt', false);
-        if (typeof runtime?.run !== 'function' || typeof prompt?.assemble !== 'function')
+        if (typeof runtime?.run !== 'function' ||
+            typeof prompt?.assemble !== 'function')
             return;
-        const projected = await prompt.assemble({ scope: execution.agent, agent: execution.agent });
+        const projected = await prompt.assemble({
+            scope: execution.agent,
+            agent: execution.agent,
+        });
         execution.signal.throwIfAborted();
-        if (current() !== runtime || projected.tools.length !== 1 || projected.tools[0]?.name !== 'run_code'
-            || !projected.sections.some((section) => section.name === 'tools:sdk'))
+        if (current() !== runtime ||
+            projected.tools.length !== 1 ||
+            projected.tools[0]?.name !== 'run_code' ||
+            !projected.sections.some((section) => section.name === 'tools:sdk'))
             return;
-        this.#executorTransports.set(execution, { definition: { name: 'run_code', execute: runtime.run }, runtime, current });
+        this.#executorTransports.set(execution, {
+            definition: { name: 'run_code', execute: runtime.run },
+            runtime,
+            current,
+        });
     }
     async assess(state, decision) {
-        if (!this.host.assess || decision?.action === 'answer' || decision?.action === 'research' || requestIntentIsUnresolved(decision))
+        if (!this.host.assess ||
+            decision?.action === 'answer' ||
+            decision?.action === 'research' ||
+            requestIntentIsUnresolved(decision))
             return true;
         if (!decision || !state.requestIntentContext)
             throw new RequestClarification('The source or candidate is unresolved', true);
         const context = state.requestIntentContext, digest = canonicalContentHash([context, decision]);
-        if (state.assessment?.digest !== digest) {
+        if (state.assessment?.digest !== digest ||
+            state.assessment.result.outcome === 'unavailable') {
             const result = await this.host.assess(state.input, context, decision);
             this.assertCurrent(state);
             if (!result) {
@@ -473,19 +666,33 @@ export class OnDemandIntake {
             throw new ExecutionSelectionPending();
         const resolved = requestIntent ?? state.requestIntent;
         try {
-            await this.host.diagnostic?.(state.input, { kind: 'interpretation', ...(state.requestIntentContext ? { context: state.requestIntentContext } : {}), ...(resolved ? { decision: resolved } : {}) });
+            await this.host.diagnostic?.(state.input, {
+                kind: 'interpretation',
+                ...(state.requestIntentContext
+                    ? { context: state.requestIntentContext }
+                    : {}),
+                ...(resolved ? { decision: resolved } : {}),
+            });
+        }
+        catch {
+            /* Advisory only. */
         }
-        catch { /* Advisory only. */ }
         if (resolved?.action === 'change' && resolved.changeScope === 'unknown') {
             throw new RequestClarification('The requested change scope is unresolved. Specify implementation or document using the current request evidence before preparing work.');
         }
-        if (resolved && requestIntentIsUnresolved(resolved) && (state.requestIntentContext?.activeGoal || state.requestIntentContext?.activeTask)) {
+        if (resolved &&
+            requestIntentIsUnresolved(resolved) &&
+            (state.requestIntentContext?.activeGoal ||
+                state.requestIntentContext?.activeTask)) {
             throw new RequestClarification('Clarify the request before preparing work');
         }
-        if (!await this.assess(state, resolved))
-            throw new RequestClarification('Independent source comparison or finite-domain verification requires clarification', true);
+        if (!(await this.assess(state, resolved)))
+            throw new RequestClarification('Independent source comparison or finite-domain verification requires clarification', true, false, resolved);
         const activeTask = state.requestIntentContext?.activeTask;
-        if (activeTask && resolved?.relation === 'same_scope_continuation' && !taskCanExecute(activeTask) && !resolved.taskOperation) {
+        if (activeTask &&
+            resolved?.relation === 'same_scope_continuation' &&
+            !taskCanExecute(activeTask) &&
+            !resolved.taskOperation) {
             throw new RequestClarification('The current task requires an explicit user-selected state operation before execution.');
         }
         const clarification = executionClarification(state.task, resolved, state.requestIntentContext);
@@ -493,13 +700,21 @@ export class OnDemandIntake {
             throw new RequestClarification(clarification);
         if (!ACTION_TYPES.includes(taskType))
             throw new Error('Answer conversational questions directly; prepare_requested_work is for requested work');
-        if (state.status === 'prepared' && state.confirmationResume && explicitIntent
-            && (state.requestIntent?.relation === 'unknown' || state.requestIntent?.action === 'unknown'))
+        if (state.status === 'prepared' &&
+            state.confirmationResume &&
+            explicitIntent &&
+            (state.requestIntent?.relation === 'unknown' ||
+                state.requestIntent?.action === 'unknown'))
             state.status = 'answer';
         if (state.status === 'prepared') {
             if (state.taskType !== taskType)
                 throw requestInterpretationError('Prepared intent cannot be replaced within a turn', state.requestIntent, state.requestIntentContext, true);
-            if (explicitIntent && state.preparedIntentDigest !== canonicalContentHash({ taskType, requestIntent: requestIntent ?? null })) {
+            if (explicitIntent &&
+                state.preparedIntentDigest !==
+                    canonicalContentHash({
+                        taskType,
+                        requestIntent: requestIntent ?? null,
+                    })) {
                 throw requestInterpretationError('Prepared interpretation cannot be replaced within a turn', state.requestIntent, state.requestIntentContext, true);
             }
             return;
@@ -514,7 +729,10 @@ export class OnDemandIntake {
         state.taskType = taskType;
         const operation = (async () => {
             // Retain exact original messages. The only caller-supplied input is an advisory task type.
-            const admitted = await this.host.prepare({ ...state.input, signal: AbortSignal.any([state.input.signal, signal]) }, taskType, requestIntent ?? state.requestIntent, state.requestIntentContext);
+            const admitted = await this.host.prepare({
+                ...state.input,
+                signal: AbortSignal.any([state.input.signal, signal]),
+            }, taskType, requestIntent ?? state.requestIntent, state.requestIntentContext);
             this.assertCurrent(state);
             signal.throwIfAborted();
             if (!admitted || !this.host.ready(state.input.agent, state.input.turn))
@@ -522,8 +740,12 @@ export class OnDemandIntake {
             const preparedIntent = requestIntent ?? state.requestIntent;
             if (preparedIntent !== undefined)
                 state.requestIntent = preparedIntent;
-            state.preparedIntentDigest = canonicalContentHash({ taskType, requestIntent: state.requestIntent ?? null });
+            state.preparedIntentDigest = canonicalContentHash({
+                taskType,
+                requestIntent: state.requestIntent ?? null,
+            });
             state.status = 'prepared';
+            this.#clarifications.delete(state.input.agent.session.id);
             delete state.confirmationResume;
         })();
         this.watch(operation);
@@ -535,11 +757,17 @@ export class OnDemandIntake {
             if (!['closed', 'stale'].includes(state.status)) {
                 // A declined selection preserves this request for a conversational acknowledgement.
                 // It is not admission: preparation remains consumed and tools still need a ready host.
-                state.selectionPending = error instanceof ExecutionSelectionPending && !state.input.signal.aborted && !signal.aborted;
+                state.selectionPending =
+                    error instanceof ExecutionSelectionPending &&
+                        !state.input.signal.aborted &&
+                        !signal.aborted;
                 // Preparation failure is not a change of human authority. Keep the
                 // captured request retryable, but never revive Stop/cancellation. A
                 // new call must pass host admission and native permission checks again.
-                state.status = state.input.signal.aborted || signal.aborted || this.#stopped ? 'stale' : 'answer';
+                state.status =
+                    state.input.signal.aborted || signal.aborted || this.#stopped
+                        ? 'stale'
+                        : 'answer';
                 delete state.preparedIntentDigest;
                 delete state.taskType;
                 state.memoryOwner = 'none';
@@ -555,9 +783,14 @@ export class OnDemandIntake {
         const pending = agent.session && this.#clarifications.get(agent.session.id);
         if (this.#stopped || pending?.agent !== agent)
             return false;
-        const boundary = agent.session?.snapshotEvents?.().filter(event => event.type === 'turn/end').at(-1);
+        const boundary = agent.session
+            ?.snapshotEvents?.()
+            .filter((event) => event.type === 'turn/end')
+            .at(-1);
         const data = boundary?.data;
-        if (data?.turn !== undefined && data.turn >= pending.turn && ['aborted', 'error', 'max-tokens', 'blocked'].includes(data.reason?.kind ?? '')) {
+        if (data?.turn !== undefined &&
+            data.turn >= pending.turn &&
+            ['aborted', 'error', 'max-tokens', 'blocked'].includes(data.reason?.kind ?? '')) {
             this.#clarifications.delete(agent.session.id);
             return false;
         }
@@ -565,67 +798,231 @@ export class OnDemandIntake {
     }
     async clarify(state, executionSignal, reason) {
         this.assertCurrent(state);
-        const signal = AbortSignal.any([executionSignal, state.input.signal, state.controller.signal]);
+        const signal = AbortSignal.any([
+            executionSignal,
+            state.input.signal,
+            state.controller.signal,
+        ]);
         const context = state.requestIntentContext;
         const sessionId = state.input.agent.session.id;
-        if (reason.assessment && state.assessment?.result.outcome === 'unavailable') {
+        if (reason.interpretation)
+            return {
+                prepared: false,
+                status: 'request_interpretation_required',
+                originalTask: state.task,
+                requestInterpretation: requestInterpretationRecovery(reason.candidate ?? state.requestIntent, context),
+                currentReferences: context
+                    ? requestIntentRequiredReferenceIds(context)
+                    : [],
+                permissions: 'unchanged_native_policy',
+                nextAction: 'submit_current_request_intent',
+                detail: 'Interpret the captured user request and current host references in the main model. A taskType label alone is not an action or approval. Ask the human only if the action or referenced target is actually unclear.',
+            };
+        if (reason.assessment &&
+            state.assessment?.result.outcome === 'unavailable') {
             const a = state.assessment.result;
-            return { prepared: false, status: 'assessment_unavailable', semantic: a.semantic, detector: a.detector.state === 'unavailable' ? a.detector.reason : a.detector.result.status,
-                originalTask: state.task, permissions: 'unchanged_native_policy', preparedExecutionAllowed: false, nextAction: 'report_assessment_unavailable',
-                recovery: 'Preserve the request and report the unavailable assessment. Do not repeat clarification, claim preparation succeeded, or switch tools to bypass this preparation boundary.', detail: '原文照合または有限領域検査を利用できません。実行は準備されていません。' };
+            return {
+                prepared: false,
+                status: 'assessment_unavailable',
+                semantic: a.semantic,
+                detector: a.detector.state === 'unavailable'
+                    ? a.detector.reason
+                    : a.detector.result.status,
+                originalTask: state.task,
+                permissions: 'unchanged_native_policy',
+                preparedExecutionAllowed: false,
+                nextAction: 'report_assessment_unavailable',
+                recovery: 'Preserve the request and report the unavailable assessment. Do not repeat clarification, claim preparation succeeded, or switch tools to bypass this preparation boundary.',
+                detail: '原文照合または有限領域検査を利用できません。実行は準備されていません。',
+            };
         }
-        const scope = state.requestIntent?.action === 'change' && state.requestIntent.changeScope === 'unknown'
-            || reason.message.startsWith('The requested change scope');
+        // An inconclusive detector is not evidence that the human omitted a target.
+        // Return the submitted interpretation for repair; keep preparation denied.
+        if (reason.assessment &&
+            state.assessment?.result.semantic === 'insufficient' &&
+            reason.candidate) {
+            return {
+                prepared: false,
+                status: 'assessment_rejected',
+                semantic: state.assessment.result.semantic,
+                semanticIssues: state.assessment.result.semanticIssues ?? [],
+                originalTask: state.task,
+                requestIntent: reason.candidate,
+                currentReferences: context
+                    ? requestIntentRequiredReferenceIds(context)
+                    : [],
+                availableReferences: context ? requestIntentReferenceIds(context) : [],
+                permissions: 'unchanged_native_policy',
+                nextAction: 'revise_request_intent_or_report_conflict',
+                detail: 'The independent comparison did not establish the submitted candidate. Re-read the captured request, answers, active task and same-session plan. Cite an existing proposal only when the request adopts it. Correct the candidate or report the specific unresolved comparison; do not repeat an identical submission or ask the human to supply internal classification fields. Ask a concrete question only if the source itself leaves an action or target ambiguous. No work is prepared.',
+            };
+        }
+        const scope = (state.requestIntent?.action === 'change' &&
+            state.requestIntent.changeScope === 'unknown') ||
+            reason.message.startsWith('The requested change scope');
         const target = !!executionClarification(state.task, state.requestIntent, context);
         const transition = context?.activeTask && !taskCanExecute(context.activeTask);
-        const question = reason.assessment ? '現在の依頼と実行候補の対象・操作・制約を照合できませんでした。今回の対象と希望する操作、以前の指示を変更する範囲を教えてください。'
-            : transition ? `現在のタスクは ${context.activeTask.state} です。続けるために、どの操作を希望しますか？（${taskAllowedOperations(context.activeTask).join(' / ')}）`
-                : target ? 'どの具体的なファイル・項目・相手・操作を対象にしますか？'
-                    : scope ? '変更するのは文章だけですか、それともコード・テスト・設定も含みますか？'
-                        : state.requestIntent?.action === 'unknown' ? 'その対象に、具体的に何をしてほしいですか？'
+        const question = reason.assessment
+            ? '現在の依頼と実行候補の対象・操作・制約を照合できませんでした。今回の対象と希望する操作、以前の指示を変更する範囲を教えてください。'
+            : transition
+                ? `現在のタスクは ${context.activeTask.state} です。続けるために、どの操作を希望しますか？（${taskAllowedOperations(context.activeTask).join(' / ')}）`
+                : target
+                    ? 'どの具体的なファイル・項目・相手・操作を対象にしますか？'
+                    : scope
+                        ? '変更するのは文章だけですか、それともコード・テスト・設定も含みますか？'
+                        : state.requestIntent?.action === 'unknown'
+                            ? 'その対象に、具体的に何をしてほしいですか？'
                             : '今回の依頼は現在の作業の続きですか、それとも別の作業ですか？';
-        const replies = this.#clarificationContexts.get(state.input.agent) ?? new Map();
-        const clarification = collectClarificationContext(humanMessages(state.input.messages).map(message => ({ id: humanId(message), text: humanTask([message]) })), replies);
-        const answerScope = canonicalContentHash({ activeTask: context?.activeTask ?? null, activeGoal: context?.activeGoal ?? null, proposals: context?.proposals ?? [] });
+        const replies = this.#clarificationContexts.get(state.input.agent) ??
+            new Map();
+        const clarification = collectClarificationContext(humanMessages(state.input.messages).map((message) => ({
+            id: humanId(message),
+            text: humanTask([message]),
+        })), replies);
+        const answerScope = canonicalContentHash({
+            activeTask: context?.activeTask ?? null,
+            activeGoal: context?.activeGoal ?? null,
+            proposals: context?.proposals ?? [],
+        });
         const answered = reusableClarificationAnswer(clarification, question, answerScope);
         if (answered)
-            return { prepared: false, status: 'clarification_answer_available', question, questionId: answered.questionId, answer: answered.value,
-                originalTask: clarification.sources.map(source => source.text).join('\n'), permissions: 'unchanged_native_policy',
-                currentReferences: context ? requestIntentRequiredReferenceIds(context) : [], nextAction: 'submit_current_request_intent' };
-        const key = canonicalContentHash({ context: context ?? null, task: state.task, humanEvidence: [...state.humanContents], question });
+            this.#clarifications.delete(sessionId);
+        if (answered && reason.assessment)
+            return {
+                prepared: false,
+                status: 'assessment_rejected',
+                semantic: state.assessment?.result.semantic,
+                semanticIssues: state.assessment?.result.semanticIssues ?? [],
+                detector: state.assessment?.result.detector.state === 'available'
+                    ? state.assessment.result.detector.result.status
+                    : state.assessment?.result.detector.reason,
+                originalTask: state.task,
+                currentReferences: context
+                    ? requestIntentRequiredReferenceIds(context)
+                    : [],
+                permissions: 'unchanged_native_policy',
+                nextAction: 'revise_request_intent_or_report_conflict',
+                detail: 'The current candidate still conflicts with, or is not established by, the source including the latest answer. Revise the candidate using that answer or explain the specific unresolved conflict. Do not repeat an identical submission or the answered question.',
+            };
+        if (answered)
+            return {
+                prepared: false,
+                status: 'clarification_answer_available',
+                question,
+                questionId: answered.questionId,
+                answer: answered.value,
+                originalTask: clarification.sources
+                    .map((source) => source.text)
+                    .join('\n'),
+                permissions: 'unchanged_native_policy',
+                currentReferences: context
+                    ? requestIntentRequiredReferenceIds(context)
+                    : [],
+                nextAction: 'submit_current_request_intent',
+            };
+        const key = canonicalContentHash({
+            context: context ?? null,
+            task: state.task,
+            humanEvidence: [...state.humanContents],
+            question,
+        });
         const previous = this.#clarifications.get(sessionId);
         if (previous?.agent === state.input.agent && previous.key === key)
             return previous.operation ?? previous.result;
         const id = `request-clarification-${key.slice(0, 20)}`;
-        const result = { prepared: false, status: 'awaiting_clarification', question, questionId: id, originalTask: state.task,
-            permissions: 'unchanged_native_policy', nextAction: this.host.questions ? 'wait_for_user' : 'ask_user_once' };
-        const pending = { agent: state.input.agent, turn: state.input.turn, key, status: 'waiting', result: result,
-            operation: undefined };
+        const result = {
+            prepared: false,
+            status: 'awaiting_clarification',
+            question,
+            questionId: id,
+            originalTask: state.task,
+            ...(requestIntentIsUnresolved(state.requestIntent)
+                ? {
+                    requestInterpretation: requestInterpretationRecovery(state.requestIntent, context),
+                }
+                : {}),
+            ...(reason.assessment
+                ? {
+                    semantic: state.assessment?.result.semantic,
+                    semanticIssues: state.assessment?.result.semanticIssues ?? [],
+                }
+                : {}),
+            permissions: 'unchanged_native_policy',
+            nextAction: this.host.questions ? 'wait_for_user' : 'ask_user_once',
+        };
+        const pending = {
+            agent: state.input.agent,
+            turn: state.input.turn,
+            key,
+            status: 'waiting',
+            result: result,
+            operation: undefined,
+        };
         this.#clarifications.set(sessionId, pending);
-        await this.diagnose(state, { kind: 'question', questionRef: id, reason: transition ? 'transition_required' : target ? 'target_unknown' : scope ? 'scope_unknown' : 'clarification_required' });
+        await this.diagnose(state, {
+            kind: 'question',
+            questionRef: id,
+            reason: transition
+                ? 'transition_required'
+                : target
+                    ? 'target_unknown'
+                    : scope
+                        ? 'scope_unknown'
+                        : 'clarification_required',
+        });
         if (!this.host.questions || !state.input.agent.followup)
             return result;
         const operation = (async () => {
             try {
-                const response = await abortable(this.host.questions.ask({ agent: state.input.agent, signal,
-                    questions: [{ id, question, ...(scope && !target && !transition ? { options: [{ label: '文章のみ' }, { label: 'コード・テスト・設定を含む' }] } : {}) }] }), signal);
+                const response = await abortable(this.host.questions.ask({
+                    agent: state.input.agent,
+                    signal,
+                    questions: [
+                        {
+                            id,
+                            question,
+                            ...(scope && !target && !transition
+                                ? {
+                                    options: [
+                                        { label: '文章のみ' },
+                                        { label: 'コード・テスト・設定を含む' },
+                                    ],
+                                }
+                                : {}),
+                        },
+                    ],
+                }), signal);
                 signal.throwIfAborted();
                 this.assertCurrent(state);
-                if (this.#clarifications.get(sessionId) !== pending || pending.status !== 'waiting')
+                if (this.#clarifications.get(sessionId) !== pending ||
+                    pending.status !== 'waiting')
                     return result;
                 await this.host.validate(state.input);
                 signal.throwIfAborted();
                 this.assertCurrent(state);
-                const current = await this.host.interpret?.(state.input, state.task);
+                const current = this.host.requestContext
+                    ? await this.host.requestContext(state.input, state.task)
+                    : (await this.host.interpret?.(state.input, state.task))?.context;
                 signal.throwIfAborted();
                 this.assertCurrent(state);
-                if (context && (!current || canonicalContentHash(current.context) !== canonicalContentHash(context))) {
+                if (context &&
+                    (!current ||
+                        canonicalContentHash(current) !== canonicalContentHash(context))) {
                     if (current) {
-                        state.requestIntentContext = current.context;
-                        state.requestIntent = current.decision;
-                        state.requestIntentContextDigest = canonicalContentHash(current.context);
+                        state.requestIntentContext = current;
+                        state.requestIntent = unresolvedRequestIntent(current, 'clarification_context_changed');
+                        state.requestIntentContextDigest = canonicalContentHash(current);
                     }
-                    pending.result = { ...result, ...(current ? { currentReferences: requestIntentRequiredReferenceIds(current.context) } : {}), status: 'clarification_context_changed', detail: 'The task or current evidence changed while awaiting the answer. Refresh the current request before asking again.' };
+                    pending.result = {
+                        ...result,
+                        ...(current
+                            ? {
+                                currentReferences: requestIntentRequiredReferenceIds(current),
+                            }
+                            : {}),
+                        status: 'clarification_context_changed',
+                        detail: 'The task or current evidence changed while awaiting the answer. Refresh the current request before asking again.',
+                    };
                     return pending.result;
                 }
                 const answer = response.answers[0];
@@ -636,17 +1033,38 @@ export class OnDemandIntake {
                 // label the actual UI answer separately, and re-enter ordinary native
                 // capture. The reply itself is never mapped to execution authority.
                 const answerMessageId = randomUUID();
-                const reply = clarificationReply(clarification, { id: answerMessageId, questionId: id, question, value, scope: answerScope });
+                const reply = clarificationReply(clarification, {
+                    id: answerMessageId,
+                    questionId: id,
+                    question,
+                    value,
+                    scope: answerScope,
+                });
                 const content = reply.content;
                 signal.throwIfAborted();
                 this.assertCurrent(state);
                 replies.set(answerMessageId, reply.context);
                 this.#clarificationContexts.set(state.input.agent, replies);
-                state.input.agent.followup({ id: answerMessageId, role: 'user', source: { kind: 'user' }, content: [{ type: 'text', text: content }] });
-                await this.diagnose(state, { kind: 'answer', questionRef: id, answerRef: answerMessageId });
+                state.input.agent.followup({
+                    id: answerMessageId,
+                    role: 'user',
+                    source: { kind: 'user' },
+                    content: [{ type: 'text', text: content }],
+                });
+                await this.diagnose(state, {
+                    kind: 'answer',
+                    questionRef: id,
+                    answerRef: answerMessageId,
+                });
                 pending.status = 'queued';
-                pending.result = { ...result, status: 'clarification_answer_queued', answer: value, answerRef: answerMessageId,
-                    nextAction: 'await_queued_answer_capture', detail: 'The answer is already queued as native user input. Do not ask it again or reuse old references. Continue only after the host captures the queued answer and supplies its current references.' };
+                pending.result = {
+                    ...result,
+                    status: 'clarification_answer_queued',
+                    answer: value,
+                    answerRef: answerMessageId,
+                    nextAction: 'await_queued_answer_capture',
+                    detail: 'The answer is already queued as native user input. Do not ask it again or reuse old references. Continue only after the host captures the queued answer and supplies its current references.',
+                };
                 return pending.result;
             }
             catch (error) {
@@ -655,8 +1073,18 @@ export class OnDemandIntake {
                         this.#clarifications.delete(sessionId);
                     throw error;
                 }
-                // A dismissed/unavailable question surface remains waiting, never approved.
-                return result;
+                // Dismissal remains unapproved. A failed surface or host read can be
+                // retried explicitly instead of retaining a dead pending question.
+                if (error?.code === 'ASK_CANCELLED')
+                    return result;
+                if (this.#clarifications.get(sessionId) === pending)
+                    this.#clarifications.delete(sessionId);
+                return {
+                    ...result,
+                    status: 'clarification_unavailable',
+                    nextAction: 'retry_preparation',
+                    detail: 'The question or its current context could not be read. No work was prepared and no answer was queued. Retry explicitly after restoring the question surface or host storage.',
+                };
             }
             finally {
                 pending.operation = undefined;
@@ -665,24 +1093,50 @@ export class OnDemandIntake {
         pending.operation = operation;
         return this.watch(operation);
     }
-    bindIntent(state, submission) {
+    async bindIntent(state, submission) {
         if (!submission) {
-            if (state.requestIntent?.action === 'change' && state.requestIntent.changeScope === 'unknown') {
+            if (requestIntentIsUnresolved(state.requestIntent) &&
+                this.host.interpret) {
+                const current = await this.host.interpret(state.input, state.task);
+                this.assertCurrent(state);
+                if (current) {
+                    state.requestIntentContext = current.context;
+                    state.requestIntentContextDigest = canonicalContentHash(current.context);
+                    state.requestIntent = current.decision;
+                }
+            }
+            if (requestIntentIsUnresolved(state.requestIntent) &&
+                state.requestIntentContext &&
+                state.requestIntent?.source === 'unresolved' &&
+                state.requestIntent.unresolvedReason !==
+                    'provider_abstained_or_uncertain' &&
+                !this.#clarifications.has(state.input.agent.session.id)) {
+                throw new RequestClarification('The main model must interpret the current request before preparing work', false, true);
+            }
+            if (state.requestIntent?.action === 'change' &&
+                state.requestIntent.changeScope === 'unknown') {
                 throw new RequestClarification('The requested change scope is unresolved. Specify implementation or document using the current request evidence before preparing work.');
             }
             return state.requestIntent;
         }
-        if (!state.requestIntentContext || state.requestIntentContextDigest !== canonicalContentHash(state.requestIntentContext)) {
+        if (!state.requestIntentContext ||
+            state.requestIntentContextDigest !==
+                canonicalContentHash(state.requestIntentContext)) {
             throw new Error('Request interpretation context is stale');
         }
         const result = validateMainModelRequestIntent(submission, state.requestIntentContext);
         if (!result.ok) {
             switch (result.reason) {
-                case 'no_active_goal': throw new Error(`Request relation ${submission.relation} cannot be used without an active Goal. ${NO_ACTIVE_GOAL_GUIDANCE}`);
-                case 'missing_reference': throw new Error('Request interpretation is missing required current message or active Goal references. Use the exact current evidenceRefs from the supplied context.');
-                case 'unknown_reference': throw new Error('Request interpretation references another request, stale revision, or unknown proposal. Use only the exact current evidenceRefs from the supplied context.');
-                case 'unresolved_intent': throw new RequestClarification('Request relation or action is unresolved. Interpret the original request and current context; clarify with the user if its action or target remains unclear.');
-                case 'invalid_submission': throw new Error('Invalid request interpretation. Supply a relation, action and unique exact current evidenceRefs.');
+                case 'no_active_goal':
+                    throw new Error(`Request relation ${submission.relation} cannot be used without an active Goal. ${NO_ACTIVE_GOAL_GUIDANCE}`);
+                case 'missing_reference':
+                    throw new Error('Request interpretation is missing required current message or active Goal references. Use the exact current evidenceRefs from the supplied context.');
+                case 'unknown_reference':
+                    throw new Error('Request interpretation references another request, stale revision, or unknown proposal. Use only the exact current evidenceRefs from the supplied context.');
+                case 'unresolved_intent':
+                    throw new RequestClarification('Request relation or action is unresolved. Interpret the original request and current context; clarify with the user if its action or target remains unclear.');
+                case 'invalid_submission':
+                    throw new Error('Invalid request interpretation. Supply a relation, action and unique exact current evidenceRefs.');
                 case 'invalid_task_operation': {
                     const task = state.requestIntentContext.activeTask;
                     if (!task)
@@ -694,10 +1148,12 @@ export class OnDemandIntake {
         }
         const bound = result.decision;
         if (bound.action === 'change' && bound.changeScope === 'unknown') {
-            throw new RequestClarification('The requested change scope is unresolved. Specify implementation or document using the current request evidence before preparing work.');
+            throw new RequestClarification('Determine requestIntent.changeScope from the captured request and plan in the main model. Ask a concrete human question only if the source itself leaves that choice unclear.', false, true, bound);
         }
         const prior = state.requestIntent;
-        if (prior?.source === 'decision-provider' && prior.relation !== 'unknown' && prior.action !== 'unknown') {
+        if (prior?.source === 'decision-provider' &&
+            prior.relation !== 'unknown' &&
+            prior.action !== 'unknown') {
             if (prior.relation !== bound.relation || prior.action !== bound.action) {
                 throw new Error('Main-model interpretation conflicts with the configured decision provider');
             }
@@ -711,55 +1167,118 @@ export class OnDemandIntake {
         // Project the immutable human batch captured before that waterfall.
         if (state?.input.turn === input.turn && state.input.agent !== input.agent)
             throw new Error('Answer projection native agent changed');
-        const projected = state?.input.turn === input.turn && !state.nativeUnowned && state.answerContextReady && !state.confirmationResume && this.host.answerContext
-            ? await this.host.answerContext.project(state.input, messages, this.ownerIdentity(state)) : messages;
+        const projected = state?.input.turn === input.turn &&
+            !state.nativeUnowned &&
+            state.answerContextReady &&
+            !state.confirmationResume &&
+            this.host.answerContext
+            ? await this.host.answerContext.project(state.input, messages, this.ownerIdentity(state))
+            : messages;
         return this.guidance(projected, state?.input.turn === input.turn ? state : undefined);
     }
     async beforeRequest(agent) {
         const state = agent.session && this.#turns.get(agent.session.id);
-        if (state && !state.nativeUnowned && state.answerContextReady && state.input.agent === agent && state.status === 'answer' && this.pending(agent)) {
+        if (state &&
+            !state.nativeUnowned &&
+            state.answerContextReady &&
+            state.input.agent === agent &&
+            state.status === 'answer' &&
+            this.pending(agent)) {
             await this.host.answerContext?.beforeRequest(state.input, this.ownerIdentity(state));
         }
     }
     async fence(agent, request) {
         const state = agent.session && this.#turns.get(agent.session.id);
-        if (state && !state.nativeUnowned && state.answerContextReady && state.input.agent === agent && state.status === 'answer' && this.pending(agent)) {
+        if (state &&
+            !state.nativeUnowned &&
+            state.answerContextReady &&
+            state.input.agent === agent &&
+            state.status === 'answer' &&
+            this.pending(agent)) {
             await this.host.answerContext?.fence(state.input, request, this.ownerIdentity(state));
         }
     }
     guidance(messages, state) {
         const context = state?.requestIntentContext;
         const interpretation = state?.requestIntent;
-        const intentText = context ? `\n\nCurrent request references and same-session work (host-bound, advisory only):\n${JSON.stringify({
-            references: requestIntentReferenceIds(context),
-            requiredReferences: requestIntentRequiredReferenceIds(context),
-            activeGoal: context.activeGoal ?? null,
-            activeTask: context.activeTask ?? null,
-            proposals: context.proposals.map(({ id, revision, digest, text }) => ({ id, revision, digest, text,
-                evidenceRef: `proposal:${canonicalContentHash([id, revision, digest])}` })),
-            decision: interpretation ? { relation: interpretation.relation, action: interpretation.action, source: interpretation.source,
-                policyVersion: interpretation.policyVersion, evidence: interpretation.evidence, unresolvedReason: interpretation.unresolvedReason ?? null } : null,
-        })}\nInclude every requiredReferences entry in requestIntent.evidenceRefs. Add a proposal evidenceRef only when the current user request actually adopts or refers to that proposal; do not copy all proposals automatically. Use only these exact references. The original human message remains unchanged.` : '';
-        const text = ON_DEMAND_GUIDANCE + intentText + (context && !context.activeGoal && !context.activeTask ? `\n${NO_ACTIVE_GOAL_GUIDANCE}` : '');
-        return [...messages, { id: randomUUID(), role: 'user', content: [{ type: 'text', text }],
-                source: { kind: KIOKUKO_DSH_SOURCE_KIND, form: 'snapshot', sections: [{ name: 'on-demand-intake', text }] } }];
+        const intentText = context
+            ? `\n\nCurrent request references and same-session work (host-bound, advisory only):\n${JSON.stringify({
+                references: requestIntentReferenceIds(context),
+                requiredReferences: requestIntentRequiredReferenceIds(context),
+                activeGoal: context.activeGoal ?? null,
+                activeTask: context.activeTask ?? null,
+                proposals: context.proposals.map(({ id, revision, digest, text }) => ({
+                    id,
+                    revision,
+                    digest,
+                    text,
+                    evidenceRef: `proposal:${canonicalContentHash([id, revision, digest])}`,
+                })),
+                decision: interpretation
+                    ? {
+                        relation: interpretation.relation,
+                        action: interpretation.action,
+                        source: interpretation.source,
+                        policyVersion: interpretation.policyVersion,
+                        evidence: interpretation.evidence,
+                        unresolvedReason: interpretation.unresolvedReason ?? null,
+                    }
+                    : null,
+            })}\nInclude every requiredReferences entry in requestIntent.evidenceRefs. Add a proposal evidenceRef only when the current user request actually adopts or refers to that proposal; do not copy all proposals automatically. Use only these exact references. The original human message remains unchanged.`
+            : '';
+        const text = ON_DEMAND_GUIDANCE +
+            intentText +
+            (context && !context.activeGoal && !context.activeTask
+                ? `\n${NO_ACTIVE_GOAL_GUIDANCE}`
+                : '');
+        return [
+            ...messages,
+            {
+                id: randomUUID(),
+                role: 'user',
+                content: [{ type: 'text', text }],
+                source: {
+                    kind: KIOKUKO_DSH_SOURCE_KIND,
+                    form: 'snapshot',
+                    sections: [{ name: 'on-demand-intake', text }],
+                },
+            },
+        ];
     }
     snapshot(sessionId) {
         const state = this.#turns.get(sessionId);
-        return state && { task: state.task, taskType: state.taskType ?? state.intent.taskType ?? null, status: state.status, turn: state.input.turn,
-            ...(state.requestIntent ? { requestIntent: structuredClone(state.requestIntent) } : {}), memoryOwner: state.memoryOwner };
+        return (state && {
+            task: state.task,
+            taskType: state.taskType ?? state.intent.taskType ?? null,
+            status: state.status,
+            turn: state.input.turn,
+            ...(state.requestIntent
+                ? { requestIntent: structuredClone(state.requestIntent) }
+                : {}),
+            memoryOwner: state.memoryOwner,
+        });
     }
     /** Refresh only authority facts after a committed control operation; retain the exact human request. */
     taskStateChanged(task) {
         const state = this.#turns.get(task.sessionId);
-        if (!state || ['closed', 'stale'].includes(state.status) || state.input.signal.aborted || !state.requestIntentContext)
+        if (!state ||
+            ['closed', 'stale'].includes(state.status) ||
+            state.input.signal.aborted ||
+            !state.requestIntentContext)
             return;
         state.nativeUnowned = false;
         const previous = state.requestIntentContext.activeTask;
-        if (previous?.taskId === task.taskId && previous.revision === task.revision && previous.generation === task.generation)
+        if (previous?.taskId === task.taskId &&
+            previous.revision === task.revision &&
+            previous.generation === task.generation)
             return;
-        const context = createRequestIntentContext({ ...state.requestIntentContext, activeTask: task,
-            ...(state.requestIntentContext.activeGoal?.runId === task.runId ? {} : { activeGoal: undefined }) });
+        const context = createRequestIntentContext({
+            ...state.requestIntentContext,
+            activeTask: task,
+            ...(state.requestIntentContext.activeGoal?.runId === task.runId
+                ? {}
+                : { activeGoal: undefined }),
+        });
         if (!context)
             return;
         state.requestIntentContext = context;
@@ -774,19 +1293,40 @@ export class OnDemandIntake {
     /** Exact registered native-tool proof, never a model flag or a generic task-control bypass. */
     unownedNative(execution) {
         const state = this.bound(execution), proof = this.#executions.get(execution);
-        return !this.#stopped && !execution.signal.aborted && UNOWNED_NATIVE_TOOLS.has(execution.name) && execution.parent === undefined
-            && !!state && state.nativeUnowned === true && state.status === 'answer' && !state.input.signal.aborted
-            && !!proof && proof.turn === state && proof.execute === this.definition(execution)?.execute
-            && proof.nativeUnownedDigest === canonicalContentHash(execution.arguments);
+        return (!this.#stopped &&
+            !execution.signal.aborted &&
+            UNOWNED_NATIVE_TOOLS.has(execution.name) &&
+            execution.parent === undefined &&
+            !!state &&
+            state.nativeUnowned === true &&
+            state.status === 'answer' &&
+            !state.input.signal.aborted &&
+            !!proof &&
+            proof.turn === state &&
+            proof.execute === this.definition(execution)?.execute &&
+            proof.nativeUnownedDigest === canonicalContentHash(execution.arguments));
     }
     /** Direct native Bash follows native permissions, independently of optional task intake. */
     nativeCommand(execution) {
         const state = this.bound(execution), actual = this.definition(execution), proof = this.#executions.get(execution);
-        if (!this.options.onlyWhenDeferred && !this.#stopped && actual && isLispNativeCommand(execution, actual.execute))
-            return !proof || proof.turn === state && proof.execute === actual.execute && proof.nativeCommandDigest === canonicalContentHash(execution.arguments);
-        if (this.options.onlyWhenDeferred || this.#stopped || execution.signal.aborted || execution.name !== 'bash'
-            || execution.parent !== undefined || !state || state.input.signal.aborted || !actual
-            || execution.agent && this.host.nativeChild?.(execution.agent))
+        if (!this.options.onlyWhenDeferred &&
+            !this.#stopped &&
+            actual &&
+            isLispNativeCommand(execution, actual.execute))
+            return (!proof ||
+                (proof.turn === state &&
+                    proof.execute === actual.execute &&
+                    proof.nativeCommandDigest ===
+                        canonicalContentHash(execution.arguments)));
+        if (this.options.onlyWhenDeferred ||
+            this.#stopped ||
+            execution.signal.aborted ||
+            execution.name !== 'bash' ||
+            execution.parent !== undefined ||
+            !state ||
+            state.input.signal.aborted ||
+            !actual ||
+            (execution.agent && this.host.nativeChild?.(execution.agent)))
             return false;
         try {
             this.assertCurrent(state);
@@ -794,15 +1334,24 @@ export class OnDemandIntake {
         catch {
             return false;
         }
-        return !proof || proof.turn === state && proof.execute === actual.execute
-            && proof.nativeCommandDigest === canonicalContentHash(execution.arguments);
+        return (!proof ||
+            (proof.turn === state &&
+                proof.execute === actual.execute &&
+                proof.nativeCommandDigest === canonicalContentHash(execution.arguments)));
     }
     /** Delegate real root Lisp tools to their own effect/lease/approval authority. */
     nativeLisp(execution) {
         const state = this.bound(execution), actual = this.definition(execution), proof = this.#executions.get(execution);
-        if (this.options.onlyWhenDeferred || this.#stopped || execution.signal.aborted || execution.parent !== undefined
-            || !state || state.status !== 'answer' || state.input.signal.aborted || !actual || !isLispImplementation(actual.execute)
-            || execution.agent && this.host.nativeChild?.(execution.agent))
+        if (this.options.onlyWhenDeferred ||
+            this.#stopped ||
+            execution.signal.aborted ||
+            execution.parent !== undefined ||
+            !state ||
+            state.status !== 'answer' ||
+            state.input.signal.aborted ||
+            !actual ||
+            !isLispImplementation(actual.execute) ||
+            (execution.agent && this.host.nativeChild?.(execution.agent)))
             return false;
         try {
             this.assertCurrent(state);
@@ -810,35 +1359,63 @@ export class OnDemandIntake {
         catch {
             return false;
         }
-        return !proof || proof.turn === state && proof.execute === actual.execute
-            && proof.nativeLispDigest === canonicalContentHash(execution.arguments);
+        return (!proof ||
+            (proof.turn === state &&
+                proof.execute === actual.execute &&
+                proof.nativeLispDigest === canonicalContentHash(execution.arguments)));
     }
     preparationOnly(execution) {
         if (this.isControl(execution))
             return true;
         const state = this.bound(execution), proof = this.#executions.get(execution);
-        if (this.#stopped || execution.signal.aborted || execution.parent !== undefined || !state || state.input.signal.aborted
-            || !proof || proof.turn !== state || this.definition(execution)?.execute !== proof.execute
-            || state.preparationCalls.has(execution.callId))
+        if (this.#stopped ||
+            execution.signal.aborted ||
+            execution.parent !== undefined ||
+            !state ||
+            state.input.signal.aborted ||
+            !proof ||
+            proof.turn !== state ||
+            this.definition(execution)?.execute !== proof.execute ||
+            state.preparationCalls.has(execution.callId))
             return false;
         if (proof.carrier)
-            return execution.name === 'run_code' && state.status === 'answer'
-                && canonicalContentHash(preparationCarrier(execution.arguments) ?? null) === proof.carrierDigest;
-        return proof.requestPreparation === true && execution.name === TASK_PREPARE_TOOL
-            && (state.status === 'answer' || state.existing === true && state.status === 'prepared' && this.host.ready(state.input.agent, state.input.turn));
+            return (execution.name === 'run_code' &&
+                state.status === 'answer' &&
+                canonicalContentHash(preparationCarrier(execution.arguments) ?? null) === proof.carrierDigest);
+        return (proof.requestPreparation === true &&
+            execution.name === TASK_PREPARE_TOOL &&
+            (state.status === 'answer' ||
+                (state.existing === true &&
+                    state.status === 'prepared' &&
+                    this.host.ready(state.input.agent, state.input.turn))));
     }
     pending(agent) {
         const state = agent.session && this.#turns.get(agent.session.id);
-        return !!state && !state.confirmationResume && state.input.agent === agent && !['prepared', 'closed', 'stale'].includes(state.status);
+        return (!!state &&
+            !state.confirmationResume &&
+            state.input.agent === agent &&
+            !['prepared', 'closed', 'stale'].includes(state.status));
     }
     /** An admitted host continuation still needs capture to retire the previous turn's receipt. */
-    continuing(agent) { return !this.#stopped && this.host.ready(agent); }
+    continuing(agent) {
+        return !this.#stopped && this.host.ready(agent);
+    }
     /** Exact captured task at a native lifecycle boundary, never a later selected task. */
     boundaryTask(session, turn) {
         const state = this.#turns.get(session.id), task = state?.requestIntentContext?.activeTask;
-        if (state?.input.agent.session !== session || state.input.turn !== turn || !task || task.state !== 'Working')
+        if (state?.input.agent.session !== session ||
+            state.input.turn !== turn ||
+            !task ||
+            task.state !== 'Working')
             return undefined;
-        return { agent: state.input.agent, expected: { taskId: task.taskId, revision: task.revision, generation: task.generation } };
+        return {
+            agent: state.input.agent,
+            expected: {
+                taskId: task.taskId,
+                revision: task.revision,
+                generation: task.generation,
+            },
+        };
     }
     finish(session, turn) {
         const state = this.#turns.get(session.id);
@@ -858,37 +1435,66 @@ export class OnDemandIntake {
         // Trust the validated host registry, not a later same-name replacement.
         this.#startupQuestionTool = tools.get('ask_user_question')?.execute;
         if (systemPrompt && !this.options.onlyWhenDeferred)
-            this.#disposers.push(systemPrompt.section({ name: 'kiokuko:on-demand-intake', order: -99999, text: 'On-demand host contract: text answers do not require execution intake. The public prepare_requested_work tool accepts an advisory taskType or a source-bound requestIntent; task_prepare/task_answer remain host-only. ' + ON_DEMAND_GUIDANCE }));
-        const definition = { name: TASK_PREPARE_TOOL, modelFacing: true,
+            this.#disposers.push(systemPrompt.section({
+                name: 'kiokuko:on-demand-intake',
+                order: -99999,
+                text: 'On-demand host contract: text answers do not require execution intake. The public prepare_requested_work tool accepts an advisory taskType or a source-bound requestIntent; task_prepare/task_answer remain host-only. ' +
+                    ON_DEMAND_GUIDANCE,
+            }));
+        const definition = {
+            name: TASK_PREPARE_TOOL,
+            modelFacing: true,
             description: 'Prepare the exact original user request for tool-backed work. Supply either legacy advisory taskType or requestIntent with exact evidenceRefs from the host context; never rewrite the task or invent a target. This does not grant native tool permissions. Answer ordinary questions directly; clarify unknown actions or targets first.',
-            parameters: { ...JSON.parse(JSON.stringify(z.toJSONSchema(preparationFieldsSchema))), anyOf: [{ required: ['taskType'] }, { required: ['requestIntent'] }] },
-            output: { schema: {}, render: (_args, value) => [{ type: 'text', text: JSON.stringify(value) }] },
+            parameters: {
+                ...JSON.parse(JSON.stringify(z.toJSONSchema(preparationFieldsSchema))),
+                anyOf: [{ required: ['taskType'] }, { required: ['requestIntent'] }],
+            },
+            output: {
+                schema: {},
+                render: (_args, value) => [
+                    { type: 'text', text: JSON.stringify(value) },
+                ],
+            },
             execute: async (args, execution) => {
                 const state = this.bound(execution);
                 const value = parsePreparationRequest(args);
-                if (!state || execution.name !== TASK_PREPARE_TOOL || this.definition(execution)?.execute !== definition.execute || !value)
+                if (!state ||
+                    execution.name !== TASK_PREPARE_TOOL ||
+                    this.definition(execution)?.execute !== definition.execute ||
+                    !value)
                     throw new Error('Invalid task preparation request');
-                if (state.preparationCalls.has(execution.callId) || !(state.status === 'answer' || state.status === 'prepared' && this.host.ready(state.input.agent, state.input.turn)))
+                if (state.preparationCalls.has(execution.callId) ||
+                    !(state.status === 'answer' ||
+                        (state.status === 'prepared' &&
+                            this.host.ready(state.input.agent, state.input.turn))))
                     throw new Error('Task preparation was already consumed for this turn');
                 state.preparationCalls.add(execution.callId);
                 try {
                     if (state.existing) {
                         this.assertCurrent(state);
                         execution.signal.throwIfAborted();
-                        const boundIntent = this.bindIntent(state, value.requestIntent);
-                        if (boundIntent?.relation === 'same_scope_continuation' && !requestIntentIsUnresolved(boundIntent) && boundIntent.action !== 'answer') {
+                        const boundIntent = await this.bindIntent(state, value.requestIntent);
+                        if (boundIntent?.relation === 'same_scope_continuation' &&
+                            !requestIntentIsUnresolved(boundIntent) &&
+                            boundIntent.action !== 'answer') {
                             const intentType = requestIntentTaskType(boundIntent, state.taskType ?? state.intent.taskType ?? value.taskType);
-                            if (value.taskType !== undefined && intentType !== undefined && value.taskType !== intentType) {
+                            if (value.taskType !== undefined &&
+                                intentType !== undefined &&
+                                value.taskType !== intentType) {
                                 throw new Error('The advisory taskType conflicts with the bound request action');
                             }
                             state.requestIntent = boundIntent;
                         }
                         else {
-                            if (!boundIntent || requestIntentIsUnresolved(boundIntent) || boundIntent.action === 'answer') {
+                            if (!boundIntent ||
+                                requestIntentIsUnresolved(boundIntent) ||
+                                boundIntent.action === 'answer') {
                                 throw new RequestClarification('Clarify whether this request continues, changes, or starts work before preparing it');
                             }
                             const intentType = requestIntentTaskType(boundIntent, state.taskType ?? state.intent.taskType ?? value.taskType);
-                            if (!intentType || intentType === 'chat' || value.taskType !== undefined && value.taskType !== intentType) {
+                            if (!intentType ||
+                                intentType === 'chat' ||
+                                (value.taskType !== undefined && value.taskType !== intentType)) {
                                 throw new Error('The advisory taskType conflicts with the bound request action');
                             }
                             state.existing = false;
@@ -898,43 +1504,68 @@ export class OnDemandIntake {
                         }
                     }
                     else {
-                        const suppliedIntent = this.bindIntent(state, value.requestIntent);
+                        const suppliedIntent = await this.bindIntent(state, value.requestIntent);
                         const currentIntent = suppliedIntent ?? state.requestIntent;
-                        const unresolved = currentIntent !== undefined && requestIntentIsUnresolved(currentIntent);
-                        if (unresolved && (state.requestIntentContext?.activeGoal || state.requestIntentContext?.activeTask || value.requestIntent !== undefined || value.taskType === undefined)) {
+                        const unresolved = currentIntent !== undefined &&
+                            requestIntentIsUnresolved(currentIntent);
+                        if (unresolved) {
                             throw new RequestClarification('Clarify the request before preparing work');
                         }
-                        if (state.requestIntentContext?.activeGoal && currentIntent === undefined) {
+                        if (state.requestIntentContext?.activeGoal &&
+                            currentIntent === undefined) {
                             throw new RequestClarification('Clarify whether this request continues, changes, or starts the active Goal');
                         }
-                        const intentType = unresolved ? undefined : requestIntentTaskType(currentIntent, state.taskType ?? state.intent.taskType ?? value.taskType);
-                        if (value.taskType !== undefined && intentType !== undefined && value.taskType !== intentType) {
+                        const intentType = unresolved
+                            ? undefined
+                            : requestIntentTaskType(currentIntent, state.taskType ?? state.intent.taskType ?? value.taskType);
+                        if (value.taskType !== undefined &&
+                            intentType !== undefined &&
+                            value.taskType !== intentType) {
                             throw new Error('The advisory taskType conflicts with the bound request action');
                         }
                         const taskType = intentType ?? value.taskType;
-                        if (!taskType || taskType === 'chat' || !ACTION_TYPES.includes(taskType))
+                        if (!taskType ||
+                            taskType === 'chat' ||
+                            !ACTION_TYPES.includes(taskType))
                             throw new RequestClarification('Answer ordinary questions directly; clarify unknown actions before preparing work');
                         state.memoryOwner = memoryOwnerKind(currentIntent, taskType);
                         await this.prepare(state, taskType, execution.signal, currentIntent, value.requestIntent !== undefined);
                     }
-                    return { prepared: true, taskType: state.taskType ?? value.taskType ?? requestIntentTaskType(state.requestIntent), originalTask: state.task,
-                        ...(state.requestIntent ? { requestIntent: state.requestIntent } : {}),
-                        ...(state.requestIntent && requestIntentIsUnresolved(state.requestIntent) ? { requestInterpretation: requestInterpretationRecovery(state.requestIntent, state.requestIntentContext, true) } : {}),
-                        memoryOwner: state.memoryOwner, permissions: 'unchanged_native_policy' };
+                    return {
+                        prepared: true,
+                        taskType: state.taskType ??
+                            value.taskType ??
+                            requestIntentTaskType(state.requestIntent),
+                        originalTask: state.task,
+                        ...(state.requestIntent
+                            ? { requestIntent: state.requestIntent }
+                            : {}),
+                        ...(state.requestIntent &&
+                            requestIntentIsUnresolved(state.requestIntent)
+                            ? {
+                                requestInterpretation: requestInterpretationRecovery(state.requestIntent, state.requestIntentContext, true),
+                            }
+                            : {}),
+                        memoryOwner: state.memoryOwner,
+                        permissions: 'unchanged_native_policy',
+                    };
                 }
                 catch (error) {
                     if (!(error instanceof RequestClarification))
                         throw error;
                     return this.clarify(state, execution.signal, error);
                 }
-            } };
+            },
+        };
         this.#disposers.push(tools.register(definition));
         this.#disposers.push(context.on('tools/pre-execute', async (execution, next) => {
             if (this.#stopped || execution.signal.aborted)
                 return denied('On-demand intake is stopped or cancelled');
             if (execution.agent && this.host.nativeChild?.(execution.agent)) {
                 const decision = await next();
-                return decision?.kind === 'cancel' ? denied('Native tool policy cancelled this call') : decision;
+                return decision?.kind === 'cancel'
+                    ? denied('Native tool policy cancelled this call')
+                    : decision;
             }
             await this.bindExecutorTransport(execution, context);
             const actual = this.definition(execution);
@@ -943,7 +1574,9 @@ export class OnDemandIntake {
             const control = this.controlCall(execution, actual);
             if (control) {
                 const turn = this.bound(execution);
-                if (execution.agent?.session && this.#turns.has(execution.agent.session.id) && !turn)
+                if (execution.agent?.session &&
+                    this.#turns.has(execution.agent.session.id) &&
+                    !turn)
                     return denied('Stale task control request');
                 if (turn) {
                     try {
@@ -953,70 +1586,127 @@ export class OnDemandIntake {
                         return denied('Stale task control request');
                     }
                 }
-                this.#controlExecutions.set(execution, { ...control, ...(turn ? { turn } : {}) });
+                this.#controlExecutions.set(execution, {
+                    ...control,
+                    ...(turn ? { turn } : {}),
+                });
                 const decision = await next();
-                return decision?.kind === 'cancel' ? denied('Native tool policy cancelled this call') : decision;
+                return decision?.kind === 'cancel'
+                    ? denied('Native tool policy cancelled this call')
+                    : decision;
             }
             const state = this.bound(execution);
             if (!state) {
-                if (execution.agent?.session && this.#turns.has(execution.agent.session.id))
+                if (execution.agent?.session &&
+                    this.#turns.has(execution.agent.session.id))
                     return denied('Stale on-demand native turn');
                 const turn = this.existingTurn(execution);
-                if (!execution.agent || turn === undefined || !this.host.ready(execution.agent, turn))
+                if (!execution.agent ||
+                    turn === undefined ||
+                    !this.host.ready(execution.agent, turn))
                     return denied('No current native request for tool execution');
                 const decision = await next();
-                return decision?.kind === 'cancel' ? denied('Native tool policy cancelled this call') : decision;
+                return decision?.kind === 'cancel'
+                    ? denied('Native tool policy cancelled this call')
+                    : decision;
             }
             try {
                 this.assertCurrent(state);
-                if (state.confirmationResume && execution.name !== TASK_PREPARE_TOOL && this.host.ready(state.input.agent, state.input.turn))
+                if (state.confirmationResume &&
+                    execution.name !== TASK_PREPARE_TOOL &&
+                    this.host.ready(state.input.agent, state.input.turn))
                     this.acknowledgeExisting(state);
                 if (this.nativeCommand(execution)) {
-                    this.#executions.set(execution, { turn: state, execute: actual.execute, nativeCommandDigest: canonicalContentHash(execution.arguments) });
+                    this.#executions.set(execution, {
+                        turn: state,
+                        execute: actual.execute,
+                        nativeCommandDigest: canonicalContentHash(execution.arguments),
+                    });
                     const decision = await next();
-                    return decision?.kind === 'cancel' ? denied('Native tool policy cancelled this call') : decision;
+                    return decision?.kind === 'cancel'
+                        ? denied('Native tool policy cancelled this call')
+                        : decision;
                 }
                 if (this.nativeLisp(execution)) {
-                    this.#executions.set(execution, { turn: state, execute: actual.execute, nativeLispDigest: canonicalContentHash(execution.arguments) });
+                    this.#executions.set(execution, {
+                        turn: state,
+                        execute: actual.execute,
+                        nativeLispDigest: canonicalContentHash(execution.arguments),
+                    });
                     const decision = await next();
-                    return decision?.kind === 'cancel' ? denied('Native tool policy cancelled this call') : decision;
+                    return decision?.kind === 'cancel'
+                        ? denied('Native tool policy cancelled this call')
+                        : decision;
                 }
                 // Evidence gathering does not decide the request's action or scope.
                 // In particular, an inherited owner must not turn a read into an
                 // immutable research preparation before the main model can interpret it.
-                if (state.status === 'answer' && !state.nativeUnowned && execution.parent === undefined && NATIVE_EVIDENCE_READS.has(execution.name)) {
+                if (state.status === 'answer' &&
+                    !state.nativeUnowned &&
+                    execution.parent === undefined &&
+                    NATIVE_EVIDENCE_READS.has(execution.name)) {
                     const clarification = executionClarification(state.task, state.requestIntent, state.requestIntentContext);
                     if (clarification)
                         return denied(clarification);
-                    this.#executions.set(execution, { turn: state, execute: actual.execute, evidenceReadDigest: canonicalContentHash(execution.arguments) });
+                    this.#executions.set(execution, {
+                        turn: state,
+                        execute: actual.execute,
+                        evidenceReadDigest: canonicalContentHash(execution.arguments),
+                    });
                     const decision = await next();
-                    return decision?.kind === 'cancel' ? denied('Native tool policy cancelled this call') : decision;
+                    return decision?.kind === 'cancel'
+                        ? denied('Native tool policy cancelled this call')
+                        : decision;
                 }
-                if (state.nativeUnowned && UNOWNED_NATIVE_TOOLS.has(execution.name) && execution.parent === undefined) {
-                    if (await this.host.nativeOwnership?.(state.input) !== 'unowned') {
+                if (state.nativeUnowned &&
+                    UNOWNED_NATIVE_TOOLS.has(execution.name) &&
+                    execution.parent === undefined) {
+                    if ((await this.host.nativeOwnership?.(state.input)) !== 'unowned') {
                         state.nativeUnowned = false;
                         return denied('Native execution acquired a Kiokuko owner; its current authority is required');
                     }
                     this.assertCurrent(state);
                     if (this.definition(execution)?.execute !== actual.execute)
                         return denied('Native tool definition changed');
-                    this.#executions.set(execution, { turn: state, execute: actual.execute, nativeUnownedDigest: canonicalContentHash(execution.arguments) });
+                    this.#executions.set(execution, {
+                        turn: state,
+                        execute: actual.execute,
+                        nativeUnownedDigest: canonicalContentHash(execution.arguments),
+                    });
                     const decision = await next();
-                    return decision?.kind === 'cancel' ? denied('Native tool policy cancelled this call') : decision;
+                    return decision?.kind === 'cancel'
+                        ? denied('Native tool policy cancelled this call')
+                        : decision;
                 }
                 const skillReader = this.#skillReaders.get(state.input.agent);
-                const skillRead = execution.name === 'skill' && skillReader !== undefined && actual.execute === skillReader && state.status === 'answer';
-                const carrier = execution.name === 'run_code' ? preparationCarrier(execution.arguments) : undefined;
-                const carrierDigest = carrier ? canonicalContentHash(carrier) : undefined;
-                if (execution.name === 'run_code' && state.status !== 'prepared' && !carrier
-                    && !automaticPreparationType(state.intent, state.requestIntent, execution.name))
+                const skillRead = execution.name === 'skill' &&
+                    skillReader !== undefined &&
+                    actual.execute === skillReader &&
+                    state.status === 'answer';
+                const carrier = execution.name === 'run_code'
+                    ? preparationCarrier(execution.arguments)
+                    : undefined;
+                const carrierDigest = carrier
+                    ? canonicalContentHash(carrier)
+                    : undefined;
+                if (execution.name === 'run_code' &&
+                    state.status !== 'prepared' &&
+                    !carrier &&
+                    !automaticPreparationType(state.intent, state.requestIntent, execution.name))
                     return denied('Clarify the requested work before code execution.');
                 if (carrier) {
-                    if (!(state.status === 'answer' || state.status === 'prepared' && this.host.ready(state.input.agent, state.input.turn)) || state.preparationCalls.has(execution.callId))
+                    if (!(state.status === 'answer' ||
+                        (state.status === 'prepared' &&
+                            this.host.ready(state.input.agent, state.input.turn))) ||
+                        state.preparationCalls.has(execution.callId))
                         return denied('Preparation carrier is not current');
                 }
                 else if (execution.name === TASK_PREPARE_TOOL) {
-                    if (actual.execute !== definition.execute || !(state.status === 'answer' || state.status === 'prepared' && this.host.ready(state.input.agent, state.input.turn)) || state.preparationCalls.has(execution.callId))
+                    if (actual.execute !== definition.execute ||
+                        !(state.status === 'answer' ||
+                            (state.status === 'prepared' &&
+                                this.host.ready(state.input.agent, state.input.turn))) ||
+                        state.preparationCalls.has(execution.callId))
                         return denied('Task preparation is not current');
                 }
                 else if (!skillRead) {
@@ -1032,13 +1722,21 @@ export class OnDemandIntake {
                 this.assertCurrent(state);
                 if (this.definition(execution)?.execute !== actual.execute)
                     return denied('Native tool definition changed during preparation');
-                this.#executions.set(execution, { turn: state, execute: actual.execute,
-                    ...(carrier && carrierDigest ? { carrier, carrierDigest } : {}), ...(skillRead ? { skillRead: true } : {}),
-                    ...(execution.name === TASK_PREPARE_TOOL ? { requestPreparation: true } : {}) });
+                this.#executions.set(execution, {
+                    turn: state,
+                    execute: actual.execute,
+                    ...(carrier && carrierDigest ? { carrier, carrierDigest } : {}),
+                    ...(skillRead ? { skillRead: true } : {}),
+                    ...(execution.name === TASK_PREPARE_TOOL
+                        ? { requestPreparation: true }
+                        : {}),
+                });
                 // Preserve native allow/deny/ask unchanged. Approval is resolved by the native registry AFTER this waterfall.
                 const decision = await next();
                 // DSH 0.1.5 does not understand cancel and otherwise dispatches it without running guards.
-                return decision?.kind === 'cancel' ? denied('Native tool policy cancelled this call') : decision;
+                return decision?.kind === 'cancel'
+                    ? denied('Native tool policy cancelled this call')
+                    : decision;
             }
             catch (error) {
                 if (error instanceof RequestClarification) {
@@ -1047,10 +1745,14 @@ export class OnDemandIntake {
                         return denied(`Execution was not prepared; no work was executed. ${JSON.stringify(result)}`);
                     }
                     catch (cancelled) {
-                        return denied(cancelled instanceof Error ? cancelled.message : 'Clarification cancelled');
+                        return denied(cancelled instanceof Error
+                            ? cancelled.message
+                            : 'Clarification cancelled');
                     }
                 }
-                return denied(error instanceof Error ? error.message : 'Execution preparation failed');
+                return denied(error instanceof Error
+                    ? error.message
+                    : 'Execution preparation failed');
             }
         }, { prepend: true }));
         this.#disposers.push(context.on('tools/execute', async (execution, next) => {
@@ -1060,21 +1762,37 @@ export class OnDemandIntake {
             if (control) {
                 if (!this.isControl(execution))
                     throw new Error('Task control identity or arguments changed');
-                execution.signal = AbortSignal.any([execution.signal, this.#lifecycle.signal, ...(control.turn ? [control.turn.input.signal] : [])]);
+                execution.signal = AbortSignal.any([
+                    execution.signal,
+                    this.#lifecycle.signal,
+                    ...(control.turn ? [control.turn.input.signal] : []),
+                ]);
                 if (!control.invoke)
                     return next();
                 const result = await control.invoke(control.args, execution);
-                return { isError: false, value: { logs: ['Host task operation. No program was evaluated.'], result },
-                    content: [{ type: 'text', text: JSON.stringify(result) }] };
+                return {
+                    isError: false,
+                    value: {
+                        logs: ['Host task operation. No program was evaluated.'],
+                        result,
+                    },
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                };
             }
             const proof = this.#executions.get(execution);
             if (!proof)
                 return next(); // Existing independently admitted runs keep their original path.
             const state = this.bound(execution);
-            if (!state || proof.turn !== state || this.definition(execution)?.execute !== proof.execute)
+            if (!state ||
+                proof.turn !== state ||
+                this.definition(execution)?.execute !== proof.execute)
                 throw new Error('On-demand dispatch identity changed');
             this.assertCurrent(state);
-            execution.signal = AbortSignal.any([execution.signal, state.input.signal, this.#lifecycle.signal]);
+            execution.signal = AbortSignal.any([
+                execution.signal,
+                state.input.signal,
+                this.#lifecycle.signal,
+            ]);
             if (proof.nativeCommandDigest !== undefined) {
                 if (!this.nativeCommand(execution))
                     throw new Error('Native command identity or arguments changed');
@@ -1086,13 +1804,17 @@ export class OnDemandIntake {
                 return withRootLispAdmission(execution, () => this.nativeLisp(execution), next);
             }
             if (proof.evidenceReadDigest !== undefined) {
-                if (state.status !== 'answer' || execution.parent !== undefined || !NATIVE_EVIDENCE_READS.has(execution.name)
-                    || canonicalContentHash(execution.arguments) !== proof.evidenceReadDigest)
+                if (state.status !== 'answer' ||
+                    execution.parent !== undefined ||
+                    !NATIVE_EVIDENCE_READS.has(execution.name) ||
+                    canonicalContentHash(execution.arguments) !==
+                        proof.evidenceReadDigest)
                     throw new Error('Native evidence read identity or arguments changed');
                 return next();
             }
             if (proof.nativeUnownedDigest !== undefined) {
-                if (!this.unownedNative(execution) || await this.host.nativeOwnership?.(state.input) !== 'unowned') {
+                if (!this.unownedNative(execution) ||
+                    (await this.host.nativeOwnership?.(state.input)) !== 'unowned') {
                     state.nativeUnowned = false;
                     throw new Error('Native unowned authority changed or became unavailable');
                 }
@@ -1102,21 +1824,26 @@ export class OnDemandIntake {
             if (!proof.carrier)
                 return next();
             const carrier = preparationCarrier(execution.arguments);
-            if (!(state.status === 'answer' || state.status === 'prepared' && this.host.ready(state.input.agent, state.input.turn)) || state.preparationCalls.has(execution.callId)
-                || !carrier || canonicalContentHash(carrier) !== proof.carrierDigest)
+            if (!(state.status === 'answer' ||
+                (state.status === 'prepared' &&
+                    this.host.ready(state.input.agent, state.input.turn))) ||
+                state.preparationCalls.has(execution.callId) ||
+                !carrier ||
+                canonicalContentHash(carrier) !== proof.carrierDigest)
                 throw new Error('Preparation carrier was already consumed or changed');
             state.preparationCalls.add(execution.callId);
             try {
-                const requestIntent = this.bindIntent(state, carrier.requestIntent);
+                const requestIntent = await this.bindIntent(state, carrier.requestIntent);
                 const clarification = executionClarification(state.task, requestIntent, state.requestIntentContext);
                 if (clarification)
                     throw new RequestClarification(clarification);
-                const unresolved = requestIntent !== undefined && requestIntentIsUnresolved(requestIntent);
-                const legacyTaskTypeAllowed = carrier.taskType !== undefined && !state.requestIntentContext?.activeGoal && !state.requestIntentContext?.activeTask
-                    && (state.requestIntentContext?.proposals.length ?? 0) === 0;
-                if (unresolved && !legacyTaskTypeAllowed)
+                const unresolved = requestIntent !== undefined &&
+                    requestIntentIsUnresolved(requestIntent);
+                if (unresolved)
                     throw new RequestClarification('Clarify the requested action and scope before preparing work');
-                const intentType = unresolved ? undefined : requestIntentTaskType(requestIntent, state.taskType ?? state.intent.taskType ?? carrier.taskType);
+                const intentType = unresolved
+                    ? undefined
+                    : requestIntentTaskType(requestIntent, state.taskType ?? state.intent.taskType ?? carrier.taskType);
                 const taskType = intentType ?? carrier.taskType;
                 if (carrier.taskType !== undefined && taskType !== carrier.taskType)
                     throw new Error('The advisory taskType conflicts with the bound request action');
@@ -1125,20 +1852,50 @@ export class OnDemandIntake {
                 }
                 state.memoryOwner = memoryOwnerKind(requestIntent, taskType);
                 await this.prepare(state, taskType, execution.signal, requestIntent, carrier.requestIntent !== undefined);
-                const result = { prepared: true, taskType: state.taskType, originalTask: state.task,
-                    ...(state.requestIntent ? { requestIntent: state.requestIntent } : {}),
-                    ...(state.requestIntent && requestIntentIsUnresolved(state.requestIntent) ? { requestInterpretation: requestInterpretationRecovery(state.requestIntent, state.requestIntentContext, true) } : {}),
-                    memoryOwner: state.memoryOwner, permissions: 'unchanged_native_policy', programExecuted: false };
-                return { isError: false, value: { logs: ['Host intake prepared. No program was evaluated.'], result }, content: [{ type: 'text', text: JSON.stringify(result) }] };
+                const result = {
+                    prepared: true,
+                    taskType: state.taskType,
+                    originalTask: state.task,
+                    ...(state.requestIntent
+                        ? { requestIntent: state.requestIntent }
+                        : {}),
+                    ...(state.requestIntent &&
+                        requestIntentIsUnresolved(state.requestIntent)
+                        ? {
+                            requestInterpretation: requestInterpretationRecovery(state.requestIntent, state.requestIntentContext, true),
+                        }
+                        : {}),
+                    memoryOwner: state.memoryOwner,
+                    permissions: 'unchanged_native_policy',
+                    programExecuted: false,
+                };
+                return {
+                    isError: false,
+                    value: {
+                        logs: ['Host intake prepared. No program was evaluated.'],
+                        result,
+                    },
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                };
             }
             catch (error) {
                 if (!(error instanceof RequestClarification))
                     throw error;
-                const result = { ...await this.clarify(state, execution.signal, error), programExecuted: false };
-                return { isError: false, value: { logs: ['Execution was not prepared. No program was evaluated.'], result }, content: [{ type: 'text', text: JSON.stringify(result) }] };
+                const result = {
+                    ...(await this.clarify(state, execution.signal, error)),
+                    programExecuted: false,
+                };
+                return {
+                    isError: false,
+                    value: {
+                        logs: ['Execution was not prepared. No program was evaluated.'],
+                        result,
+                    },
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                };
             }
         }, { prepend: true }));
-        this.#disposers.push(tools.guard(execution => {
+        this.#disposers.push(tools.guard((execution) => {
             if (this.#stopped || execution.signal.aborted)
                 return 'On-demand intake is stopped or cancelled';
             if (execution.agent && this.host.nativeChild?.(execution.agent))
@@ -1149,39 +1906,75 @@ export class OnDemandIntake {
             if (!actual)
                 return 'Unknown native tool definition';
             if (!state) {
-                if (execution.agent?.session && this.#turns.has(execution.agent.session.id))
+                if (execution.agent?.session &&
+                    this.#turns.has(execution.agent.session.id))
                     return 'Stale on-demand native turn';
                 const turn = this.existingTurn(execution);
-                return execution.agent && turn !== undefined && this.host.ready(execution.agent, turn) ? undefined : 'No current native request for tool execution';
+                return execution.agent &&
+                    turn !== undefined &&
+                    this.host.ready(execution.agent, turn)
+                    ? undefined
+                    : 'No current native request for tool execution';
             }
             const proof = this.#executions.get(execution);
-            if (!proof || proof.turn !== state || proof.execute !== actual.execute || ['closed', 'stale', 'capturing'].includes(state.status))
+            if (!proof ||
+                proof.turn !== state ||
+                proof.execute !== actual.execute ||
+                ['closed', 'stale', 'capturing'].includes(state.status))
                 return 'Tool execution has no current on-demand preparation';
             if (proof.nativeCommandDigest !== undefined)
-                return this.nativeCommand(execution) ? undefined : 'Native command identity or arguments changed';
+                return this.nativeCommand(execution)
+                    ? undefined
+                    : 'Native command identity or arguments changed';
             if (proof.nativeLispDigest !== undefined)
-                return this.nativeLisp(execution) ? undefined : 'Native Lisp identity or arguments changed';
+                return this.nativeLisp(execution)
+                    ? undefined
+                    : 'Native Lisp identity or arguments changed';
             if (proof.evidenceReadDigest !== undefined)
-                return state.status === 'answer' && execution.parent === undefined
-                    && NATIVE_EVIDENCE_READS.has(execution.name) && canonicalContentHash(execution.arguments) === proof.evidenceReadDigest
-                    ? undefined : 'Native evidence read identity or arguments changed';
+                return state.status === 'answer' &&
+                    execution.parent === undefined &&
+                    NATIVE_EVIDENCE_READS.has(execution.name) &&
+                    canonicalContentHash(execution.arguments) ===
+                        proof.evidenceReadDigest
+                    ? undefined
+                    : 'Native evidence read identity or arguments changed';
             if (proof.nativeUnownedDigest !== undefined)
-                return this.unownedNative(execution) ? undefined : 'Native unowned execution proof changed';
+                return this.unownedNative(execution)
+                    ? undefined
+                    : 'Native unowned execution proof changed';
             if (proof.carrier)
-                return (state.status === 'answer' || state.status === 'prepared' && this.host.ready(state.input.agent, state.input.turn))
-                    && canonicalContentHash(preparationCarrier(execution.arguments) ?? null) === proof.carrierDigest ? undefined : 'Preparation carrier is not current';
+                return (state.status === 'answer' ||
+                    (state.status === 'prepared' &&
+                        this.host.ready(state.input.agent, state.input.turn))) &&
+                    canonicalContentHash(preparationCarrier(execution.arguments) ?? null) === proof.carrierDigest
+                    ? undefined
+                    : 'Preparation carrier is not current';
             if (proof.skillRead)
-                return state.status === 'answer' && actual.execute === this.#skillReaders.get(state.input.agent) ? undefined : 'Conversational Skill read is not current';
+                return state.status === 'answer' &&
+                    actual.execute === this.#skillReaders.get(state.input.agent)
+                    ? undefined
+                    : 'Conversational Skill read is not current';
             if (execution.name === TASK_PREPARE_TOOL)
-                return actual.execute === definition.execute && (state.status === 'answer' || state.status === 'prepared' && this.host.ready(state.input.agent, state.input.turn)) ? undefined : 'Task preparation is not current';
-            return state.status === 'prepared' && this.host.ready(state.input.agent, state.input.turn) ? undefined : 'Execution task is not prepared';
+                return actual.execute === definition.execute &&
+                    (state.status === 'answer' ||
+                        (state.status === 'prepared' &&
+                            this.host.ready(state.input.agent, state.input.turn)))
+                    ? undefined
+                    : 'Task preparation is not current';
+            return state.status === 'prepared' &&
+                this.host.ready(state.input.agent, state.input.turn)
+                ? undefined
+                : 'Execution task is not prepared';
         }));
     }
     answerOwner(session) {
         if (this.#stopped)
             return undefined;
         const state = this.#turns.get(session.id);
-        if (!state || state.status !== 'answer' || state.input.agent.session !== session || state.memoryOwner !== 'conversation')
+        if (!state ||
+            state.status !== 'answer' ||
+            state.input.agent.session !== session ||
+            state.memoryOwner !== 'conversation')
             return undefined;
         const owner = this.host.answerContext?.owner(session, this.ownerIdentity(state));
         return state.input.agent === owner?.agent ? owner : undefined;
@@ -1189,17 +1982,28 @@ export class OnDemandIntake {
     retire(agent) {
         this.host.answerContext?.retire(agent);
         const state = agent.session && this.#turns.get(agent.session.id);
-        if (state?.input.agent !== agent || state.input.agent.session !== agent.session)
+        if (state?.input.agent !== agent ||
+            state.input.agent.session !== agent.session)
             return;
         state.controller.abort(new Error('Native agent disposed'));
         state.status = 'closed';
         this.#turns.delete(agent.session.id);
         this.#clarifications.delete(agent.session.id);
     }
-    stop() { this.#clarifications.clear(); this.#stopped = true; this.#lifecycle.abort(new Error('On-demand intake stopped')); }
-    async drain() { while (this.#pending.size)
-        await Promise.allSettled([...this.#pending]); }
-    async dispose() { this.stop(); await this.drain(); for (const dispose of this.#disposers.reverse())
-        dispose(); }
+    stop() {
+        this.#clarifications.clear();
+        this.#stopped = true;
+        this.#lifecycle.abort(new Error('On-demand intake stopped'));
+    }
+    async drain() {
+        while (this.#pending.size)
+            await Promise.allSettled([...this.#pending]);
+    }
+    async dispose() {
+        this.stop();
+        await this.drain();
+        for (const dispose of this.#disposers.reverse())
+            dispose();
+    }
 }
 //# sourceMappingURL=on-demand-intake.js.map