maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/node_modules/@maka/runtime-host/dist/protocol/operations.js

@@ -57,6 +57,7 @@ import { SESSION_REVISION_OPERATION_SPECS } from './session-revision.js';
 import { SESSION_BUNDLE_OPERATION_SPECS } from './session-bundle.js';
 import { SESSION_RETIREMENT_OPERATION_SPECS } from './session-retirement.js';
 import { PROMPT_SUGGESTION_OPERATION_SPECS } from './prompt-suggestions.js';
+import { SESSION_CHECKIN_OPERATION_SPECS } from './session-checkin.js';
 import { SESSION_EFFECT_OPERATION_SPECS } from './session-effects.js';
 import { SKILL_CATALOG_OPERATION_SPECS } from './skill-catalog.js';
 import { STORAGE_RETENTION_OPERATION_SPECS } from './storage-retention.js';
@@ -98,6 +99,7 @@ export * from './session-turns.js';
 export * from './session-todo.js';
 export * from './session-effects.js';
 export * from './prompt-suggestions.js';
+export * from './session-checkin.js';
 export * from './skill-catalog.js';
 export * from './storage-retention.js';
 export * from './storage-usage.js';
@@ -105,7 +107,10 @@ export * from './usage-pricing.js';
 export * from './web-search.js';
 export * from './recall.js';
 export * from './workspace.js';
