kiokuko-dsh 0.2.28 → 0.2.30

package/dist/dsh/decisions/request-intent.js

@@ -1,24 +1,57 @@
 import { z } from 'zod';
 import { canonicalContentHash } from '../../serialization/validate.js';
 import { DecisionError } from './contracts.js';
-import { TaskSnapshotSchema, TASK_OPERATIONS, validateTaskOperation } from '../task-state.js';
-import { correlateRequestIntent, requestIntentDiagnosticId } from './diagnostic-correlation.js';
+import { TaskSnapshotSchema, TASK_OPERATIONS, validateTaskOperation, } from '../task-state.js';
+import { correlateRequestIntent, requestIntentDiagnosticId, } from './diagnostic-correlation.js';
 export const REQUEST_INTENT_POLICY_VERSION = 'request-intent-task-state-v3';
 export const MAX_REQUEST_INTENT_BYTES = 32 * 1024;
-export const RequestRelationship = z.enum(['new', 'same_scope_continuation', 'scope_change', 'unknown']);
-export const RequestAction = z.enum(['answer', 'research', 'verify', 'change', 'operate', 'unknown']);
-export const RequestChangeScope = z.enum(['implementation', 'document', 'unknown']);
-const safeId = z.string().min(1).max(256).refine(value => !/[\p{Cc}\p{Cf}]/u.test(value));
+export const RequestRelationship = z.enum([
+    'new',
+    'same_scope_continuation',
+    'scope_change',
+    'unknown',
+]);
+export const RequestAction = z.enum([
+    'answer',
+    'research',
+    'verify',
+    'change',
+    'operate',
+    'unknown',
+]);
+export const RequestChangeScope = z.enum([
+    'implementation',
+    'document',
+    'unknown',
+]);
+const safeId = z
+    .string()
+    .min(1)
+    .max(256)
+    .refine((value) => !/[\p{Cc}\p{Cf}]/u.test(value));
 const boundedText = z.string().min(1).max(8192);
