maka-agent 0.2.2-dev.92.20261019 → 0.2.2-dev.97.20261024

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

@@ -30,7 +30,28 @@ class AssistantRuntime {
     directory;
     dependencies;
     tools = [];
+    internalTools = [];
+    toolFilters = [];
     bot = new AssistantBotBridge();
+    backgroundSessions = [];
+    sessionAccess = [];
+    hasSessionAccess(sessionId) {
+        return (this.bot.isConversation(sessionId) ||
+            this.bot.isWorker(sessionId) ||
+            this.backgroundSessions.some((read) => read().includes(sessionId)) ||
+            this.sessionAccess.some((allows) => allows(sessionId)));
+    }
+    /**
+     * The only visibility policy. Catalogs and execution both use it, so a tool hidden
+     * from a Session cannot run in that Session either.
+     */
+    visibleTools(sessionId, tools) {
+        const nativeNames = new Set(this.tools.map((tool) => tool.name));
+        const allowed = this.hasSessionAccess(sessionId)
+            ? tools
+            : tools.filter((tool) => !nativeNames.has(tool.name));
+        return this.toolFilters.reduce((current, filter) => filter(sessionId, current), allowed);
+    }
     sections = [];
     contexts = [];
     checks = [];
@@ -53,18 +74,19 @@ class AssistantRuntime {
         if (this.initialized)
             throw Error('Personal assistant already initialized');
         const settings = await this.loadSettings(legacy, entries);
-        const backgroundSessions = [];
         const services = {
             bot: this.bot,
-            backgroundSessions: { register: (read) => backgroundSessions.push(read) },
+            backgroundSessions: { register: (read) => this.backgroundSessions.push(read) },
             ...this.dependencies,
             onClose: (dispose) => this.disposers.push(dispose),
             onStart: (start) => this.starters.push(start),
             tools: {
+                filter: (filter) => this.toolFilters.push(filter),
+                registerSessionAccess: (allows) => this.sessionAccess.push(allows),
                 register: (tool) => {
                     if (this.tools.some((t) => t.name === tool.name))
                         throw Error(`Duplicate assistant tool: ${tool.name}`);
-                    this.tools.push({
+                    const internalTool = {
                         ...tool,
                         impl: (input, call) => {
                             if (this.closing)
@@ -84,9 +106,26 @@ class AssistantRuntime {
                                 return this.dependencies.agents.withInvocation(scoped, () => tool.impl(input, scoped));
                             });
                         },
+                    };
+                    this.internalTools.push(internalTool);
+                    this.tools.push({
+                        ...internalTool,
+                        impl: (input, call) => {
+                            if (this.closing)
+                                throw Error('Personal assistant is shutting down');
+                            if (!this.hasSessionAccess(call.sessionId))
+                                throw Error('Personal assistant tools are unavailable in this session');
+                            if (!this.visibleTools(call.sessionId, [tool]).length)
+                                throw Error('Personal assistant tool is unavailable in this session');
+                            return internalTool.impl(input, call);
+                        },
                     });
                 },
-                resolve: (sessionId) => sessionId ? this.dependencies.resolveTools(sessionId, this.tools) : { tools: this.tools },
+                // Only Host module APIs use this resolver. They retain the caller's source
+                // permissions (e.g. ordinary-chat original links) without exposing model tools.
+                resolve: (sessionId) => sessionId
+                    ? this.dependencies.resolveTools(sessionId, this.internalTools)
+                    : { tools: this.internalTools },
             },
             systemPrompt: {
                 section: (value) => this.sections.push(value),
@@ -114,7 +153,7 @@ class AssistantRuntime {
             ])
                 await initialize(services, settings[name].directory, settings[name].config);
             await this.dependencies.markBackgroundSessions([
-                ...new Set(backgroundSessions.flatMap((read) => read())),
+                ...new Set(this.backgroundSessions.flatMap((read) => read())),
             ]);
             this.initialized = true;
         }
@@ -427,6 +466,11 @@ export class PersonalAssistantService {
     hasInboxMessage(sessionId, id) {
         return this.enabled && this.runtime.bot.hasUserMessage(sessionId, id);
     }
+    filterTools(sessionId, tools) {
+        if (!this.enabled)
+            return tools;
+        return this.runtime.visibleTools(sessionId, tools);
+    }
     toolCeiling(sessionId) {
         return this.enabled && this.runtime.bot.isWorker(sessionId)
             ? this.runtime.tools.filter((tool) => BOT_TOOLS.has(tool.name))

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

@@ -20,7 +20,12 @@ import { GOAL_CONDITION_TEXT_LIMIT, GOAL_MAX_ITERATIONS_LIMIT, GOAL_REASON_TEXT_
 import { requireCount, requireEncodedByteLimit, requireEntityId, requireExactRecord, requireUtf8String, } from './codec.js';
 import { invalidProtocolFrame } from './errors.js';
 import { defineOperation } from './operation-spec.js';
-export const GOAL_RESULT_MAX_BYTES = 8 * 1024;
+export const GOAL_RESULT_MAX_BYTES = 16 * 1024;
+/** Display bounds; canonical ShellRun references fit in full. */
+export const GOAL_EVENT_WAIT_SUMMARY_LIMITS = Object.freeze({
+    resourceIdBytes: 512,
+    reasonCodeBytes: 128,
+});
 const QUERY_ERRORS = [
     'host_not_ready',
     'host_draining',
@@ -31,6 +36,17 @@ const QUERY_ERRORS = [
 const CONTROL_ERRORS = [...QUERY_ERRORS, 'session_archived', 'operation_conflict'];
 const ARM_ERRORS = CONTROL_ERRORS;
 export const GOAL_OPERATION_SPECS = {
+    'goal.event-wait.cancel': defineOperation({
+        mode: 'control',
+        availability: 'ready',
+        errors: CONTROL_ERRORS,
+        decodeInput: decodeGoalEventWaitCancelInput,
+        decodeOutput: decodeGoalEventWaitCancelResult,
+        assertOutputForInput(input, output) {
+            if (input.sessionId !== output.sessionId)
+                throw invalidProtocolFrame('Wait cancellation belongs to another Session');
+        },
+    }),
     'goal.query': defineOperation({
         mode: 'query',
         availability: 'ready',
@@ -85,6 +101,7 @@ export function decodeGoalProjection(value) {
         'lastReason',
         'achievedAt',
         'pausedAt',
+        'eventWait',
     ]);
     const condition = requireUtf8String(record.condition, 'Goal condition', GOAL_CONDITION_TEXT_LIMIT.utf8Bytes);
     if (condition.length > GOAL_CONDITION_TEXT_LIMIT.codeUnits) {
@@ -107,6 +124,7 @@ export function decodeGoalProjection(value) {
         lastReason,
         achievedAt: requireNullableCount(record.achievedAt, 'Goal achievedAt'),
         pausedAt: requireNullableCount(record.pausedAt, 'Goal pausedAt'),
+        eventWait: record.eventWait === null ? null : decodeGoalEventWaitProjection(record.eventWait),
     };
 }
 function decodeGoalQueryInput(value) {
@@ -220,3 +238,103 @@ function requireNullableCount(value, label) {
         return null;
     return requireCount(value, label);
 }
+export function decodeGoalEventWaitProjection(value) {
+    const r = requireExactRecord(value, 'Goal event wait', [
+        'waitId',
+        'controlGeneration',
+        'waitRevision',
+        'resource',
+        'reason',
+        'deadlineAt',
+        'phase',
+        'observation',
+        'outcome',
+    ]);
+    const resource = requireExactRecord(r.resource, 'Wait resource', [
+        'providerId',
+        'resourceType',
+        'resourceId',
+    ]);
+    if (r.phase !== 'observing' && r.phase !== 'awaiting_admission')
+        throw invalidProtocolFrame('Invalid wait phase');
+    if (r.outcome !== null &&
+        r.outcome !== 'satisfied' &&
+        r.outcome !== 'invalidated' &&
+        r.outcome !== 'source_unavailable' &&
+        r.outcome !== 'expired')
+        throw invalidProtocolFrame('Invalid wait outcome');
+    let observation = null;
+    if (r.observation !== null) {
+        const o = requireExactRecord(r.observation, 'Wait observation', [
+            'state',
+            'lastObservedAt',
+            'reasonCode',
+        ]);
+        if (o.state !== 'checking' && o.state !== 'pending' && o.state !== 'unknown')
+            throw invalidProtocolFrame('Invalid observation state');
+        observation = {
+            state: o.state,
+            lastObservedAt: requireNullableCount(o.lastObservedAt, 'Observation time'),
+            reasonCode: o.reasonCode === null
+                ? null
+                : requireUtf8String(o.reasonCode, 'Observation reason', GOAL_EVENT_WAIT_SUMMARY_LIMITS.reasonCodeBytes),
+        };
+    }
+    if ((r.phase === 'observing' && (observation === null || r.outcome !== null)) ||
+        (r.phase === 'awaiting_admission' && (observation !== null || r.outcome === null)))
+        throw invalidProtocolFrame('Inconsistent wait phase');
+    const reason = requireNullableGoalReason(r.reason);
+    if (reason === null)
+        throw invalidProtocolFrame('Invalid wait reason');
+    return {
+        waitId: requireEntityId(r.waitId, 'waitId'),
+        controlGeneration: requireCount(r.controlGeneration, 'Control generation'),
+        waitRevision: requireCount(r.waitRevision, 'Wait revision'),
+        resource: {
+            providerId: requireWaitTypeId(resource.providerId, 'Wait provider'),
+            resourceType: requireWaitTypeId(resource.resourceType, 'Wait resource type'),
+            resourceId: requireUtf8String(resource.resourceId, 'Wait reference', GOAL_EVENT_WAIT_SUMMARY_LIMITS.resourceIdBytes),
+        },
+        reason,
+        deadlineAt: requireCount(r.deadlineAt, 'Wait deadline'),
+        phase: r.phase,
+        observation,
+        outcome: r.outcome,
+    };
+}
+function decodeGoalEventWaitCancelInput(value) {
+    const r = requireExactRecord(value, 'Wait cancellation', [
+        'sessionId',
+        'goalId',
+        'controlGeneration',
+        'waitId',
+        'expectedGoalRevision',
+    ]);
+    return {
+        sessionId: requireEntityId(r.sessionId, 'sessionId'),
+        goalId: requireEntityId(r.goalId, 'goalId'),
+        waitId: requireEntityId(r.waitId, 'waitId'),
+        controlGeneration: requireCount(r.controlGeneration, 'Control generation'),
+        expectedGoalRevision: requireCount(r.expectedGoalRevision, 'Goal revision'),
+    };
+}
+function decodeGoalEventWaitCancelResult(value) {
+    requireEncodedByteLimit(value, 'Wait cancellation result', GOAL_RESULT_MAX_BYTES);
+    const r = requireExactRecord(value, 'Wait cancellation result', ['sessionId', 'outcome', 'goal']);
+    if (r.outcome !== 'cancelled' &&
+        r.outcome !== 'already_cancelled' &&
+        r.outcome !== 'already_admitted' &&
+        r.outcome !== 'conflict')
+        throw invalidProtocolFrame('Invalid cancellation outcome');
+    const sessionId = requireEntityId(r.sessionId, 'sessionId');
+    const goal = r.goal === null ? null : decodeGoalProjection(r.goal);
+    if (goal && goal.sessionId !== sessionId)
+        throw invalidProtocolFrame('Wait cancellation Goal belongs to another Session');
+    return { sessionId, outcome: r.outcome, goal };
+}
+function requireWaitTypeId(value, label) {
+    const id = requireUtf8String(value, label, 128);
+    if (!/^[A-Za-z0-9_.-]{1,128}$/.test(id))
+        throw invalidProtocolFrame(`Invalid ${label}`);
+    return id;
+}

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

@@ -69,7 +69,13 @@ export const RUNTIME_HOST_PROTOCOL_VERSION = 0;
 // Increment when the same protocol version no longer guarantees safe Client-Host
 // interoperability. Mismatches are rejected before domain commands are admitted.
 // Re-check against main before merging; sibling PRs may use the same next epoch.
-export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 225;
+export const RUNTIME_HOST_COMPATIBILITY_EPOCH = 229;
+// 229: Session check-in proposes cards for unfinished work across Sessions.
+// 228: Executor catalog queries support per-agent filtering and process-free inventory.
+// Older peers reject the executorId and listOnly fields in the strict query decoder.
+// 227: Goal projections carry eventWait and support goal.event-wait.cancel.
+// Older peers cannot decode the wait summary or cancel a specific wait.
+// 226: assistant.allocate-workspace allocates a Host-owned fallback for projectless assistants.
 // 225: Goal successor transcript origins carry typed event-wait provenance.
 // Older peers reject the additional field in the strict stored-message decoder.
 // 224: Assistant conversation admission supports Inbox receipts without a model Turn,

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/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,7 +76,7 @@ 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;
@@ -104,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 };
@@ -113,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 ||
@@ -127,9 +129,12 @@ 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);
@@ -417,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({
@@ -467,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)
@@ -558,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))
@@ -830,7 +841,7 @@ export class HostEventWaitManager {
             eventKey: null,
             reason: null,
         };
-        decodeEventWaitRecord({
+        this.#decode({
             ...r,
             updatedAt: now,
             observation: {
@@ -958,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;
@@ -1095,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({
@@ -1103,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')
@@ -1264,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) }),
+            },
+        });
+    }
+}