kiokuko-dsh 0.2.37 → 0.2.39

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

@@ -17,6 +17,7 @@ import { KIOKUKO_DSH_SOURCE_KIND, isKiokukoDshSource } 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 { assessmentAllowsPreparation, mayConfirmRequestInterpretation } from './decisions/intent-assessment.js';
 class RequestClarification extends Error {
     assessment;
     interpretation;
@@ -195,6 +196,7 @@ export class OnDemandIntake {
         }
     }
     #turns = new Map();
+    #nativeConfirmations = new WeakMap();
     #clarificationContexts = new WeakMap();
     #clarifications = new Map();
     #executions = new WeakMap();
@@ -249,20 +251,20 @@ export class OnDemandIntake {
         let verified;
         state.auxiliaryReceipt = await this.host.recovery?.defer({ source: { sessionId: state.input.agent.session.id, turn: state.input.turn,
                 origin: 'intent-assessment', sourceDigest: canonicalContentHash(state.task), contextDigest: digest },
-            current: () => this.recoveryCurrent(state) && state.assessment?.digest === digest && canonicalContentHash([state.requestIntentContext, decision]) === digest,
+            current: () => this.recoveryCurrent(state) && !this.#clarifications.has(state.session.id) && state.assessment?.digest === digest && canonicalContentHash([state.requestIntentContext, decision]) === digest,
             check: async (signal, attempt) => {
                 await this.host.validate({ ...state.input, signal });
-                const result = await this.host.assess?.({ ...state.input, signal }, context, decision, attempt);
+                const result = await this.host.assess?.({ ...state.input, signal }, context, decision, attempt, this.hasNativeConfirmation(state, context, decision));
                 signal.throwIfAborted();
                 if (!result)
                     return { state: 'rejected', reason: 'assessment_disabled' };
-                if (result.outcome === 'consistent') {
+                if (assessmentAllowsPreparation(result)) {
                     verified = result;
-                    return { state: 'verified', reason: 'semantic_rechecked' };
+                    return { state: 'verified', reason: result.outcome === 'user_confirmed' ? 'native_user_confirmation_accepted' : 'semantic_rechecked' };
                 }
                 return { state: result.semantic === 'contradicted' ? 'rejected' : 'retry_wait', reason: result.semantic === 'contradicted' ? 'semantic_contradicted' : 'assessment_unresolved' };
             }, verified: async () => {
-                if (verified && this.recoveryCurrent(state) && state.assessment?.digest === digest && canonicalContentHash([state.requestIntentContext, decision]) === digest) {
+                if (verified && this.recoveryCurrent(state) && !this.#clarifications.has(state.session.id) && state.assessment?.digest === digest && canonicalContentHash([state.requestIntentContext, decision]) === digest) {
                     state.assessment = { digest, result: verified };
                     await this.diagnose(state, { kind: 'assessment', assessment: verified });
                 }
@@ -357,6 +359,11 @@ export class OnDemandIntake {
         void promise.then(() => this.#pending.delete(promise), () => this.#pending.delete(promise));
         return promise;
     }
+    /** True only while the previous turn has no matching turn/end in the session log. */
+    turnIsOpen(state) {
+        const events = state.input.agent.session?.snapshotEvents?.() ?? [];
+        return !events.some((event) => event.type === 'turn/end' && eventTurn(event) === state.input.turn);
+    }
     existingTurn(execution) {
         const last = execution.agent?.session
             ?.snapshotEvents?.()
@@ -395,7 +402,7 @@ export class OnDemandIntake {
             messageRefs: requestIntentMessageRefs(input.messages, task),
         });
         try {
-            await this.host.prepareNativeCoding(input, task, context);
+            await this.host.prepareNativeCoding(input, task, context, this.nativeContinuation(input));
         }
         catch (error) {
             input.signal.throwIfAborted();
@@ -463,8 +470,12 @@ export class OnDemandIntake {
                     return false;
                 }
             }
+            // A superseded capture is only a live turn while its own boundary stays open.
+            // Once turn/end exists for it, the host has finished that turn; its failure
+            // must not refuse every later human request for the rest of the session.
             if (previous.input.turn !== input.turn &&
-                !['closed', 'prepared'].includes(previous.status))
+                !['closed', 'prepared'].includes(previous.status) &&
+                this.turnIsOpen(previous))
                 throw new Error('Previous on-demand turn has not ended');
             previous.controller.abort(new Error('A newer native turn superseded this request'));
         }
@@ -486,6 +497,8 @@ export class OnDemandIntake {
                 messages: Object.freeze(structuredClone([...input.messages])),
             },
             task: humanTask(input.messages),
+            ...(this.isClarificationContinuation(input)
+                ? { clarificationPending: true } : {}),
             humanContents: new Map(humanMessages(input.messages).map((message) => [
                 humanId(message),
                 canonicalContentHash(message),
@@ -529,7 +542,7 @@ export class OnDemandIntake {
                         messageRefs: requestIntentMessageRefs(state.input.messages, state.task),
                     });
                 this.assertCurrent(state);
-                await this.host.prepareNativeCoding?.(state.input, state.task, context);
+                await this.host.prepareNativeCoding?.(state.input, state.task, context, this.nativeContinuation(state.input));
                 this.assertCurrent(state);
                 state.nativeUnowned = true;
                 if (context) {
@@ -546,7 +559,7 @@ export class OnDemandIntake {
                 const context = await this.host.requestContext?.(state.input, state.task)
                     ?? createRequestIntentContext({ task: state.task, messageRefs: requestIntentMessageRefs(state.input.messages, state.task) });
                 this.assertCurrent(state);
-                await this.host.prepareNativeCoding(state.input, state.task, context);
+                await this.host.prepareNativeCoding(state.input, state.task, context, this.nativeContinuation(state.input));
                 this.assertCurrent(state);
             }
             try {
@@ -778,6 +791,55 @@ export class OnDemandIntake {
             current,
         });
     }
+    isClarificationContinuation(input) {
+        const messages = humanMessages(input.messages), known = this.#clarificationContexts.get(input.agent);
+        if (!known)
+            return false;
+        const sources = collectClarificationContext(messages.map(message => ({ id: humanId(message), text: humanTask([message]) })), known).sources;
+        return messages.some(message => {
+            const reply = known.get(humanId(message));
+            return reply && canonicalContentHash(reply.sources) === canonicalContentHash(sources);
+        });
+    }
+    /** Startup preferences are reused only from this exact native confirmation,
+     * never by matching a model-written "continue" or quoted answer. */
+    nativeContinuation(input) {
+        const messages = humanMessages(input.messages);
+        const clarification = collectClarificationContext(messages.map(message => ({ id: humanId(message), text: humanTask([message]) })), this.#clarificationContexts.get(input.agent) ?? new Map());
+        for (const message of messages) {
+            const receipt = this.#nativeConfirmations.get(input.agent)?.get(humanId(message));
+            if (receipt && receipt.session === input.agent.session && receipt.originalTurn < input.turn &&
+                receipt.contentDigest === canonicalContentHash(humanTask([message])) &&
+                receipt.sourcesDigest === canonicalContentHash(clarification.sources))
+                return { turn: receipt.originalTurn, task: receipt.originalTask };
+        }
+        return undefined;
+    }
+    confirmationScope(context) {
+        // Eligible confirmations adopt no proposals. Fresh unselected assistant
+        // prose must not invalidate the human answer; selected refs are bound in
+        // confirmationCandidate and still cannot enter this path.
+        return canonicalContentHash({ activeTask: context.activeTask ?? null,
+            activeGoal: context.activeGoal ?? null });
+    }
+    confirmationCandidate(candidate) {
+        return canonicalContentHash([candidate.relation, candidate.action, candidate.changeScope,
+            candidate.taskOperation ?? null, candidate.evidence.proposalRefs]);
+    }
+    hasNativeConfirmation(state, context, candidate) {
+        if (!mayConfirmRequestInterpretation(candidate))
+            return false;
+        const messages = humanMessages(state.input.messages);
+        const clarification = collectClarificationContext(messages.map(message => ({ id: humanId(message), text: humanTask([message]) })), this.#clarificationContexts.get(state.input.agent) ?? new Map());
+        return messages.some(message => {
+            const receipt = this.#nativeConfirmations.get(state.input.agent)?.get(humanId(message));
+            return !!receipt && receipt.session === state.input.agent.session &&
+                receipt.contentDigest === canonicalContentHash(humanTask([message])) &&
+                receipt.sourcesDigest === canonicalContentHash(clarification.sources) &&
+                receipt.scopeDigest === this.confirmationScope(context) &&
+                receipt.candidateDigest === this.confirmationCandidate(candidate);
+        });
+    }
     async assess(state, decision) {
         if (!this.host.assess ||
             decision?.action === 'answer' ||
@@ -793,7 +855,7 @@ export class OnDemandIntake {
             const started = performance.now(), deadline = AbortSignal.timeout(1500);
             const signal = AbortSignal.any([state.input.signal, deadline]);
             try {
-                result = await abortable(this.host.assess({ ...state.input, signal }, context, decision), signal);
+                result = await abortable(this.host.assess({ ...state.input, signal }, context, decision, undefined, this.hasNativeConfirmation(state, context, decision)), signal);
             }
             catch {
                 state.input.signal.throwIfAborted();
@@ -809,10 +871,10 @@ export class OnDemandIntake {
                 throw new Error('Assessment source changed');
             state.assessment = { digest, result };
             await this.diagnose(state, { kind: 'assessment', assessment: result });
-            if (result.outcome !== 'consistent')
+            if (!assessmentAllowsPreparation(result))
                 await this.deferAssessment(state, context, decision, digest);
         }
-        return state.assessment.result.outcome === 'consistent';
+        return assessmentAllowsPreparation(state.assessment.result);
     }
     async prepare(state, taskType, signal, requestIntent, explicitIntent = false) {
         this.assertCurrent(state);
@@ -900,6 +962,7 @@ export class OnDemandIntake {
                 requestIntent: state.requestIntent ?? null,
             });
             state.status = 'prepared';
+            delete state.clarificationPending;
             this.#clarifications.delete(state.input.agent.session.id);
             delete state.confirmationResume;
         })();
@@ -987,17 +1050,22 @@ export class OnDemandIntake {
             reason.message.startsWith('The requested change scope');
         const target = !!executionClarification(state.task, decision, context);
         const transition = context?.activeTask && !taskCanExecute(context.activeTask);
-        const question = reason.assessment
-            ? '現在の依頼と実行候補の対象・操作・制約を照合できませんでした。今回の対象と希望する操作、以前の指示を変更する範囲を教えてください。'
-            : transition
-                ? `現在のタスクは ${context.activeTask.state} です。続けるために、どの操作を希望しますか？（${taskAllowedOperations(context.activeTask).join(' / ')}）`
-                : target
-                    ? 'どの具体的なファイル・項目・相手・操作を対象にしますか？'
-                    : scope
-                        ? '変更するのは文章だけですか、それともコード・テスト・設定も含みますか？'
-                        : decision?.action === 'unknown'
-                            ? 'その対象に、具体的に何をしてほしいですか？'
-                            : null;
+        const confirmCurrent = reason.assessment && state.assessment?.result.semantic === 'insufficient' &&
+            !!decision && mayConfirmRequestInterpretation(decision) && !(decision.relation === 'same_scope_continuation' && context?.proposals.length) && !target && !scope && !transition;
+        const confirmLabel = 'この依頼の対象・操作・制約のまま進める';
+        const question = confirmCurrent
+            ? `次の依頼について、対象と操作を判定しきれませんでした。\n\n${state.task}\n\n予定している操作: ${{ answer: '回答', research: '調査', verify: '検証', change: decision.changeScope === 'document' ? '文書の編集' : 'コード・テスト・設定の変更', operate: '操作', unknown: '未確定' }[decision.action]}。\nこの依頼に書かれた対象・操作・制約のまま進めてよいですか？違う場合は、具体的な対象と希望する操作を訂正してください。`
+            : reason.assessment
+                ? target ? '依頼の対象を特定できませんでした。変更・確認する具体的なファイルや項目と、希望する操作を教えてください。' : '依頼の対象・操作・制約を判定しきれませんでした。今回の具体的な対象と希望する操作、以前の指示を変更する範囲を教えてください。'
+                : transition
+                    ? `現在のタスクは ${context.activeTask.state} です。続けるために、どの操作を希望しますか？（${taskAllowedOperations(context.activeTask).join(' / ')}）`
+                    : target
+                        ? 'どの具体的なファイル・項目・相手・操作を対象にしますか？'
+                        : scope
+                            ? '変更するのは文章だけですか、それともコード・テスト・設定も含みますか？'
+                            : decision?.action === 'unknown'
+                                ? 'その対象に、具体的に何をしてほしいですか？'
+                                : null;
         // Internal relationship classification belongs to the model. An unresolved
         // classifier is not evidence that the human omitted an action or target.
         if (reason.interpretation || question === null)
@@ -1020,6 +1088,7 @@ export class OnDemandIntake {
                 prepared: false,
                 status: 'assessment_unavailable',
                 semantic: a.semantic,
+                semanticChecks: a.semanticChecks ?? [],
                 detector: a.detector.state === 'unavailable'
                     ? a.detector.reason
                     : a.detector.result.status,
@@ -1031,27 +1100,6 @@ export class OnDemandIntake {
                 detail: '原文照合または有限領域検査を利用できません。実行は準備されていません。',
             };
         }
-        // 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 replies = this.#clarificationContexts.get(state.input.agent) ??
             new Map();
         const clarification = collectClarificationContext(humanMessages(state.input.messages).map((message) => ({
@@ -1072,6 +1120,7 @@ export class OnDemandIntake {
                 status: 'assessment_rejected',
                 semantic: state.assessment?.result.semantic,
                 semanticIssues: state.assessment?.result.semanticIssues ?? [],
+                semanticChecks: state.assessment?.result.semanticChecks ?? [],
                 detector: state.assessment?.result.detector.state === 'available'
                     ? state.assessment.result.detector.result.status
                     : state.assessment?.result.detector.reason,
@@ -1124,6 +1173,7 @@ export class OnDemandIntake {
                 ? {
                     semantic: state.assessment?.result.semantic,
                     semanticIssues: state.assessment?.result.semanticIssues ?? [],
+                    semanticChecks: state.assessment?.result.semanticChecks ?? [],
                 }
                 : {}),
             permissions: 'unchanged_native_policy',
@@ -1137,6 +1187,7 @@ export class OnDemandIntake {
             result: result,
             operation: undefined,
         };
+        state.clarificationPending = true;
         this.#clarifications.set(sessionId, pending);
         await this.diagnose(state, {
             kind: 'question',
@@ -1160,7 +1211,7 @@ export class OnDemandIntake {
                         {
                             id,
                             question,
-                            ...(scope && !target && !transition
+                            ...(confirmCurrent ? { options: [{ label: confirmLabel }, { label: '対象または操作を訂正する' }] } : scope && !target && !transition
                                 ? {
                                     options: [
                                         { label: '文章のみ' },
@@ -1204,24 +1255,62 @@ export class OnDemandIntake {
                     };
                     return pending.result;
                 }
-                const answer = response.answers[0];
+                let answer = response.answers[0];
+                let answerQuestionId = id, answerQuestion = question;
+                if (confirmCurrent && answer?.id === id && !answer.custom?.trim() &&
+                    answer.selected.length === 1 && answer.selected[0] === '対象または操作を訂正する') {
+                    answerQuestionId = `${id}-correction`;
+                    answerQuestion = `次の依頼について、訂正後の具体的な対象（ファイル・項目など）と希望する操作を入力してください。変更しない範囲もあれば含めてください。\n\n${state.task}`;
+                    await this.diagnose(state, { kind: 'question', questionRef: answerQuestionId, reason: 'clarification_required' });
+                    const corrected = await abortable(this.host.questions.ask({ agent: state.input.agent, signal,
+                        questions: [{ id: answerQuestionId, question: answerQuestion }] }), signal);
+                    signal.throwIfAborted();
+                    this.assertCurrent(state);
+                    if (this.#clarifications.get(sessionId) !== pending || pending.status !== 'waiting')
+                        return result;
+                    await this.host.validate(state.input);
+                    const afterCorrection = 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 && (!afterCorrection || canonicalContentHash(afterCorrection) !== canonicalContentHash(context))) {
+                        if (afterCorrection) {
+                            state.requestIntentContext = afterCorrection;
+                            state.requestIntent = unresolvedRequestIntent(afterCorrection, 'clarification_context_changed');
+                            state.requestIntentContextDigest = canonicalContentHash(afterCorrection);
+                        }
+                        pending.result = { ...result, status: 'clarification_context_changed',
+                            detail: 'The source changed while awaiting the correction. No answer was queued; refresh the current request.' };
+                        return pending.result;
+                    }
+                    answer = corrected.answers[0];
+                }
                 const value = answer?.custom?.trim() || answer?.selected[0]?.trim();
-                if (answer?.id !== id || !value || value.length > 8192)
+                if (answer?.id !== answerQuestionId || !value || value.length > 8192)
                     return result;
-                // Preserve actual native sources and answers once; never recursively quote an earlier generated envelope.
-                // label the actual UI answer separately, and re-enter ordinary native
-                // capture. The reply itself is never mapped to execution authority.
+                // Preserve native sources and answers once, then recapture the reply.
+                // Only the exact affirmative selection below creates a scoped receipt;
+                // a free-text correction is fresh user evidence, never an admission.
                 const answerMessageId = randomUUID();
                 const reply = clarificationReply(clarification, {
                     id: answerMessageId,
-                    questionId: id,
-                    question,
+                    questionId: answerQuestionId,
+                    question: answerQuestion,
                     value,
                     scope: answerScope,
                 });
                 const content = reply.content;
                 signal.throwIfAborted();
                 this.assertCurrent(state);
+                if (confirmCurrent && answerQuestionId === id && decision && context && !answer.custom?.trim() &&
+                    answer.selected.length === 1 && answer.selected[0] === confirmLabel) {
+                    const receipts = this.#nativeConfirmations.get(state.input.agent) ?? new Map();
+                    receipts.set(answerMessageId, { session: state.input.agent.session, originalTurn: state.input.turn, originalTask: state.task,
+                        contentDigest: canonicalContentHash(content), sourcesDigest: canonicalContentHash(clarification.sources),
+                        scopeDigest: this.confirmationScope(context), candidateDigest: this.confirmationCandidate(decision) });
+                    this.#nativeConfirmations.set(state.input.agent, receipts);
+                }
                 replies.set(answerMessageId, reply.context);
                 this.#clarificationContexts.set(state.input.agent, replies);
                 state.input.agent.followup({
@@ -1232,12 +1321,14 @@ export class OnDemandIntake {
                 });
                 await this.diagnose(state, {
                     kind: 'answer',
-                    questionRef: id,
+                    questionRef: answerQuestionId,
                     answerRef: answerMessageId,
                 });
                 pending.status = 'queued';
                 pending.result = {
                     ...result,
+                    questionId: answerQuestionId,
+                    question: answerQuestion,
                     status: 'clarification_answer_queued',
                     answer: value,
                     answerRef: answerMessageId,
@@ -1338,7 +1429,10 @@ export class OnDemandIntake {
             if (prior.relation !== bound.relation || prior.action !== bound.action) {
                 throw new Error('Main-model interpretation conflicts with the configured decision provider');
             }
-            return { ...prior, evidence: bound.evidence };
+            // The explicit submission is a current main-model interpretation, even
+            // when its classification agrees with earlier provider extraction.
+            // Preserve the explicit submission's provenance; this is not user confirmation.
+            return bound;
         }
         return bound;
     }
@@ -1514,6 +1608,7 @@ export class OnDemandIntake {
         return (!this.#stopped &&
             !execution.signal.aborted &&
             UNOWNED_NATIVE_TOOLS.has(execution.name) &&
+            (!state?.clarificationPending || NATIVE_EVIDENCE_READS.has(execution.name) || execution.name === 'skill') &&
             execution.parent === undefined &&
             !!state &&
             state.nativeUnowned === true &&
@@ -1524,9 +1619,11 @@ export class OnDemandIntake {
             proof.execute === this.definition(execution)?.execute &&
             proof.nativeUnownedDigest === canonicalContentHash(execution.arguments));
     }
-    /** Direct native Bash follows native permissions, independently of optional task intake. */
+    /** Ordinary native Bash follows native policy; an issued clarification cannot be bypassed by switching tools. */
     nativeCommand(execution) {
         const state = this.bound(execution), actual = this.definition(execution), proof = this.#executions.get(execution);
+        if (state?.clarificationPending)
+            return false;
         if (!this.options.onlyWhenDeferred &&
             !this.#stopped &&
             actual &&
@@ -1557,6 +1654,15 @@ export class OnDemandIntake {
                 proof.execute === actual.execute &&
                 proof.nativeCommandDigest === canonicalContentHash(execution.arguments)));
     }
+    /** Known observational/cancellation Lisp contracts stay usable while waiting.
+     * Live evaluation is effect-capable; do not inspect or guess its code string. */
+    pendingLispEffect(execution) {
+        if (['lisp_status', 'lisp_hot_status', 'lisp_cancel'].includes(execution.name))
+            return false;
+        const args = execution.arguments;
+        return !(execution.name === 'lisp_inspect' && execution.parent === undefined &&
+            typeof args?.resultOperationId === 'string' && args.ref === undefined);
+    }
     /** 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);
@@ -1568,6 +1674,7 @@ export class OnDemandIntake {
             state.status !== 'answer' ||
             state.input.signal.aborted ||
             !actual ||
+            (state.clarificationPending && this.pendingLispEffect(execution)) ||
             !isLispImplementation(actual.execute) ||
             (execution.agent && this.host.nativeChild?.(execution.agent)))
             return false;
@@ -1842,6 +1949,11 @@ export class OnDemandIntake {
             }
             try {
                 this.assertCurrent(state);
+                if (state.clarificationPending && (execution.name === 'bash' || isLispNativeCommand(execution, actual.execute) ||
+                    (isLispImplementation(actual.execute) && this.pendingLispEffect(execution)) ||
+                    (state.nativeUnowned && UNOWNED_NATIVE_TOOLS.has(execution.name) &&
+                        !NATIVE_EVIDENCE_READS.has(execution.name) && execution.name !== 'skill')))
+                    return denied('The current request is awaiting clarification. Native commands cannot bypass that question; resolve it and prepare the exact request first.');
                 if (state.confirmationResume &&
                     execution.name !== TASK_PREPARE_TOOL &&
                     this.host.ready(state.input.agent, state.input.turn))