-const messageReference = z.object({ id: safeId, digest: z.string().regex(/^[a-f0-9]{64}$/u) }).strict();
-const proposalReference = z.object({
+const messageReference = z
+    .object({ id: safeId, digest: z.string().regex(/^[a-f0-9]{64}$/u) })
+    .strict();
+const proposalReference = z
+    .object({
     id: safeId,
     revision: z.number().int().min(0).nullable(),
     digest: z.string().regex(/^[a-f0-9]{64}$/u),
     text: boundedText,
-    field: z.enum(['readPaths', 'writePaths', 'excludedPaths', 'constraints', 'completion']).optional(),
-}).strict();
-const activeGoal = z.object({
+    field: z
+        .enum([
+        'readPaths',
+        'writePaths',
+        'excludedPaths',
+        'constraints',
+        'completion',
+    ])
+        .optional(),
+})
+    .strict();
+const activeGoal = z
+    .object({
     runId: safeId,
     workflowRevision: z.number().int().min(1).optional(),
     goalId: safeId.optional(),
@@ -28,8 +61,10 @@ const activeGoal = z.object({
     target: boundedText.optional(),
     outOfScope: z.array(boundedText).max(32).default([]),
     constraints: z.array(boundedText).max(32).default([]),
-}).strict();
-export const RequestIntentContextSchema = z.object({
+})
+    .strict();
+export const RequestIntentContextSchema = z
+    .object({
     /** Exact current user request. No transcript or other session is accepted. */
     task: z.string().min(1).max(16_384),
     messageRefs: z.array(messageReference).min(1).max(16),
@@ -37,27 +72,48 @@ export const RequestIntentContextSchema = z.object({
     /** SQLite task identity and revision, independent of an implementation-only Goal. */
     activeTask: TaskSnapshotSchema.optional(),
     proposals: z.array(proposalReference).max(8).default([]),
-}).strict().superRefine((value, context) => {
-    if (new Set(value.messageRefs.map(item => item.id)).size !== value.messageRefs.length) {
-        context.addIssue({ code: 'custom', path: ['messageRefs'], message: 'Message references must be unique' });
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (new Set(value.messageRefs.map((item) => item.id)).size !==
+        value.messageRefs.length) {
+        context.addIssue({
+            code: 'custom',
+            path: ['messageRefs'],
+            message: 'Message references must be unique',
+        });
     }
-    if (new Set(value.proposals.map(item => item.id)).size !== value.proposals.length) {
-        context.addIssue({ code: 'custom', path: ['proposals'], message: 'Proposal references must be unique' });
+    if (new Set(value.proposals.map((item) => item.id)).size !==
+        value.proposals.length) {
+        context.addIssue({
+            code: 'custom',
+            path: ['proposals'],
+            message: 'Proposal references must be unique',
+        });
     }
-    if (Buffer.byteLength(JSON.stringify(value), 'utf8') > MAX_REQUEST_INTENT_BYTES) {
-        context.addIssue({ code: 'custom', message: 'Request intent context exceeds its byte limit' });
+    if (Buffer.byteLength(JSON.stringify(value), 'utf8') >
+        MAX_REQUEST_INTENT_BYTES) {
+        context.addIssue({
+            code: 'custom',
+            message: 'Request intent context exceeds its byte limit',
+        });
     }
 });
 export { requestIntentMessageRefs } from './message-refs.js';
 export function createRequestIntentContext(input) {
     // Request-scoped diagnostics are not new task authority and must not invalidate their own retry context.
     const { unresolved: _unresolved, ...activeTask } = input.activeTask ?? {};
-    const parsed = RequestIntentContextSchema.safeParse({ task: input.task, messageRefs: input.messageRefs,
+    const parsed = RequestIntentContextSchema.safeParse({
+        task: input.task,
+        messageRefs: input.messageRefs,
         ...(input.activeGoal === undefined ? {} : { activeGoal: input.activeGoal }),
-        ...(input.activeTask === undefined ? {} : { activeTask }), proposals: input.proposals ?? [] });
+        ...(input.activeTask === undefined ? {} : { activeTask }),
+        proposals: input.proposals ?? [],
+    });
     return parsed.success ? parsed.data : undefined;
 }
-export const RequestIntentSubmissionSchema = z.object({
+export const RequestIntentSubmissionSchema = z
+    .object({
     relation: RequestRelationship,
     action: RequestAction,
     /** Missing legacy values normalize to unknown and can never authorize a change. */
@@ -66,29 +122,74 @@ export const RequestIntentSubmissionSchema = z.object({
     taskOperation: z.enum(TASK_OPERATIONS).optional(),
     /** Exact opaque references supplied in the current host context. */
     evidenceRefs: z.array(safeId).min(1).max(32),
-}).strict().superRefine((value, context) => {
+})
+    .strict()
+    .superRefine((value, context) => {
     if (new Set(value.evidenceRefs).size !== value.evidenceRefs.length) {
-        context.addIssue({ code: 'custom', path: ['evidenceRefs'], message: 'Evidence references must be unique' });
+        context.addIssue({
+            code: 'custom',
+            path: ['evidenceRefs'],
+            message: 'Evidence references must be unique',
+        });
     }
 });
 const relationshipChoices = [
-    { id: 'new', description: 'A new task, not a continuation or revision of the active Goal or listed proposals.' },
-    { id: 'same_scope_continuation', description: 'Continue, inspect, verify, or finish the current source-bound conversation or active task without changing its target, exclusions, or requirements. A formal Goal is optional.' },
-    { id: 'scope_change', description: 'Change the active Goal, target, exclusions, requirements, or adopt proposals that expand or alter its scope.' },
-    { id: 'unknown', description: 'The current message does not establish its relationship to the active Goal or proposals.' },
+    {
+        id: 'new',
+        description: 'A new task, not a continuation or revision of the active Goal or listed proposals.',
+    },
+    {
+        id: 'same_scope_continuation',
+        description: 'Continue, inspect, verify, or finish the current source-bound conversation or active task without changing its target, exclusions, or requirements. A formal Goal is optional.',
+    },
+    {
+        id: 'scope_change',
+        description: 'Change the active Goal, target, exclusions, requirements, or adopt proposals that expand or alter its scope.',
+    },
+    {
+        id: 'unknown',
+        description: 'The current message does not establish its relationship to the active Goal or proposals.',
+    },
 ];
 const actionChoices = [
-    { id: 'answer', description: 'Answer, explain, or discuss; no tool-backed work is requested.' },
-    { id: 'research', description: 'Inspect sources or gather information without changing project state.' },
-    { id: 'verify', description: 'Inspect behavior, run or review checks, or establish whether something works.' },
-    { id: 'change', description: 'Modify code, files, configuration, or another project artifact.' },
-    { id: 'operate', description: 'Perform deployment, restart, installation, or other system/service operation.' },
-    { id: 'unknown', description: 'The requested action or target is ambiguous, or not supported by the current evidence. Multiple compatible requested actions alone are not ambiguity.' },
+    {
+        id: 'answer',
+        description: 'Answer, explain, or discuss; no tool-backed work is requested.',
+    },
+    {
+        id: 'research',
+        description: 'Inspect sources or gather information without changing project state.',
+    },
+    {
+        id: 'verify',
+        description: 'Inspect behavior, run or review checks, or establish whether something works.',
+    },
+    {
+        id: 'change',
+        description: 'Modify code, files, configuration, or another project artifact.',
+    },
+    {
+        id: 'operate',
+        description: 'Perform deployment, restart, installation, or other system/service operation.',
+    },
+    {
+        id: 'unknown',
+        description: 'The requested action or target is ambiguous, or not supported by the current evidence. Multiple compatible requested actions alone are not ambiguity.',
+    },
 ];
 const changeScopeChoices = [
-    { id: 'implementation', description: 'The requested artifact change affects code, tests, runtime behavior, or configuration behavior. If documentation is changed together with implementation, choose implementation.' },
-    { id: 'document', description: 'The requested change is prose-only documentation and does not change code, tests, or behavior configuration.' },
-    { id: 'unknown', description: 'The requested artifact scope cannot be determined from the current request and supplied Goal/proposal references.' },
+    {
+        id: 'implementation',
+        description: 'The requested artifact change affects code, tests, runtime behavior, or configuration behavior. If documentation is changed together with implementation, choose implementation.',
+    },
+    {
+        id: 'document',
+        description: 'The requested change is prose-only documentation and does not change code, tests, or behavior configuration.',
+    },
+    {
+        id: 'unknown',
+        description: 'The requested artifact scope cannot be determined from the current request and supplied Goal/proposal references.',
+    },
 ];
 /** Finite choices preserve both the action and the proposals it refers to. */
 export function buildRequestIntentBatch(raw) {
@@ -106,23 +207,71 @@ export function buildRequestIntentBatch(raw) {
             boundary: 'Use only this exact current request and the supplied active Goal/proposal candidates. Never use another chat, infer a free-text target, or grant execution permission.',
         },
         questions: [
-            { id: 'request-relation', instructions: 'Classify the relationship of the current user message to the supplied active Goal and proposals. Respect negation, quotation, actor, and omitted references. An exact continuation phrase is not required. If the intended reference or scope is not established, choose unknown.', choices: [...relationshipChoices], abstainId: 'unknown' },
-            { id: 'request-action', instructions: 'Classify the action the user requests now, not a quoted example or an action they forbid. “See whether it works” is verify/research, not a file edit. When explanation or inspection accompanies an explicit edit request, choose change and preserve every requested action and prohibition. Do not turn a verification-only request into an edit. Classification grants no permission. If the action or target is unclear, choose unknown.', choices: [...actionChoices], abstainId: 'unknown' },
-            { id: 'request-change-scope', instructions: 'For action=change, classify the exact current requested artifact scope using only the current message and supplied Goal/proposal references. Code, tests, runtime behavior, or behavior configuration is implementation; a request that mixes implementation with documentation is implementation. Prose-only document edits are document. Do not infer scope from an advisory task label, wording style, or whether the message happens to say “write”. For other actions choose unknown.', choices: [...changeScopeChoices], abstainId: 'unknown' },
-            ...(parsed.data.activeTask ? [{ id: 'request-task-operation', instructions: 'Propose only a structured state operation clearly requested by the current human message for the exact SQLite task. Do not mutate state, fabricate completion or stop evidence, or infer approval from a keyword. Choose none when no state transition is requested; choose unknown when ambiguous. Terminal resume requires an explicit user operation.',
-                    choices: [{ id: 'none', description: 'No task state operation is requested.' },
-                        ...parsed.data.activeTask.allowedOps.map(operation => ({ id: operation, description: `Propose ${operation} for this exact task revision; host validation and evidence still apply.` })),
-                        { id: 'unknown', description: 'The intended operation or target is uncertain.' }], abstainId: 'unknown' }] : []),
-            ...parsed.data.proposals.map((proposal, index) => ({ id: `request-proposal-${index}`,
+            {
+                id: 'request-relation',
+                instructions: 'Classify the relationship of the current user message to the supplied active Goal and proposals. Respect negation, quotation, actor, and omitted references. An exact continuation phrase is not required. If the intended reference or scope is not established, choose unknown.',
+                choices: [...relationshipChoices],
+                abstainId: 'unknown',
+            },
+            {
+                id: 'request-action',
+                instructions: 'Classify the action the user requests now, not a quoted example or an action they forbid. “See whether it works” is verify/research, not a file edit. When explanation or inspection accompanies an explicit edit request, choose change and preserve every requested action and prohibition. Do not turn a verification-only request into an edit. Classification grants no permission. If the action or target is unclear, choose unknown.',
+                choices: [...actionChoices],
+                abstainId: 'unknown',
+            },
+            {
+                id: 'request-change-scope',
+                instructions: 'For action=change, classify the exact current requested artifact scope using only the current message and supplied Goal/proposal references. Code, tests, runtime behavior, or behavior configuration is implementation; a request that mixes implementation with documentation is implementation. Prose-only document edits are document. Do not infer scope from an advisory task label, wording style, or whether the message happens to say “write”. For other actions choose unknown.',
+                choices: [...changeScopeChoices],
+                abstainId: 'unknown',
+            },
+            ...(parsed.data.activeTask
+                ? [
+                    {
+                        id: 'request-task-operation',
+                        instructions: 'Propose only a structured state operation clearly requested by the current human message for the exact SQLite task. Do not mutate state, fabricate completion or stop evidence, or infer approval from a keyword. Choose none when no state transition is requested; choose unknown when ambiguous. Terminal resume requires an explicit user operation.',
+                        choices: [
+                            {
+                                id: 'none',
+                                description: 'No task state operation is requested.',
+                            },
+                            ...parsed.data.activeTask.allowedOps.map((operation) => ({
+                                id: operation,
+                                description: `Propose ${operation} for this exact task revision; host validation and evidence still apply.`,
+                            })),
+                            {
+                                id: 'unknown',
+                                description: 'The intended operation or target is uncertain.',
+                            },
+                        ],
+                        abstainId: 'unknown',
+                    },
+                ]
+                : []),
+            ...parsed.data.proposals.map((proposal, index) => ({
+                id: `request-proposal-${index}`,
                 instructions: `Does the current user instruction adopt or refer to proposal ${JSON.stringify(proposal.id)}? Interpret omitted Japanese subjects and references such as 全部, それ, 続けて against the supplied context. Quoted or forbidden actions are not approvals.`,
-                choices: [{ id: 'selected', description: 'The current request refers to this proposal.' },
-                    { id: 'not_selected', description: 'This proposal is not referenced by the current request.' },
-                    { id: 'unknown', description: 'The reference cannot be resolved from the supplied context.' }], abstainId: 'unknown' })),
+                choices: [
+                    {
+                        id: 'selected',
+                        description: 'The current request refers to this proposal.',
+                    },
+                    {
+                        id: 'not_selected',
+                        description: 'This proposal is not referenced by the current request.',
+                    },
+                    {
+                        id: 'unknown',
+                        description: 'The reference cannot be resolved from the supplied context.',
+                    },
+                ],
+                abstainId: 'unknown',
+            })),
         ],
     };
 }
 export function requestIntentReferenceIds(context) {
-    const refs = context.messageRefs.map(item => `message:${canonicalContentHash(item)}`);
+    const refs = context.messageRefs.map((item) => `message:${canonicalContentHash(item)}`);
     if (context.activeGoal) {
         refs.push(`run:${canonicalContentHash(context.activeGoal.runId)}`);
         if (context.activeGoal.workflowRevision !== undefined)
@@ -134,37 +283,61 @@ export function requestIntentReferenceIds(context) {
     }
     if (context.activeTask)
         refs.push(`task:${canonicalContentHash([context.activeTask.taskId, context.activeTask.revision, context.activeTask.generation])}`);
-    refs.push(...context.proposals.map(item => `proposal:${canonicalContentHash([item.id, item.revision, item.digest])}`));
+    refs.push(...context.proposals.map((item) => `proposal:${canonicalContentHash([item.id, item.revision, item.digest])}`));
     return refs;
 }
 /** Current identity is mandatory; proposal references are optional evidence of selection. */
 export function requestIntentRequiredReferenceIds(context) {
-    return requestIntentReferenceIds(context).filter(reference => !reference.startsWith('proposal:'));
+    return requestIntentReferenceIds(context).filter((reference) => !reference.startsWith('proposal:'));
 }
 function evidenceFor(context, selectedProposalIds = new Set()) {
     const active = context.activeGoal;
     return {
         requestDigest: canonicalContentHash(context.task),
-        messageRefs: context.messageRefs.map(item => ({ ...item })),
-        ...(active ? {
-            runId: active.runId,
-            ...(active.workflowRevision === undefined ? {} : { workflowRevision: active.workflowRevision }),
-            ...(active.goalRevision === undefined ? {} : { goalRevision: active.goalRevision }),
-            ...(active.scopeRevision === undefined ? {} : { scopeRevision: active.scopeRevision }),
-        } : {}),
-        ...(context.activeTask ? { taskId: context.activeTask.taskId, taskRevision: context.activeTask.revision,
-            taskGeneration: context.activeTask.generation } : {}),
-        proposalRefs: context.proposals.filter(item => selectedProposalIds.has(item.id))
+        messageRefs: context.messageRefs.map((item) => ({ ...item })),
+        ...(active
+            ? {
+                runId: active.runId,
+                ...(active.workflowRevision === undefined
+                    ? {}
+                    : { workflowRevision: active.workflowRevision }),
+                ...(active.goalRevision === undefined
+                    ? {}
+                    : { goalRevision: active.goalRevision }),
+                ...(active.scopeRevision === undefined
+                    ? {}
+                    : { scopeRevision: active.scopeRevision }),
+            }
+            : {}),
+        ...(context.activeTask
+            ? {
+                taskId: context.activeTask.taskId,
+                taskRevision: context.activeTask.revision,
+                taskGeneration: context.activeTask.generation,
+            }
+            : {}),
+        proposalRefs: context.proposals
+            .filter((item) => selectedProposalIds.has(item.id))
             .map(({ id, revision, digest }) => ({ id, revision, digest })),
     };
 }
 export function unresolvedRequestIntent(context, reason, providerSent = false) {
-    return { relation: 'unknown', action: 'unknown', changeScope: 'unknown', source: 'unresolved', policyVersion: REQUEST_INTENT_POLICY_VERSION,
-        evidence: evidenceFor(context), providerSent, unresolvedReason: reason };
+    return {
+        relation: 'unknown',
+        action: 'unknown',
+        changeScope: 'unknown',
+        source: 'unresolved',
+        policyVersion: REQUEST_INTENT_POLICY_VERSION,
+        evidence: evidenceFor(context),
+        providerSent,
+        unresolvedReason: reason,
+    };
 }
 export function requestIntentIsUnresolved(value) {
-    return value === undefined || value.relation === 'unknown' || value.action === 'unknown'
-        || value.action === 'change' && value.changeScope === 'unknown';
+    return (value === undefined ||
+        value.relation === 'unknown' ||
+        value.action === 'unknown' ||
+        (value.action === 'change' && value.changeScope === 'unknown'));
 }
 /** Validate exact current-session evidence before checking whether its Goal supports the selected relation. */
 export function validateMainModelRequestIntent(raw, context) {
@@ -174,32 +347,55 @@ export function validateMainModelRequestIntent(raw, context) {
     if (parsed.data.relation === 'unknown' || parsed.data.action === 'unknown')
         return { ok: false, reason: 'unresolved_intent' };
     const allowed = new Set(requestIntentReferenceIds(context));
-    if (parsed.data.evidenceRefs.some(reference => !allowed.has(reference)))
+    if (parsed.data.evidenceRefs.some((reference) => !allowed.has(reference)))
         return { ok: false, reason: 'unknown_reference' };
     const requiredRefs = requestIntentRequiredReferenceIds(context);
-    if (!requiredRefs.every(reference => parsed.data.evidenceRefs.includes(reference)))
+    if (!requiredRefs.every((reference) => parsed.data.evidenceRefs.includes(reference)))
         return { ok: false, reason: 'missing_reference' };
-    if (parsed.data.relation === 'scope_change' && !context.activeGoal && !context.activeTask)
+    if (parsed.data.relation === 'scope_change' &&
+        !context.activeGoal &&
+        !context.activeTask &&
+        !context.proposals.some((item) => parsed.data.evidenceRefs.includes(`proposal:${canonicalContentHash([item.id, item.revision, item.digest])}`)))
         return { ok: false, reason: 'no_active_goal' };
     if (parsed.data.taskOperation) {
         if (!context.activeTask)
             return { ok: false, reason: 'invalid_task_operation' };
         try {
-            validateTaskOperation(context.activeTask, { operation: parsed.data.taskOperation,
-                operationId: `intent:${canonicalContentHash(context)}`, expectedRevision: context.activeTask.revision,
-                expectedGeneration: context.activeTask.generation, reason: 'Advisory interpretation of the current human request', evidence: [], explicit: false });
+            validateTaskOperation(context.activeTask, {
+                operation: parsed.data.taskOperation,
+                operationId: `intent:${canonicalContentHash(context)}`,
+                expectedRevision: context.activeTask.revision,
+                expectedGeneration: context.activeTask.generation,
+                reason: 'Advisory interpretation of the current human request',
+                evidence: [],
+                explicit: false,
+            });
         }
         catch {
             return { ok: false, reason: 'invalid_task_operation' };
         }
     }
-    const selectedProposalIds = new Set(context.proposals.filter(item => parsed.data.evidenceRefs
-        .includes(`proposal:${canonicalContentHash([item.id, item.revision, item.digest])}`)).map(item => item.id));
-    const changeScope = parsed.data.action === 'change' ? parsed.data.changeScope ?? 'unknown' : 'unknown';
-    return { ok: true, decision: { relation: parsed.data.relation, action: parsed.data.action, changeScope,
+    const selectedProposalIds = new Set(context.proposals
+        .filter((item) => parsed.data.evidenceRefs.includes(`proposal:${canonicalContentHash([item.id, item.revision, item.digest])}`))
+        .map((item) => item.id));
+    const changeScope = parsed.data.action === 'change'
+        ? (parsed.data.changeScope ?? 'unknown')
+        : 'unknown';
+    return {
+        ok: true,
+        decision: {
+            relation: parsed.data.relation,
+            action: parsed.data.action,
+            changeScope,
             source: 'main-model',
-            policyVersion: REQUEST_INTENT_POLICY_VERSION, evidence: evidenceFor(context, selectedProposalIds), providerSent: false,
-            ...(parsed.data.taskOperation ? { taskOperation: parsed.data.taskOperation } : {}) } };
+            policyVersion: REQUEST_INTENT_POLICY_VERSION,
+            evidence: evidenceFor(context, selectedProposalIds),
+            providerSent: false,
+            ...(parsed.data.taskOperation
+                ? { taskOperation: parsed.data.taskOperation }
+                : {}),
+        },
+    };
 }
 /** Validate a main-model interpretation against exact refs from this request and its active session only. */
 export function bindMainModelRequestIntent(raw, context) {
@@ -211,40 +407,57 @@ export function rebindRequestIntentDecision(raw, context) {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         return undefined;
     const value = raw;
-    if (!RequestRelationship.safeParse(value.relation).success || !RequestAction.safeParse(value.action).success
-        || !RequestChangeScope.safeParse(value.changeScope).success
-        || !['decision-provider', 'main-model', 'unresolved'].includes(value.source)
-        || value.policyVersion !== REQUEST_INTENT_POLICY_VERSION || !value.evidence
-        || !Array.isArray(value.evidence.messageRefs) || !Array.isArray(value.evidence.proposalRefs)
-        || value.evidence.requestDigest !== canonicalContentHash(context.task))
+    if (!RequestRelationship.safeParse(value.relation).success ||
+        !RequestAction.safeParse(value.action).success ||
+        !RequestChangeScope.safeParse(value.changeScope).success ||
+        !['decision-provider', 'main-model', 'unresolved'].includes(value.source) ||
+        value.policyVersion !== REQUEST_INTENT_POLICY_VERSION ||
+        !value.evidence ||
+        !Array.isArray(value.evidence.messageRefs) ||
+        !Array.isArray(value.evidence.proposalRefs) ||
+        value.evidence.requestDigest !== canonicalContentHash(context.task))
         return undefined;
     const refs = requestIntentReferenceIds(context);
-    const messagesMatch = value.evidence.messageRefs.length === context.messageRefs.length
-        && context.messageRefs.every((item, index) => value.evidence.messageRefs[index]?.id === item.id
-            && value.evidence.messageRefs[index]?.digest === item.digest);
+    const messagesMatch = value.evidence.messageRefs.length === context.messageRefs.length &&
+        context.messageRefs.every((item, index) => value.evidence.messageRefs[index]?.id === item.id &&
+            value.evidence.messageRefs[index]?.digest === item.digest);
     const active = context.activeGoal;
     const task = context.activeTask;
-    if (value.evidence.taskId !== task?.taskId || value.evidence.taskRevision !== task?.revision
-        || value.evidence.taskGeneration !== task?.generation)
+    if (value.evidence.taskId !== task?.taskId ||
+        value.evidence.taskRevision !== task?.revision ||
+        value.evidence.taskGeneration !== task?.generation)
         return undefined;
-    if (!messagesMatch || (active ? value.evidence.runId !== active.runId
-        || value.evidence.workflowRevision !== active.workflowRevision || value.evidence.goalRevision !== active.goalRevision
-        || value.evidence.scopeRevision !== active.scopeRevision
-        : value.evidence.runId !== undefined))
+    if (!messagesMatch ||
+        (active
+            ? value.evidence.runId !== active.runId ||
+                value.evidence.workflowRevision !== active.workflowRevision ||
+                value.evidence.goalRevision !== active.goalRevision ||
+                value.evidence.scopeRevision !== active.scopeRevision
+            : value.evidence.runId !== undefined))
         return undefined;
     const selected = new Set();
     for (const proposal of value.evidence.proposalRefs) {
         if (!proposal || typeof proposal !== 'object')
             return undefined;
-        const current = context.proposals.find(item => item.id === proposal.id && item.revision === proposal.revision && item.digest === proposal.digest);
-        if (!current || !refs.includes(`proposal:${canonicalContentHash([proposal.id, proposal.revision, proposal.digest])}`))
+        const current = context.proposals.find((item) => item.id === proposal.id &&
+            item.revision === proposal.revision &&
+            item.digest === proposal.digest);
+        if (!current ||
+            !refs.includes(`proposal:${canonicalContentHash([proposal.id, proposal.revision, proposal.digest])}`))
             return undefined;
         selected.add(proposal.id);
     }
     if (value.relation !== 'unknown' && value.action !== 'unknown') {
-        const validated = validateMainModelRequestIntent({ relation: value.relation, action: value.action, changeScope: value.changeScope,
-            ...(value.taskOperation ? { taskOperation: value.taskOperation } : {}), evidenceRefs: refs.filter(reference => !reference.startsWith('proposal:')
-                || context.proposals.some(proposal => selected.has(proposal.id) && reference === `proposal:${canonicalContentHash([proposal.id, proposal.revision, proposal.digest])}`)) }, context);
+        const validated = validateMainModelRequestIntent({
+            relation: value.relation,
+            action: value.action,
+            changeScope: value.changeScope,
+            ...(value.taskOperation ? { taskOperation: value.taskOperation } : {}),
+            evidenceRefs: refs.filter((reference) => !reference.startsWith('proposal:') ||
+                context.proposals.some((proposal) => selected.has(proposal.id) &&
+                    reference ===
+                        `proposal:${canonicalContentHash([proposal.id, proposal.revision, proposal.digest])}`)),
+        }, context);
         if (!validated.ok)
             return undefined;
     }
@@ -257,19 +470,31 @@ export function rebindRequestIntentDecision(raw, context) {
 /** A selected action can advise intake type; it never supplies a target or execution permission. */
 export function requestIntentTaskType(decision, fallback) {
     switch (decision?.action) {
-        case 'answer': return 'chat';
-        case 'research': return 'research';
-        case 'verify': return fallback === 'debug' ? 'debug' : 'review';
-        case 'change': return decision?.changeScope === 'implementation'
-            ? fallback === 'debug' ? 'debug' : 'build'
-            : decision?.changeScope === 'document' ? 'writing' : fallback;
-        case 'operate': return 'devops';
-        default: return fallback;
+        case 'answer':
+            return 'chat';
+        case 'research':
+            return fallback === 'analysis' ? 'analysis' : 'research';
+        case 'verify':
+            return fallback === 'debug' ? 'debug' : 'review';
+        case 'change':
+            return decision?.changeScope === 'implementation'
+                ? fallback === 'debug'
+                    ? 'debug'
+                    : 'build'
+                : decision?.changeScope === 'document'
+                    ? 'writing'
+                    : fallback;
+        case 'operate':
+            return 'devops';
+        default:
+            return fallback;
     }
 }
 export async function classifyRequestIntent(service, requestId, rawContext, signal) {
     let diagnosticId;
-    const result = await classifyRequestIntentAttempt(service, requestId, rawContext, signal, id => { diagnosticId = id; });
+    const result = await classifyRequestIntentAttempt(service, requestId, rawContext, signal, (id) => {
+        diagnosticId = id;
+    });
     if (result && diagnosticId)
         correlateRequestIntent(result, diagnosticId);
     return result;
@@ -290,61 +515,103 @@ async function classifyRequestIntentAttempt(service, requestId, rawContext, sign
         if (!batch)
             return unresolvedRequestIntent(context, 'context_not_usable');
         const outcome = await service.evaluate(requestId, batch, signal, REQUEST_INTENT_POLICY_VERSION, undefined, {
-            onProviderDispatch: () => { providerSent = true; },
-            onEvaluation: observation => { if (observation.decisionId)
-                observeId(observation.decisionId); },
+            onProviderDispatch: () => {
+                providerSent = true;
+            },
+            onEvaluation: (observation) => {
+                if (observation.decisionId)
+                    observeId(observation.decisionId);
+            },
         });
         if (outcome.status !== 'completed')
             return unresolvedRequestIntent(context, outcome.reason, providerSent);
-        const relation = outcome.result.answers.find(answer => answer.id === 'request-relation');
-        const action = outcome.result.answers.find(answer => answer.id === 'request-action');
-        const changeScopeAnswer = outcome.result.answers.find(answer => answer.id === 'request-change-scope');
-        const relationValue = relation?.status === 'selected' && RequestRelationship.safeParse(relation.choiceId).success
-            ? relation.choiceId : 'unknown';
-        const actionValue = action?.status === 'selected' && RequestAction.safeParse(action.choiceId).success
-            ? action.choiceId : 'unknown';
-        const changeScopeValue = actionValue === 'change' && changeScopeAnswer?.status === 'selected'
-            && RequestChangeScope.safeParse(changeScopeAnswer.choiceId).success
-            ? changeScopeAnswer.choiceId : 'unknown';
+        const relation = outcome.result.answers.find((answer) => answer.id === 'request-relation');
+        const action = outcome.result.answers.find((answer) => answer.id === 'request-action');
+        const changeScopeAnswer = outcome.result.answers.find((answer) => answer.id === 'request-change-scope');
+        const relationValue = relation?.status === 'selected' &&
+            RequestRelationship.safeParse(relation.choiceId).success
+            ? relation.choiceId
+            : 'unknown';
+        const actionValue = action?.status === 'selected' &&
+            RequestAction.safeParse(action.choiceId).success
+            ? action.choiceId
+            : 'unknown';
+        const changeScopeValue = actionValue === 'change' &&
+            changeScopeAnswer?.status === 'selected' &&
+            RequestChangeScope.safeParse(changeScopeAnswer.choiceId).success
+            ? changeScopeAnswer.choiceId
+            : 'unknown';
         const selected = new Set();
         let uncertainProposal = false;
         for (const [index, proposal] of context.proposals.entries()) {
-            const answer = outcome.result.answers.find(answer => answer.id === `request-proposal-${index}`);
+            const answer = outcome.result.answers.find((answer) => answer.id === `request-proposal-${index}`);
             if (answer?.status === 'selected' && answer.choiceId === 'selected')
                 selected.add(proposal.id);
-            else if (answer?.status !== 'selected' || answer.choiceId !== 'not_selected')
+            else if (answer?.status !== 'selected' ||
+                answer.choiceId !== 'not_selected')
                 uncertainProposal = true;
         }
-        const unresolved = relationValue === 'unknown' || actionValue === 'unknown' || actionValue === 'change' && changeScopeValue === 'unknown' || uncertainProposal;
+        const unresolved = relationValue === 'unknown' ||
+            actionValue === 'unknown' ||
+            (actionValue === 'change' && changeScopeValue === 'unknown') ||
+            uncertainProposal;
         if (uncertainProposal)
             return unresolvedRequestIntent(context, 'proposal_reference_uncertain', providerSent);
-        const taskOperationAnswer = outcome.result.answers.find(answer => answer.id === 'request-task-operation');
-        const taskOperation = taskOperationAnswer?.status === 'selected' && TASK_OPERATIONS.includes(taskOperationAnswer.choiceId)
-            ? taskOperationAnswer.choiceId : undefined;
+        const taskOperationAnswer = outcome.result.answers.find((answer) => answer.id === 'request-task-operation');
+        const taskOperation = taskOperationAnswer?.status === 'selected' &&
+            TASK_OPERATIONS.includes(taskOperationAnswer.choiceId)
+            ? taskOperationAnswer.choiceId
+            : undefined;
         // A task operation is a separate advisory candidate, not a prerequisite for
         // ordinary work on an already authorized task. Abstention must not erase
         // independently resolved action/scope or fabricate a lifecycle transition.
         // Keep the diagnostic and fallback source so the main model can resolve it;
         // actual task state, lease, scope and native permission checks still apply.
-        const taskOperationUnresolved = !!context.activeTask && (!taskOperationAnswer
-            || taskOperationAnswer.status !== 'selected' || taskOperationAnswer.choiceId === 'unknown');
+        const taskOperationUnresolved = !!context.activeTask &&
+            (!taskOperationAnswer ||
+                taskOperationAnswer.status !== 'selected' ||
+                taskOperationAnswer.choiceId === 'unknown');
         if (!unresolved) {
-            const refs = requestIntentReferenceIds(context).filter(reference => !reference.startsWith('proposal:')
-                || context.proposals.some(proposal => selected.has(proposal.id) && reference === `proposal:${canonicalContentHash([proposal.id, proposal.revision, proposal.digest])}`));
-            const bound = validateMainModelRequestIntent({ relation: relationValue, action: actionValue, changeScope: changeScopeValue,
-                ...(taskOperation ? { taskOperation } : {}), evidenceRefs: refs }, context);
+            const refs = requestIntentReferenceIds(context).filter((reference) => !reference.startsWith('proposal:') ||
+                context.proposals.some((proposal) => selected.has(proposal.id) &&
+                    reference ===
+                        `proposal:${canonicalContentHash([proposal.id, proposal.revision, proposal.digest])}`));
+            const bound = validateMainModelRequestIntent({
+                relation: relationValue,
+                action: actionValue,
+                changeScope: changeScopeValue,
+                ...(taskOperation ? { taskOperation } : {}),
+                evidenceRefs: refs,
+            }, context);
             if (!bound.ok)
                 return unresolvedRequestIntent(context, bound.reason, providerSent);
-            return { ...bound.decision, source: taskOperationUnresolved ? 'unresolved' : 'decision-provider', providerSent,
-                ...(taskOperationUnresolved ? { unresolvedReason: 'task_operation_unresolved' } : {}) };
+            return {
+                ...bound.decision,
+                source: taskOperationUnresolved ? 'unresolved' : 'decision-provider',
+                providerSent,
+                ...(taskOperationUnresolved
+                    ? { unresolvedReason: 'task_operation_unresolved' }
+                    : {}),
+            };
         }
-        return { relation: relationValue, action: actionValue, changeScope: changeScopeValue, source: unresolved ? 'unresolved' : 'decision-provider',
-            policyVersion: REQUEST_INTENT_POLICY_VERSION, evidence: evidenceFor(context, selected), providerSent,
-            ...(unresolved ? { unresolvedReason: 'provider_abstained_or_uncertain' } : {}) };
+        return {
+            relation: relationValue,
+            action: actionValue,
+            changeScope: changeScopeValue,
+            source: unresolved ? 'unresolved' : 'decision-provider',
+            policyVersion: REQUEST_INTENT_POLICY_VERSION,
+            evidence: evidenceFor(context, selected),
+            providerSent,
+            ...(unresolved
+                ? { unresolvedReason: 'provider_abstained_or_uncertain' }
+                : {}),
+        };
     }
     catch (error) {
         if (signal.aborted)
-            throw error instanceof DecisionError ? error : new DecisionError('CANCELLED');
+            throw error instanceof DecisionError
+                ? error
+                : new DecisionError('CANCELLED');
         return unresolvedRequestIntent(context, error instanceof DecisionError ? error.code : 'decision_provider_failed', providerSent);
     }
 }