-export const HOST_OPERATION_SPECS = composeOperationSpecMaps(HOST_BOOTSTRAP_OPERATION_SPECS, HOST_RESOURCE_OPERATION_SPECS, PEER_MESH_OPERATION_SPECS, HOSTED_EXECUTION_OPERATION_SPECS, ACCESS_AUTHORITY_OPERATION_SPECS, SESSION_COLLABORATION_OPERATION_SPECS, AGENT_GRAPH_OPERATION_SPECS, GOAL_OPERATION_SPECS, TURN_OPERATION_SPECS, CONTEXT_OPERATION_SPECS, CONNECTION_EFFECT_OPERATION_SPECS, DAILY_REVIEW_OPERATION_SPECS, EXECUTION_INSPECT_OPERATION_SPECS, EXTERNAL_SESSION_OPERATION_SPECS, RUNTIME_POLICY_OPERATION_SPECS, RUNTIME_RESOURCE_OPERATION_SPECS, SCHEDULED_TASK_OPERATION_SPECS, PLAN_OPERATION_SPECS, PROJECT_CATALOG_OPERATION_SPECS, MESSAGE_OPERATION_SPECS, SESSION_TODO_OPERATION_SPECS, INTERACTION_OPERATION_SPECS, SESSION_CONTINUITY_OPERATION_SPECS, SESSION_TRANSCRIPT_OPERATION_SPECS, SESSION_TURNS_OPERATION_SPECS, SESSION_CATALOG_OPERATION_SPECS, SESSION_EFFECT_OPERATION_SPECS, PROMPT_SUGGESTION_OPERATION_SPECS, SESSION_REVISION_OPERATION_SPECS, SESSION_BUNDLE_OPERATION_SPECS, SESSION_RETIREMENT_OPERATION_SPECS, ARTIFACT_OPERATION_SPECS, SKILL_CATALOG_OPERATION_SPECS, USAGE_PRICING_OPERATION_SPECS, STORAGE_USAGE_OPERATION_SPECS, STORAGE_RETENTION_OPERATION_SPECS, composeOperationSpecMaps(MEMORY_OPERATION_SPECS, PERSONAL_ASSISTANT_OPERATION_SPECS), OAUTH_OPERATION_SPECS, EXTERNAL_AGENT_SETUP_OPERATION_SPECS, CLIENT_CAPABILITY_OPERATION_SPECS, WEB_SEARCH_OPERATION_SPECS, NETWORK_PROXY_OPERATION_SPECS, RECALL_OPERATION_SPECS, CONFIGURATION_OPERATION_SPECS, WORKHUB_COORDINATION_OPERATION_SPECS, PLUGIN_PLATFORM_OPERATION_SPECS);
+export const HOST_OPERATION_SPECS = composeOperationSpecMaps(HOST_BOOTSTRAP_OPERATION_SPECS, HOST_RESOURCE_OPERATION_SPECS, PEER_MESH_OPERATION_SPECS, HOSTED_EXECUTION_OPERATION_SPECS, ACCESS_AUTHORITY_OPERATION_SPECS, SESSION_COLLABORATION_OPERATION_SPECS, AGENT_GRAPH_OPERATION_SPECS, GOAL_OPERATION_SPECS, TURN_OPERATION_SPECS, CONTEXT_OPERATION_SPECS, CONNECTION_EFFECT_OPERATION_SPECS, DAILY_REVIEW_OPERATION_SPECS, EXECUTION_INSPECT_OPERATION_SPECS, EXTERNAL_SESSION_OPERATION_SPECS, RUNTIME_POLICY_OPERATION_SPECS, RUNTIME_RESOURCE_OPERATION_SPECS, SCHEDULED_TASK_OPERATION_SPECS, PLAN_OPERATION_SPECS, PROJECT_CATALOG_OPERATION_SPECS, MESSAGE_OPERATION_SPECS, SESSION_TODO_OPERATION_SPECS, INTERACTION_OPERATION_SPECS, SESSION_CONTINUITY_OPERATION_SPECS, SESSION_TRANSCRIPT_OPERATION_SPECS, SESSION_TURNS_OPERATION_SPECS, SESSION_CATALOG_OPERATION_SPECS, SESSION_EFFECT_OPERATION_SPECS, 
+// One argument for both: the disjoint-key check across every map passed here
+// already sits at TypeScript's type instantiation depth limit.
+{ ...PROMPT_SUGGESTION_OPERATION_SPECS, ...SESSION_CHECKIN_OPERATION_SPECS }, SESSION_REVISION_OPERATION_SPECS, SESSION_BUNDLE_OPERATION_SPECS, SESSION_RETIREMENT_OPERATION_SPECS, ARTIFACT_OPERATION_SPECS, SKILL_CATALOG_OPERATION_SPECS, USAGE_PRICING_OPERATION_SPECS, STORAGE_USAGE_OPERATION_SPECS, STORAGE_RETENTION_OPERATION_SPECS, composeOperationSpecMaps(MEMORY_OPERATION_SPECS, PERSONAL_ASSISTANT_OPERATION_SPECS), OAUTH_OPERATION_SPECS, EXTERNAL_AGENT_SETUP_OPERATION_SPECS, CLIENT_CAPABILITY_OPERATION_SPECS, WEB_SEARCH_OPERATION_SPECS, NETWORK_PROXY_OPERATION_SPECS, RECALL_OPERATION_SPECS, CONFIGURATION_OPERATION_SPECS, WORKHUB_COORDINATION_OPERATION_SPECS, PLUGIN_PLATFORM_OPERATION_SPECS);
 // Remote credentials are fail-closed: adding a protocol operation does not
 // grant it to remote owners until this policy is deliberately updated.
 export const REMOTE_OWNER_OPERATION_GRANTS = Object.freeze([
@@ -152,6 +157,7 @@ export const REMOTE_OWNER_OPERATION_GRANTS = Object.freeze([
     'external-session.source.query',
     'goal.arm',
     'goal.control',
+    'goal.event-wait.cancel',
     'goal.query',
     'host.diagnostics.query',
     'host.resources.query',
@@ -197,6 +203,7 @@ export const REMOTE_OWNER_OPERATION_GRANTS = Object.freeze([
     'scheduled-task.query',
     'session.branch.create',
     'session.catalog.query',
+    'session.checkin.generate',
     'session.configuration.update',
     'session.create',
     'session.execution_boundary.query',

package/node_modules/@maka/runtime-host/dist/protocol/personal-assistant.js

@@ -56,6 +56,7 @@ const request = z
         'assistant.enablement',
         'assistant.set-enabled',
         'assistant.binding',
+        'assistant.allocate-workspace',
         'assistant.avatar',
         'assistant.avatar-image',
         'assistant.original',

package/node_modules/@maka/runtime-host/dist/protocol/plugin-platform.js

@@ -93,13 +93,19 @@ export const PLUGIN_PLATFORM_OPERATION_SPECS = {
         decodeInput: (value) => {
             const record = requireRecord(value, 'Executor query');
             if (record.kind === 'catalog') {
-                const input = requireShapedRecord(record, 'Executor catalog', ['kind', 'cwd'], ['refresh']);
+                const input = requireShapedRecord(record, 'Executor catalog', ['kind', 'cwd'], ['refresh', 'executorId', 'listOnly']);
                 if (input.refresh !== undefined && typeof input.refresh !== 'boolean')
                     throw invalidProtocolFrame('Invalid executor refresh flag');
+                if (input.listOnly !== undefined && typeof input.listOnly !== 'boolean')
+                    throw invalidProtocolFrame('Invalid executor inventory flag');
                 return {
                     kind: 'catalog',
                     cwd: requireString(input.cwd, 'cwd', 4096),
                     ...(input.refresh ? { refresh: true } : {}),
+                    ...(input.executorId !== undefined
+                        ? { executorId: requireId(input.executorId, 'executorId') }
+                        : {}),
+                    ...(input.listOnly ? { listOnly: true } : {}),
                 };
             }
             const input = requireExactRecord(record, 'Executor conversation', ['kind', 'sessionId']);

package/node_modules/@maka/runtime-host/dist/protocol/session-checkin.js

@@ -0,0 +1,133 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { CHECKIN_INSTRUCTION_MAX_CHARS, CHECKIN_MAX_CARDS, CHECKIN_QUOTE_MAX_CHARS, CHECKIN_TITLE_MAX_CHARS, isCheckinCardAction, isCheckinEvidenceSource, } from '@maka/core/session-checkin';
+import { requireCount, requireEntityId, requireExactRecord, requireRecord, requireShapedRecord, } from './codec.js';
+import { invalidProtocolFrame } from './errors.js';
+import { defineOperation } from './operation-spec.js';
+const SESSION_NAME_MAX_BYTES = 1024;
+const SESSION_CHECKIN_FAILURE_CLASSES = [
+    'aborted',
+    'timeout',
+    'configuration',
+    'provider',
+    'invalid_response',
+    'unknown',
+];
+export const SESSION_CHECKIN_OPERATION_SPECS = {
+    'session.checkin.generate': defineOperation({
+        mode: 'command',
+        availability: 'ready',
+        errors: [
+            'host_not_ready',
+            'host_draining',
+            'operation_unavailable',
+            'operation_conflict',
+            'internal_failure',
+        ],
+        decodeInput: decodeSessionCheckinGenerateInput,
+        decodeOutput: decodeSessionCheckinGenerateResult,
+        assertOutputForInput: (input, output) => {
+            if (input.effectId !== output.effectId) {
+                throw invalidProtocolFrame('Session check-in changed effect identity');
+            }
+        },
+    }),
+};
+export function decodeSessionCheckinGenerateInput(value) {
+    const input = requireExactRecord(value, 'Session check-in input', ['effectId', 'since']);
+    return {
+        effectId: requireEntityId(input.effectId, 'effectId'),
+        since: input.since === null ? null : requireCount(input.since, 'Session check-in since'),
+    };
+}
+export function decodeSessionCheckinGenerateResult(value) {
+    const result = requireRecord(value, 'Session check-in result');
+    if (result.kind === 'empty') {
+        const empty = requireExactRecord(result, 'Empty Session check-in', ['kind', 'effectId']);
+        return { kind: 'empty', effectId: requireEntityId(empty.effectId, 'effectId') };
+    }
+    if (result.kind === 'failed') {
+        const failed = requireExactRecord(result, 'Failed Session check-in', [
+            'kind',
+            'effectId',
+            'errorClass',
+        ]);
+        if (!SESSION_CHECKIN_FAILURE_CLASSES.includes(failed.errorClass)) {
+            throw invalidProtocolFrame('Invalid Session check-in failure class');
+        }
+        return {
+            kind: 'failed',
+            effectId: requireEntityId(failed.effectId, 'effectId'),
+            errorClass: failed.errorClass,
+        };
+    }
+    const generated = requireExactRecord(result, 'Generated Session check-in', [
+        'kind',
+        'effectId',
+        'cards',
+        'dropped',
+    ]);
+    if (generated.kind !== 'generated')
+        throw invalidProtocolFrame('Invalid Session check-in kind');
+    if (!Array.isArray(generated.cards) || generated.cards.length > CHECKIN_MAX_CARDS) {
+        throw invalidProtocolFrame('Invalid Session check-in cards');
+    }
+    return {
+        kind: 'generated',
+        effectId: requireEntityId(generated.effectId, 'effectId'),
+        cards: generated.cards.map(decodeCheckinCard),
+        dropped: requireCount(generated.dropped, 'Session check-in dropped count'),
+    };
+}
+function decodeCheckinCard(value) {
+    const card = requireShapedRecord(value, 'Session check-in card', ['sessionId', 'sessionRevision', 'sessionName', 'title', 'evidence', 'action'], ['instruction']);
+    const evidence = requireExactRecord(card.evidence, 'Session check-in evidence', [
+        'source',
+        'quote',
+    ]);
+    if (!isCheckinCardAction(card.action) || !isCheckinEvidenceSource(evidence.source)) {
+        throw invalidProtocolFrame('Invalid Session check-in card');
+    }
+    if (typeof card.sessionName !== 'string' ||
+        Buffer.byteLength(card.sessionName) > SESSION_NAME_MAX_BYTES) {
+        throw invalidProtocolFrame('Invalid Session check-in Session name');
+    }
+    return {
+        sessionId: requireEntityId(card.sessionId, 'sessionId'),
+        sessionRevision: requireCount(card.sessionRevision, 'Session check-in revision'),
+        sessionName: card.sessionName,
+        title: requireChars(card.title, 'Session check-in title', CHECKIN_TITLE_MAX_CHARS),
+        evidence: {
+            source: evidence.source,
+            quote: requireChars(evidence.quote, 'Session check-in quote', CHECKIN_QUOTE_MAX_CHARS),
+        },
+        action: card.action,
+        ...(card.instruction !== undefined
+            ? {
+                instruction: requireChars(card.instruction, 'Session check-in instruction', CHECKIN_INSTRUCTION_MAX_CHARS),
+            }
+            : {}),
+    };
+}
+function requireChars(value, label, maxChars) {
+    if (typeof value !== 'string' || !value.trim() || Array.from(value).length > maxChars) {
+        throw invalidProtocolFrame(`Invalid ${label}`);
+    }
+    return value;
+}

package/node_modules/@maka/runtime-host/dist/server/agent-settings-tools.js

@@ -46,7 +46,6 @@ export function buildHostAgentSettingsTools(authority) {
             'This never returns credentials, network proxy details, native client settings, or Bot settings.',
         parameters: z.object({}).strict(),
         categoryHint: 'read',
-        recoveryMode: 'replay_safe',
         impl: async () => projectSettings((await authority.read()).policy),
     };
     const updateTool = {

package/node_modules/@maka/runtime-host/dist/server/canonical-session-projection.js

@@ -60,9 +60,10 @@ export class CanonicalSessionProjectionReader {
             rootTurn = await readCanonicalTurnSnapshot(this.#stores, durableAdmission);
         }
         const interactions = projectSessionInteractions(await this.#stores.interactionStore.listSessionPending(sessionId), await this.#stores.sessionStore.listPendingSandboxBoundaryRequests(sessionId));
-        // The Session lane barrier must remain held through this final synchronous read.
+        // Keep the Session lane across the asynchronous Goal/wait read and the
+        // final queue projection; neither read can authorize a second admission.
+        const goal = await this.#readGoal(sessionId);
         const queue = this.#messages.projection(sessionId);
-        const goal = this.#readGoal(sessionId);
         const session = {
             sessionId: header.id,
             metadataRevision,

package/node_modules/@maka/runtime-host/dist/server/event-wait-manager.js

@@ -17,7 +17,7 @@
  * under the License.
  */
 import { randomUUID } from 'node:crypto';
-import { decodeEventWaitRecord, EVENT_WAIT_LIMITS, } from '@maka/core/event-wait';
+import { decodeEventWaitRecord, decodeObservedEventWaitRecord, EVENT_WAIT_LIMITS, } from '@maka/core/event-wait';
 import { authenticateInteractiveEventWaitAuthorityWriter, EVENT_WAIT_OBSERVATION_HINT_LIMIT, EVENT_WAIT_PAGE_LIMIT, eventWaitSourceKey, } from '@maka/storage/event-wait-authority';
 import { StorageRootAuthorityError } from '@maka/storage/root-authority';
 const systemClock = {
@@ -76,12 +76,14 @@ const addTime = (now, delay) => Math.min(Number.MAX_SAFE_INTEGER, now + delay);
  * Ready candidates normally use durable observation age. Failed preparations get a bounded
  * traversal by immutable ID, so neither failed writes nor cache capacity can pin selection.
  */
-export class HostEventWaitManager {
+export class HostEventWaitObserver {
     #store;
     #options;
     #clock;
     #policy;
     #flights = new Map();
+    /** Registration/delivery authorization shares observation capacity and source facts. */
+    #accessFlights = new Set();
     #subscriptions = new Map();
     #cooldowns = new Map();
     /** Dispatch preparation is serialized per source, independently of in-flight reads. */
@@ -102,7 +104,7 @@ export class HostEventWaitManager {
     #closed = false;
     #ready = false;
     constructor(options) {
-        this.#store = authenticateInteractiveEventWaitAuthorityWriter(options.store);
+        this.#store = options.store;
         this.#options = options;
         this.#clock = options.clock ?? systemClock;
         this.#policy = { ...DEFAULT_EVENT_WAIT_OBSERVATION_POLICY, ...options.policy };
@@ -111,7 +113,9 @@ export class HostEventWaitManager {
                 if (!Number.isFinite(value) || value < 0 || value > 1)
                     throw new TypeError('Invalid wait jitter');
             }
-            else if (!Number.isSafeInteger(value) || value < 1 || value > 2_147_483_647)
+            else if (!Number.isSafeInteger(value) ||
+                value < 1 ||
+                (name !== 'maxLifetimeMs' && value > 2_147_483_647))
                 throw new TypeError(`Invalid wait policy: ${name}`);
         }
         if (this.#policy.pageSize > EVENT_WAIT_PAGE_LIMIT ||
@@ -125,13 +129,72 @@ export class HostEventWaitManager {
                 EVENT_WAIT_OBSERVATION_HINT_LIMIT)
             throw new TypeError('Inconsistent event wait policy');
     }
+    #decode(value) {
+        return (this.#options.decodeRecord ?? decodeObservedEventWaitRecord)(value);
+    }
     /** Validates the supported template only; PR3 owns registration authorization and yield. */
     validate(wait) {
-        const record = decodeEventWaitRecord(wait);
+        const record = this.#decode(wait);
         if (record.deadlineAt - record.createdAt > this.#policy.maxLifetimeMs)
             throw new TypeError('Event wait exceeds maximum lifetime');
         this.#options.adapters.validate(record);
     }
+    /** Bounded source access outside observation; no wait attempt or work Turn is charged. */
+    async checkSourceAccess(wait, parent, authorize) {
+        const unknown = { kind: 'unknown', reason: 'authorization_unavailable' };
+        const source = sourceKey(wait);
+        const occupied = this.#occupiedFlights();
+        if (this.#closed ||
+            parent.aborted ||
+            this.#pendingCooldowns.size >= this.#policy.maxSourceCooldowns ||
+            this.#sourceCooldown(source) > this.#clock.now() ||
+            occupied.size >= this.#policy.maxConcurrent ||
+            [...occupied].filter((f) => f.source === source).length >= this.#policy.maxPerSource)
+            return unknown;
+        const flight = {
+            controller: new AbortController(),
+            source,
+            sessionId: wait.sessionId,
+            waitId: wait.waitId,
+            claimed: false,
+            cooldownUntil: 0,
+            retryAfterUntil: 0,
+            task: Promise.resolve(),
+        };
+        this.#accessFlights.add(flight);
+        const abort = () => flight.controller.abort();
+        parent.addEventListener('abort', abort, { once: true });
+        const task = (async () => {
+            const cooldown = await this.#store.readSourceCooldown({
+                providerId: wait.resource.providerId,
+                connectionId: wait.resource.connectionId,
+            });
+            if (this.#closed ||
+                flight.controller.signal.aborted ||
+                Math.max(cooldown ?? 0, this.#sourceCooldown(source)) > this.#clock.now())
+                return unknown;
+            try {
+                // Expired waits still need delivery authorization, so the source deadline
+                // does not bound this separate request. #call retains the request timeout.
+                return ((await this.#tryAuthorize(wait, flight, Number.MAX_SAFE_INTEGER, authorize))?.access ??
+                    unknown);
+            }
+            catch (error) {
+                if (error instanceof SourceCooldownWriteError || error instanceof StorageRootAuthorityError)
+                    throw error;
+                return unknown;
+            }
+        })();
+        flight.task = task.then(() => undefined, () => undefined);
+        try {
+            return await task;
+        }
+        finally {
+            parent.removeEventListener('abort', abort);
+            this.#accessFlights.delete(flight);
+            // #call retains interrupted requests in #lingering until late facts settle.
+        }
+    }
     start() {
         if (this.#closed)
             return Promise.reject(new Error('Event wait manager is closed'));
@@ -174,7 +237,11 @@ export class HostEventWaitManager {
     #occupiedFlights() {
         // One observation owns one slot even while its interrupted request and checkpoint
         // persistence overlap. Keep that slot until both the flight and its late work retire.
-        return new Set([...this.#flights.values(), ...this.#lingering.values()]);
+        return new Set([
+            ...this.#flights.values(),
+            ...this.#accessFlights,
+            ...this.#lingering.values(),
+        ]);
     }
     async #scanPage() {
         // Session cleanup can remove waits without calling cancel(). Include polling-only
@@ -355,7 +422,8 @@ export class HostEventWaitManager {
         }
     }
     async #observe(snapshot, flight) {
-        let r = snapshot.record;
+        const projectionBefore = snapshot.record;
+        let r = projectionBefore;
         if (r.status !== 'waiting' || this.#closed)
             return;
         const cooldown = await this.#store.readSourceCooldown({
@@ -405,7 +473,9 @@ export class HostEventWaitManager {
             outcome: 'checking',
             cursor: previous?.cursor ?? null,
             eventKey: previous?.eventKey ?? null,
-            reason: null,
+            // Reconnecting projections still need the last completed observation's
+            // diagnostic while this reservation's source request is in flight.
+            reason: previous?.reason ?? null,
         };
         const claim = await this.#commit(snapshot, { ...r, updatedAt: now, observation: reserved });
         if (this.#closed || flight.controller.signal.aborted)
@@ -496,7 +566,10 @@ export class HostEventWaitManager {
             !subscriptionPending &&
             !this.#subscriptions.get(r.waitId)?.controller.signal.aborted)
             this.#detach(r.waitId);
-        await this.#finish(snapshot, result, { retryAfterUntil: flight.retryAfterUntil });
+        await this.#finish(snapshot, result, {
+            retryAfterUntil: flight.retryAfterUntil,
+            projectionBefore,
+        });
     }
     #validateAccess(access) {
         if (!access || !['allowed', 'revoked', 'unknown'].includes(access.kind))
@@ -515,7 +588,7 @@ export class HostEventWaitManager {
         }
     }
     /** Null defers dispatch to the caller without starting an authorization request. */
-    async #tryAuthorize(r, flight) {
+    async #tryAuthorize(r, flight, deadline = r.deadlineAt, authorize = this.#options.authorize) {
         const recordCooldown = async (checked) => {
             if (!checked || this.#closed)
                 return;
@@ -525,12 +598,12 @@ export class HostEventWaitManager {
                 await this.#recordSourceCooldown(r, checked.access);
             }
         };
-        const checked = await this.#call(flight, r.deadlineAt, (signal) => {
+        const checked = await this.#call(flight, deadline, (signal) => {
             // Recheck at actual dispatch; cooldown can change after the timer wakes or
             // before #call invokes this callback. Active flights retain it across cache eviction.
             if (flight.retryAfterUntil > this.#clock.now())
                 return Promise.resolve(null);
-            return this.#options.authorize(r, signal).then((access) => ({ access }));
+            return authorize(structuredClone(r), signal).then((access) => ({ access }));
         }, recordCooldown);
         // Shared facts outlive a cancelled wait, including cancellation during the
         // handoff from #call. Normal and late results use the same validation/persistence
@@ -753,15 +826,30 @@ export class HostEventWaitManager {
             (!Number.isSafeInteger(result.retryAfterMs) || result.retryAfterMs < 0))
             throw new TypeError('Invalid retry delay');
         const now = Math.max(r.updatedAt, this.#clock.now());
-        decodeEventWaitRecord({
+        // Registration and delivery authorization may have no observation checkpoint.
+        // Validate the prospective fields without writing an attempt or changing the wait.
+        const observation = r.observation ?? {
+            schemaVersion: 1,
+            attempts: 1,
+            lastAttemptAt: now,
+            lastObservedAt: now,
+            nextObserveAt: now,
+            nextPollAt: now,
+            consecutiveErrors: 0,
+            outcome: 'checking',
+            cursor: null,
+            eventKey: null,
+            reason: null,
+        };
+        this.#decode({
             ...r,
             updatedAt: now,
             observation: {
-                ...r.observation,
+                ...observation,
                 outcome: result.kind,
                 lastObservedAt: now,
-                cursor: result.cursor ?? r.observation.cursor,
-                eventKey: result.eventKey ?? r.observation.eventKey,
+                cursor: result.cursor ?? observation.cursor,
+                eventKey: result.eventKey ?? observation.eventKey,
                 reason: result.kind === 'unknown' ? result.reason : null,
             },
             ...(result.kind === 'pending' || result.kind === 'unknown'
@@ -881,7 +969,7 @@ export class HostEventWaitManager {
                 },
             };
         }
-        const committed = await this.#commit(snapshot, record);
+        const committed = await this.#commit(snapshot, record, options.projectionBefore);
         if (!committed || committed.record.status !== 'waiting')
             this.#detach(r.waitId);
         return committed;
@@ -1018,7 +1106,7 @@ export class HostEventWaitManager {
             finishHandoff();
         }
     }
-    async #commit(snapshot, record) {
+    async #commit(snapshot, record, projectionBefore = snapshot.record) {
         if (this.#closed)
             return null;
         const result = await this.#store.commit({
@@ -1026,7 +1114,23 @@ export class HostEventWaitManager {
             expectedAuthorityRevision: snapshot.authorityRevision,
             record,
         });
-        return result.kind === 'committed' ? result.snapshot : null;
+        if (result.kind !== 'committed')
+            return null;
+        const after = result.snapshot.record;
+        // Compare durable semantics before the attempt, not its temporary checking
+        // reservation. Cache eviction must not turn unchanged polling into activity.
+        if ((after.status !== 'waiting' || after.observation?.outcome !== 'checking') &&
+            (projectionBefore.status !== after.status ||
+                projectionBefore.observation?.outcome !== after.observation?.outcome ||
+                projectionBefore.observation?.reason !== after.observation?.reason)) {
+            try {
+                this.#options.onChanged?.(after);
+            }
+            catch {
+                /* Projection hints are best effort. */
+            }
+        }
+        return result.snapshot;
     }
     async #expire(snapshot) {
         if (this.#closed || snapshot.record.status !== 'waiting')
@@ -1105,7 +1209,7 @@ export class HostEventWaitManager {
     }
     #cool(source, until, owner) {
         // Prepared reads retain new source facts even if their cache entry is evicted.
-        for (const flight of this.#flights.values()) {
+        for (const flight of this.#occupiedFlights()) {
             if (flight.source === source && flight !== owner) {
                 flight.cooldownUntil = Math.max(flight.cooldownUntil, until);
                 // An owner marks ordinary read spacing. Source-reported Retry-After has no
@@ -1160,6 +1264,8 @@ export class HostEventWaitManager {
         this.#timer = undefined;
         for (const flight of this.#flights.values())
             flight.controller.abort();
+        for (const flight of this.#accessFlights)
+            flight.controller.abort();
         for (const waitId of this.#subscriptions.keys())
             this.#detach(waitId);
         this.#close = (async () => {
@@ -1170,6 +1276,7 @@ export class HostEventWaitManager {
                         this.#start,
                         this.#scan,
                         ...[...this.#flights.values()].map((v) => v.task),
+                        ...[...this.#accessFlights].map((v) => v.task),
                         ...this.#lateResults,
                     ]),
                     new Promise((resolve) => {
@@ -1184,3 +1291,27 @@ export class HostEventWaitManager {
         return this.#close;
     }
 }
+export class HostEventWaitManager extends HostEventWaitObserver {
+    checkSourceAccess(wait, signal, authorize) {
+        return super.checkSourceAccess(wait, signal, (record, signal) => authorize(decodeEventWaitRecord(record), signal));
+    }
+    constructor(options) {
+        const store = authenticateInteractiveEventWaitAuthorityWriter(options.store);
+        super({
+            ...options,
+            decodeRecord: decodeEventWaitRecord,
+            authorize: (wait, signal) => options.authorize(decodeEventWaitRecord(wait), signal),
+            onChanged: (wait) => options.onChanged?.(decodeEventWaitRecord(wait)),
+            store: {
+                read: (input) => store.read(input),
+                listByStatus: (input) => store.listByStatus(input),
+                listForObservation: (input) => store.listForObservation(input),
+                readSourceCooldown: (input) => store.readSourceCooldown(input),
+                extendSourceCooldown: (input) => store.extendSourceCooldown(input),
+                reserveSourceDispatch: (input) => store.reserveSourceDispatch(input),
+                completeSourceDispatch: (input) => store.completeSourceDispatch(input),
+                commit: (input) => store.commit({ ...input, record: decodeEventWaitRecord(input.record) }),
+            },
+        });
+    }
+}

package/node_modules/@maka/runtime-host/dist/server/event-wait-observation-store.js

@@ -0,0 +1,19 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export {};