@dsh-enhanced/assistant-evaluation 0.1.66 → 0.1.67

package/lib/service.js

@@ -4,7 +4,7 @@ import { acceptanceDigest, goalDefinitionSituation, validateTaskAcceptanceContra
 import { EvaluationStore, EvaluationStoreError, canonicalEvaluationScope, evaluationLearningProjectionDigest, } from './store.js';
 import { registerEvaluationTools } from './tools.js';
 import { normalizeAttentionCohort, } from './attention-tuning.js';
-import { ATTENTION_OWNER_QUESTION_SOURCE_ID, attentionOwnerQuestionIdempotencyKey, attentionOwnerQuestionText, } from './attention-owner-questions.js';
+import { ATTENTION_OWNER_QUESTION_SOURCE_ID, attentionOwnerQuestionIdempotencyKey, attentionOwnerQuestionText, parseAttentionOwnerQuestionChoice, ATTENTION_OWNER_QUESTION_REPLY_PROTOCOL, } from './attention-owner-questions.js';
 import { validateWorkItemOwnerFeedbackProof } from './work-item-owner-proof.js';
 import { computeIntakeAttentionAgreement, INTAKE_ATTENTION_AGREEMENT_SCAN_LIMIT, isIntakeProvenanceSource } from './intake-attention-agreement.js';
 import { executionStatuses, objectiveStatuses, outcomeSourceKinds, TRUSTED_EVALUATION_PRODUCER_PROTOCOL, } from './types.js';
@@ -15,6 +15,10 @@ function isOwnerQuestionDeliveryPort(value) {
         && typeof port.validateOwnerRoute === 'function' && typeof port.resolveOwnerRoute === 'function'
         && typeof port.inspectOwnerNotification === 'function' && typeof port.registerOwnerNotificationWithdrawal === 'function';
 }
+function isOwnerQuestionReplyPort(value) {
+    const port = value;
+    return typeof port === 'object' && port !== null && typeof port.registerOwnerNotificationReply === 'function';
+}
 export const ASSISTANT_EVALUATION_SKILL = `# Personal assistant self-evaluation
 
 Use this workflow only to assess whether an already-finished task met its objective. A self-assessment is diagnostic evidence, never ground truth and never permission to change production behavior.
@@ -250,6 +254,8 @@ export class AssistantEvaluationService extends Service {
     lastNotificationSyncAt = Number.NEGATIVE_INFINITY;
     ownerQuestionWithdrawal;
     activeOwnerQuestionWithdrawals = new WeakSet();
+    ownerQuestionReply;
+    activeOwnerQuestionReplies = new WeakSet();
     attentionCohorts;
     active = true;
     constructor(ctx, input, options = {}) {
@@ -401,6 +407,8 @@ export class AssistantEvaluationService extends Service {
         if (this.config.attentionOwnerQuestionDeliveryEnabled) {
             this.bindOwnerQuestionWithdrawal(currentDelivery);
             ctx.inject(['assistantDelivery'], deliveryCtx => this.bindOwnerQuestionWithdrawal(deliveryCtx.get('assistantDelivery')));
+            this.bindOwnerQuestionReply(currentDelivery);
+            ctx.inject(['assistantDelivery'], deliveryCtx => this.bindOwnerQuestionReply(deliveryCtx.get('assistantDelivery')));
         }
         const currentVerifier = ctx.get('assistantVerifier');
         if (isTrustedVerifierEvaluationProducer(currentVerifier))
@@ -449,6 +457,7 @@ export class AssistantEvaluationService extends Service {
             this.projectionTimer = undefined;
             this.notificationFacts = undefined;
             this.ownerQuestionWithdrawal?.dispose();
+            this.ownerQuestionReply?.dispose();
             disposeCurrentProjector?.();
             this.automationBinding?.dispose();
             this.deliveryBinding?.dispose();
@@ -942,7 +951,14 @@ export class AssistantEvaluationService extends Service {
         });
     }
     #looseningOptions() {
-        return this.config.attentionLooseningEnabled ? Object.freeze({ replayWindowMs: this.config.attentionLooseningReplayWindowMs }) : undefined;
+        if (!this.config.attentionLooseningEnabled)
+            return undefined;
+        return Object.freeze({
+            replayWindowMs: this.config.attentionLooseningReplayWindowMs,
+            ...(this.config.attentionOwnerQuestionDeliveryEnabled
+                ? { ownerQuestionReplyLoop: Object.freeze({ noticeTtlMs: this.config.attentionOwnerQuestionNoticeTtlMs }) }
+                : {}),
+        });
     }
     #attentionCohort(input) {
         let cohort;
@@ -1095,6 +1111,95 @@ export class AssistantEvaluationService extends Service {
         this.ownerQuestionWithdrawal = binding;
         return binding.dispose;
     }
+    /**
+     * Register (once per Delivery instance) the slice-5 reply consumer. A
+     * Delivery without the reply port is treated as absent: slice-4 notice
+     * delivery keeps working, only replies are not read. A registration error
+     * only disables replies; it never blocks notice delivery.
+     */
+    bindOwnerQuestionReply(source) {
+        if (!this.active || !isOwnerQuestionReplyPort(source))
+            return undefined;
+        if (this.ownerQuestionReply?.source === source)
+            return undefined;
+        const registration = Object.freeze({
+            protocol: ATTENTION_OWNER_QUESTION_REPLY_PROTOCOL,
+            authority: 'assistantEvaluation',
+            sourceId: ATTENTION_OWNER_QUESTION_SOURCE_ID,
+            idempotencyKeyPrefix: attentionOwnerQuestionIdempotencyKey(''),
+            consume: (input) => this.#consumeOwnerQuestionReply(input),
+        });
+        this.activeOwnerQuestionReplies.add(registration);
+        let unregister;
+        try {
+            unregister = source.registerOwnerNotificationReply(registration)?.unregister;
+        }
+        catch (error) {
+            this.activeOwnerQuestionReplies.delete(registration);
+            this.ctx.logger.warn(`assistant-evaluation: owner-question reply registration failed; replies are not read: ${String(error)}`);
+            return undefined;
+        }
+        if (typeof unregister !== 'function') {
+            this.activeOwnerQuestionReplies.delete(registration);
+            this.ctx.logger.warn('assistant-evaluation: owner-question reply registration returned no unregister; replies are not read');
+            return undefined;
+        }
+        const release = unregister;
+        this.ownerQuestionReply?.dispose();
+        let live = true;
+        const binding = Object.freeze({ source, registration, dispose: () => {
+                if (!live)
+                    return;
+                live = false;
+                this.activeOwnerQuestionReplies.delete(registration);
+                try {
+                    release();
+                }
+                catch { /* Delivery already gone */ }
+                if (this.ownerQuestionReply === binding)
+                    this.ownerQuestionReply = undefined;
+            } });
+        this.ownerQuestionReply = binding;
+        return binding.dispose;
+    }
+    /**
+     * Synchronous Delivery callback for one authenticated reply to an exact
+     * owner-question notice. Only exact whole-phrase choices are accepted; a
+     * recognized choice is consumed even when its question is no longer open,
+     * so a stale "authorize-once" never reaches the Agent. Storage errors are
+     * `transient` and leave Delivery's Inbox pending for a bounded retry.
+     */
+    #consumeOwnerQuestionReply(input) {
+        if (!this.active || !this.config.attentionOwnerQuestionDeliveryEnabled)
+            return 'ignored';
+        if (typeof input?.idempotencyKey !== 'string' || typeof input.text !== 'string')
+            return 'ignored';
+        const prefix = attentionOwnerQuestionIdempotencyKey('');
+        if (!input.idempotencyKey.startsWith(prefix))
+            return 'ignored';
+        const questionId = input.idempotencyKey.slice(prefix.length);
+        const choice = parseAttentionOwnerQuestionChoice(input.text);
+        if (choice === undefined || questionId.length === 0)
+            return 'ignored';
+        try {
+            for (const cohort of this.attentionCohorts) {
+                for (const scope of this.store.attention.scopes(cohort)) {
+                    const latest = this.store.attention.latestOwnerQuestion(scope, cohort);
+                    if (latest === undefined || latest === 'unverifiable' || latest.questionId !== questionId)
+                        continue;
+                    this.applyAttentionOwnerQuestionReply({ scope, cohort, questionId, choice });
+                    return 'applied';
+                }
+            }
+            // The notice was genuinely issued under this source and key, but the
+            // local ledger no longer holds that exact question: consume the
+            // recognized choice instead of sending it to the Agent.
+            return 'applied';
+        }
+        catch {
+            return 'transient';
+        }
+    }
     /**
      * Send-time answer for one owner-question notice. It stays sendable only
      * while its question is still the cohort's latest, open, unanswered, inside
@@ -1171,6 +1276,9 @@ export class AssistantEvaluationService extends Service {
                     continue;
                 }
                 this.bindOwnerQuestionWithdrawal(delivery);
+                // A replaced Delivery instance needs the reply consumer bound as well;
+                // the tick is the existing retry point, so no extra loop is added.
+                this.bindOwnerQuestionReply(delivery);
                 // Only queue (or adopt) while this service's own withdrawal check is
                 // bound to this exact Delivery instance; otherwise a closed question
                 // could be sent unchecked.
@@ -1232,7 +1340,7 @@ export class AssistantEvaluationService extends Service {
                         scope: { principalId: owner.principalId, ...principal, workspace: scope.workspace, preset: scope.preset },
                         sessionId,
                         idempotencyKey,
-                        text: attentionOwnerQuestionText(question, scope),
+                        text: attentionOwnerQuestionText(question, scope, { repliesRead: true }),
                         expiresAt,
                         attention: { purpose: 'result' },
                         withdrawable: true,
@@ -1255,8 +1363,10 @@ export class AssistantEvaluationService extends Service {
     }
     /**
      * Host-internal record-only owner reply to the cohort's latest question.
-     * It never records a grant or changes a tuning version; an owner who
-     * authorizes still records a grant through `grantAttentionLoosening`.
+     * It never records a grant or changes a tuning version, and it is not the
+     * slice-5 apply path; an owner who authorizes uses
+     * `applyAttentionOwnerQuestionReply` (the only path the Delivery reply
+     * consumer calls) or records a host grant through `grantAttentionLoosening`.
      */
     recordAttentionOwnerQuestionReply(input) {
         this.assertActive();
@@ -1272,6 +1382,23 @@ export class AssistantEvaluationService extends Service {
             || this.now() >= latest.question.createdAt + this.config.attentionOwnerQuestionNoticeTtlMs;
         return this.store.attentionQuestions.recordReply(input.scope, cohort, latest.questionId, input.choice, latest.open, expired);
     }
+    /**
+     * Slice 5 evidence-backed apply path for one exact owner reply; the
+     * Delivery consumer and Host callers use this instead of the record-only
+     * seam. `authorize-once` records the reply and creates one bounded one-time
+     * grant for exactly the questioned proposal (parent/candidate bounds, the
+     * proposal's step size, one adoption); the next tuning tick still re-runs
+     * the independent holdout replay before adopting. `decline` closes the
+     * proposal. A proposal that already had an immutable decision returns
+     * `proposal-terminal` and nothing adopts.
+     */
+    applyAttentionOwnerQuestionReply(input) {
+        this.assertActive();
+        const cohort = this.#attentionCohort(input.cohort);
+        if (!this.config.attentionOwnerQuestionDeliveryEnabled)
+            return Object.freeze({ status: 'rejected', reason: 'delivery-disabled' });
+        return this.store.attention.applyOwnerQuestionReply(input.scope, cohort, input.questionId, input.choice, { noticeTtlMs: this.config.attentionOwnerQuestionNoticeTtlMs });
+    }
     /** Per-question delivery decisions and recorded replies for one cohort. */
     attentionOwnerQuestionStatus(input) {
         this.assertActive();
@@ -1303,6 +1430,14 @@ export class AssistantEvaluationService extends Service {
         return this.active && typeof registration === 'object' && registration !== null
             && this.activeOwnerQuestionWithdrawals.has(registration);
     }
+    /**
+     * Delivery's slot-anchored proof that the slice-5 reply consumer under the
+     * `assistantEvaluation` authority is this live service's own registration.
+     */
+    ownsOwnerNotificationReply(registration) {
+        return this.active && typeof registration === 'object' && registration !== null
+            && this.activeOwnerQuestionReplies.has(registration);
+    }
     /** Delivery uses the same ownership boundary as Automations. */
     ownsTrustedDeliveryEvaluationRegistration(registration) {
         return this.active && typeof registration === 'object' && registration !== null