kiokuko-dsh 0.2.38 → 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 });
                 }
@@ -400,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();
@@ -495,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),
@@ -538,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) {
@@ -555,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 {
@@ -787,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' ||
@@ -802,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();
@@ -818,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);
@@ -909,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;
         })();
@@ -996,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)
@@ -1041,34 +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) {
-            const assessment = state.assessment.result;
-            const issues = assessment.semanticIssues ?? [];
-            const unresolved = assessment.semanticChecks?.filter(check => issues.includes(check.criterion)) ?? [];
-            const providerUncertain = issues.length > 0 && unresolved.length === issues.length && unresolved.every(check => check.status === 'abstained' && (check.reason === 'uncertain' || check.reason === 'tie'));
-            return {
-                prepared: false,
-                status: 'assessment_rejected',
-                semantic: state.assessment.result.semantic,
-                semanticIssues: state.assessment.result.semanticIssues ?? [],
-                semanticChecks: assessment.semanticChecks ?? [],
-                originalTask: state.task,
-                requestIntent: reason.candidate,
-                currentReferences: context
-                    ? requestIntentRequiredReferenceIds(context)
-                    : [],
-                availableReferences: context ? requestIntentReferenceIds(context) : [],
-                permissions: 'unchanged_native_policy',
-                nextAction: providerUncertain ? 'report_assessment_uncertainty' : 'revise_request_intent_or_report_conflict',
-                detail: providerUncertain
-                    ? 'The independent provider abstained because of confidence or tied choices. This does not establish ambiguity in the user request or an incorrect candidate. Preserve the request and candidate and report the unresolved provider assessment. Do not resubmit an identical candidate, change its meaning merely to obtain acceptance, ask the human for internal classification fields, or bypass preparation. No work is prepared.'
-                    : '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) => ({
@@ -1156,6 +1187,7 @@ export class OnDemandIntake {
             result: result,
             operation: undefined,
         };
+        state.clarificationPending = true;
         this.#clarifications.set(sessionId, pending);
         await this.diagnose(state, {
             kind: 'question',
@@ -1179,7 +1211,7 @@ export class OnDemandIntake {
                         {
                             id,
                             question,
-                            ...(scope && !target && !transition
+                            ...(confirmCurrent ? { options: [{ label: confirmLabel }, { label: '対象または操作を訂正する' }] } : scope && !target && !transition
                                 ? {
                                     options: [
                                         { label: '文章のみ' },
@@ -1223,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({
@@ -1251,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,
@@ -1357,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;
     }
@@ -1533,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 &&
@@ -1543,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 &&
@@ -1576,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);
@@ -1587,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;
@@ -1861,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))