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

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 {};

package/node_modules/@maka/runtime-host/dist/server/execution-composition.js

@@ -16,8 +16,10 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { readMatterRuntimeEvents } from '../assistant/proactive-matters/settlement-context.js';
 import { markAssistantBackgroundSessions } from '../assistant/background-sessions.js';
 import { PersonalAssistantService, ASSISTANT_LEGACY_PACKAGES } from '../assistant/service.js';
+import { assistantInputTurnId, legacyAssistantInputTurnId } from '../assistant/bot/turn-ids.js';
 import { createAssistantMessageReader } from './session-transcript-reader.js';
 import { createImageFileReader } from '@maka/runtime/image-file-reader';
 import { ChatImageDeliveryService } from './chat-image-delivery.js';
@@ -60,6 +62,9 @@ import { RuntimeReadModel } from '@maka/runtime/runtime-read-model';
 import { renderAgentSwarmSupervisorWake, shouldWakeAgentSwarmSupervisor, } from '@maka/runtime/agent-swarm-status-tool';
 import { SessionActivityRegistry } from '@maka/runtime/goal-turn-lifecycle';
 import { ShellRunProcessManager } from '@maka/runtime/shell-run-manager';
+import { ShellRunEventWaitAccess } from './shell-run-event-wait-access.js';
+import { ShellRunEventWaitAdapter } from './shell-run-event-wait-adapter.js';
+import { EventWaitAdapterRegistry } from './event-wait-adapter.js';
 import { resolveShellPlan, resolveTurnShellPlan, validateShellPreference, } from '@maka/runtime/shell-detect';
 import { Context } from '@maka/runtime/plugin-kernel';
 import { PluginAgentService } from '@maka/runtime/plugin-agent-service';
@@ -109,12 +114,13 @@ import { HostConnectionEffectCoordinator } from './connection-effect-coordinator
 import { HostChangeFeed } from './host-change-feed.js';
 import { HostConfigurationCoordinator } from './configuration-coordinator.js';
 import { HostPromptSuggestionCoordinator, supportsPromptSuggestion } from './prompt-suggestion.js';
+import { checkinSessionState, HostSessionCheckinCoordinator, listCheckinCatalogSessions, } from './session-checkin.js';
 import { HostContextCoordinator } from './context-coordinator.js';
 import { HostClientCapabilityCoordinator } from './client-capability-coordinator.js';
 import { HostDailyReviewCoordinator } from './daily-review-coordinator.js';
 import { prepareHostAiSdkBackend } from './execution-model-composition.js';
 import { createInteractiveRunComposer, createInteractiveRunComposerFactory, routeInteractiveRunToolSurface, } from './interactive-run-composer.js';
-import { createHostGoalEvaluator, createHostDailyReviewModel, createHostMemoryExtractionModel, createHostPluginModel, createHostSessionEffectModel, createHostPromptSuggestionModel, } from './execution-model-authority.js';
+import { createHostGoalEvaluator, createHostDailyReviewModel, createHostMemoryExtractionModel, createHostPluginModel, createHostSessionEffectModel, createHostPromptSuggestionModel, createHostCheckinModel, resolveDefaultModelHeader, } from './execution-model-authority.js';
 import { HostExecutionInspectCoordinator } from './execution-inspect-coordinator.js';
 import { HostExternalSessionCoordinator } from './external-session-coordinator.js';
 import { boundedFailureDiagnostic } from './failure-diagnostic.js';
@@ -143,6 +149,7 @@ import { join } from 'node:path';
 import { toRuntimePolicyProxy } from './runtime-policy-proxy.js';
 import { AcpSetupError } from './acp/connection.js';
 import { installAntigravity } from './acp/antigravity-install.js';
+import { ANTIGRAVITY_ACP_EXECUTOR_ID } from '@maka/antigravity-acp-plugin';
 import { createProxiedFetchTransport } from '@maka/runtime/network/scoped-fetch-transport';
 import { HostExternalAgentSetupCoordinator } from './external-agent-setup-coordinator.js';
 import { HostOAuthCoordinator } from './oauth-coordinator.js';
@@ -163,6 +170,7 @@ import { startHostModelMetadataRefresh } from './model-metadata-refresh.js';
 import { HostRuntimeResourceCoordinator } from './runtime-resource-coordinator.js';
 import { SessionAdmissionGate } from './session-admission-gate.js';
 import { workHubResultOrigin } from './workhub-result-coordinator.js';
+import { HostPersonalAssistantWorkspace } from './personal-assistant-workspace.js';
 import { HostSessionCatalogCoordinator } from './session-catalog-coordinator.js';
 import { SessionBackgroundActivityProjection } from './session-background-activity.js';
 import { SessionInteractionActivityProjection } from './session-interaction-activity.js';
@@ -171,6 +179,7 @@ import { HostSessionRetirementCoordinator } from './session-retirement-coordinat
 import { HostStorageMaintenance } from './storage-maintenance.js';
 import { HostStorageUsageCoordinator } from './storage-usage-coordinator.js';
 import { HostArchiveRetentionCoordinator } from './archive-retention-coordinator.js';
+import { createHostSessionCheckpointPublication, } from './session-checkpoint-publication.js';
 import { HostSessionRevisionCoordinator } from './session-revision-coordinator.js';
 import { HostSessionEffectCoordinator } from './session-effect-coordinator.js';
 import { SessionContinuityCoordinator } from './session-continuity-coordinator.js';
@@ -226,6 +235,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
     let graphClient;
     let sessionEffects;
     let promptSuggestions;
+    let checkins;
     let memoryExtraction;
     let imageDelivery;
     let unsubscribeTranscriptChanges;
@@ -240,6 +250,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
     let invalidatePluginExecutorBackends = () => undefined;
     let modelMetadataRefresh;
     let archiveEvidence;
+    let sessionCheckpoints;
     try {
         const pluginRoot = new Context();
         const pluginAgents = new PluginAgentService(pluginRoot);
@@ -295,9 +306,20 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     ...(header.executorConfig ? { configuration: header.executorConfig } : {}),
                 });
             }
-            return pluginExecutors.catalog({ cwd: input.cwd, refresh: input.refresh });
+            return pluginExecutors.catalog({
+                cwd: input.cwd,
+                refresh: input.refresh,
+                executorId: input.executorId,
+                listOnly: input.listOnly,
+            });
         });
         const personalAssistant = (assistant = new PersonalAssistantService(join(context.owner.controlDirectory, 'personal-assistant'), {
+            prepareBotWake: async (ownerId, workerId) => {
+                if (await interactions.hasPendingSession(workerId))
+                    return 'deferred';
+                return sessionCatalog.synchronizeAssistantBotModel(ownerId, workerId);
+            },
+            allocateWorkspace: () => assistantWorkspace.allocate(),
             stopSessions: async () => {
                 if (!rootCoordinator)
                     return;
@@ -344,6 +366,9 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 });
             },
             markBackgroundSessions: (ids) => markAssistantBackgroundSessions(stores.sessionStore, ids),
+            readRuntimeEvents: async (sessionId, runId) => runId
+                ? readMatterRuntimeEvents(stores.runtimeEventStore, sessionId, runId)
+                : (await stores.runtimeEventStore.readSessionRuntimeEventEntries(sessionId)).map((entry) => entry.event),
             agents: pluginAgents,
             llm: pluginLlm,
             sessionQuery: pluginSessionQuery,
@@ -879,13 +904,15 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         continuity = new SessionContinuityCoordinator(context.hostEpoch, (sessionId) => canonicalProjectionReader.read(sessionId), sessionAdmission, context.requestDrain, transcriptReader, async (sessionId, attention) => {
             if (attention) {
                 try {
-                    if ((await runtimePolicyStores.runtimePolicy.getSnapshot()).policy.privacy.incognitoActive) {
+                    const header = await stores.sessionStore.readHeaderSnapshot(sessionId);
+                    if (header.labels?.includes(ASSISTANT_BACKGROUND_SESSION_LABEL) ||
+                        (await runtimePolicyStores.runtimePolicy.getSnapshot()).policy.privacy.incognitoActive) {
                         attention = undefined;
                     }
                 }
                 catch (error) {
                     attention = undefined;
-                    console.warn('[runtime-host] Could not read notification privacy policy', error);
+                    console.warn('[runtime-host] Could not read notification policy', error);
                 }
             }
             hostChanges.publishSessionCatalog(sessionId, attention);
@@ -927,6 +954,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         let domainModuleDrainBegun = false;
         const beginDrain = () => {
             draining = true;
+            sessionCheckpoints?.beginDrain();
             if (!domainModules || domainModuleDrainBegun)
                 return;
             domainModuleDrainBegun = true;
@@ -1022,19 +1050,24 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 ...(scheduledTaskTool ? { scheduledTaskTool } : {}),
                 planStore,
                 goalTools: requireGoal(goal).tools,
+                eventWaitAvailable: () => backendContext.header.toolMode !== 'code_mode' &&
+                    ['active', 'waiting'].includes(requireGoal(goal).manager.get(backendContext.sessionId)?.status ?? ''),
                 builtinTools,
                 hostTools,
                 resolveToolCeiling: (sessionId) => personalAssistant.toolCeiling(sessionId),
                 resolveRootTools: async (sessionId) => {
                     await assertAssistantSessionEnabled(sessionId);
                     return [
-                        ...personalAssistant.tools,
+                        ...personalAssistant.filterTools(sessionId, personalAssistant.tools),
                         ...(sessionId === WORKHUB_COORDINATION_SESSION_ID && workHubResults && workHubInspection
                             ? [workHubResults.tool, workHubInspection]
                             : await requireGraphCoordinator(graphCoordinator).toolsForSession(sessionId)),
                     ];
                 },
-                resolvePluginTools: (sessionId, coreTools) => pluginTools.resolveContributions(sessionId, coreTools),
+                resolvePluginTools: (sessionId, coreTools) => {
+                    const resolved = pluginTools.resolveContributions(sessionId, coreTools);
+                    return { ...resolved, tools: personalAssistant.filterTools(sessionId, resolved.tools) };
+                },
                 resolvePluginSystemPrompt: async (sessionId, promptContext, baseText) => {
                     const assembly = await pluginSystemPrompt.assemble({
                         sessionId,
@@ -1190,7 +1223,10 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 const [graphTools, planState] = await Promise.all([
                     (sessionId === WORKHUB_COORDINATION_SESSION_ID && workHubResults && workHubInspection
                         ? Promise.resolve([workHubResults.tool, workHubInspection])
-                        : requireGraphCoordinator(graphCoordinator).toolsForSession(sessionId)).then((tools) => [...personalAssistant.tools, ...tools]),
+                        : requireGraphCoordinator(graphCoordinator).toolsForSession(sessionId)).then((tools) => [
+                        ...personalAssistant.filterTools(sessionId, personalAssistant.tools),
+                        ...tools,
+                    ]),
                     planStore.readState(sessionId),
                 ]);
                 const { runtimePolicy, surface } = await resolveInteractiveToolSurface({
@@ -1524,7 +1560,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 context.requestDrain();
             },
             onSucceeded: () => {
-                pluginExecutors.invalidateCatalog();
+                pluginExecutors.invalidateCatalog(ANTIGRAVITY_ACP_EXECUTOR_ID);
                 hostChanges.publishConfiguration();
             },
             capabilities: clientCapabilities,
@@ -1621,6 +1657,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         };
         const pluginSessionSummary = (session) => Object.freeze({
             id: session.id,
+            isArchived: session.isArchived,
             ...(session.name ? { title: session.name } : {}),
             ...(session.cwd ? { cwd: session.cwd } : {}),
             ...(session.labels?.length ? { labels: session.labels } : {}),
@@ -1976,8 +2013,14 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             matchesActive: (sessionId, checkpoint, controlLease) => requireGoal(goal).matchesActive(sessionId, checkpoint, controlLease),
         });
         goalExecutions = goalExecutionCoordinator;
+        const shellRunWaitAccess = new ShellRunEventWaitAccess(openedShellRunStore, stores.runtimeEventStore);
         goal = new HostGoalCoordinator({
-            ...(dependencies.eventWaitSources ? { eventWaitSources: dependencies.eventWaitSources } : {}),
+            eventWaitSources: dependencies.eventWaitSources ?? {
+                adapters: new EventWaitAdapterRegistry([
+                    new ShellRunEventWaitAdapter(shellRunWaitAccess, shellRuns),
+                ]),
+                authorize: (wait, signal) => shellRunWaitAccess.authorize(wait, signal),
+            },
             store: openedGoalStore,
             stores,
             readSessionContext: async (sessionId) => {
@@ -2033,7 +2076,8 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         });
         async function applyRuntimePolicyMutationEffects() {
             try {
-                pluginExecutors.invalidateCatalog();
+                // Reconciliation replaces only changed agent configurations. Unrelated
+                // policy edits must not discard every provider's persistent catalog.
                 await builtinExternalAgentPlugins.reconcile();
                 await requireMemory(memory).refreshAfterPolicyMutation();
             }
@@ -2097,6 +2141,46 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 ? { sessionAccessAuthority: context.sessionAccessAuthority }
                 : {}),
         });
+        const sessionCheckins = new HostSessionCheckinCoordinator({
+            allowed: async () => !(await runtimePolicyStores.runtimePolicy.getSnapshot()).policy.privacy.incognitoActive,
+            listSessions: (context) => listCheckinCatalogSessions((input) => sessionCatalog.handlers['session.catalog.query'](input, context)),
+            readSession: async (session) => {
+                // The Todo read takes the Session's admission itself, so it cannot run inside this one.
+                const todos = (await sessionTodo.read(session.id)).items;
+                return sessionAdmission.run(session.id, async () => {
+                    const canonical = await canonicalProjectionReader.read(session.id);
+                    if (!canonical || canonical.session.isArchived)
+                        return undefined;
+                    await requireSessionManager(manager).ensureTranscriptLedgerForRead(session.id);
+                    const view = await recapReadModel.getSessionView(session.id);
+                    return checkinSessionState({
+                        session,
+                        canonical,
+                        todos,
+                        messages: view.messages,
+                        turns: view.turns,
+                    });
+                });
+            },
+            readModelTarget: () => resolveDefaultModelHeader(runtimePolicyStores),
+            generate: createHostCheckinModel({
+                runtimePolicy: runtimePolicyStores,
+                oauthCredentials,
+                usage: openedUsageStores,
+                requestDrain: context.requestDrain,
+            }),
+        });
+        checkins = sessionCheckins;
+        const assistantWorkspace = new HostPersonalAssistantWorkspace({
+            stateRoot: context.owner.capability.canonicalPath,
+            ...(options.assistantHomeDirectory ? { homeDirectory: options.assistantHomeDirectory } : {}),
+            projects: openedProjectCatalog,
+            membership: projectMembership,
+            projectChanged: () => hostChanges.publishProjectCatalog(),
+            preflightSessionCreation: async () => {
+                await sessionCatalog.resolveDefaultCreateTarget();
+            },
+        });
         const workHubTargetExecution = new HostWorkHubTargetExecutionAuthority({
             readSession: (sessionId) => stores.sessionStore.readHeaderRecordSnapshot(sessionId),
             runtimePolicy: {
@@ -2610,6 +2694,15 @@ export async function createExecutionRuntimeHostComposition(context, options = {
             catalog: stores.sessionStore,
             retirement: sessionRetirement,
         });
+        sessionCheckpoints = await createHostSessionCheckpointPublication({
+            context,
+            stores,
+            admission: sessionAdmission,
+            manager: requireSessionManager(manager),
+            shellRuns: openedShellRunStore,
+            isSessionIdle: (sessionId) => rootRecoveryCompleted && !draining && coordinator.isSessionExecutionIdle(sessionId),
+            options: dependencies.checkpointPublication,
+        });
         const storageMaintenance = new HostStorageMaintenance({
             artifacts: openedArtifactStore,
             contextOffload: openedContextOffloadStore,
@@ -2843,7 +2936,9 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                                 return result;
                             // Canonical receipts remain queryable even while the feature is disabled.
                             const visible = new Set((await stores.sessionStore.readMessagesSnapshot(input.sessionId))
-                                .filter((row) => row.type === 'user' && row.turnId === `assistant-input:${row.id}`)
+                                .filter((row) => row.type === 'user' &&
+                                (row.turnId === assistantInputTurnId(row.id) ||
+                                    row.turnId === legacyAssistantInputTurnId(row.id)))
                                 .map((row) => row.id));
                             return {
                                 ok: true,
@@ -2908,6 +3003,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     interactions.handlers,
                     sessionEffectCoordinator.handlers,
                     promptSuggestionCoordinator.handlers,
+                    sessionCheckins.handlers,
                     continuityCoordinator.handlers,
                     runtimeResources.handlers,
                     contextOperations.handlers,
@@ -2938,6 +3034,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     () => interactions.beginDrain(),
                     () => sessionEffects?.beginDrain(),
                     () => promptSuggestions?.beginDrain(),
+                    () => checkins?.beginDrain(),
                 ],
                 close: [
                     async () => {
@@ -2953,6 +3050,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                     () => workspaceExecution?.close(),
                     () => sessionEffects?.close(),
                     () => promptSuggestions?.close(),
+                    () => checkins?.close(),
                     () => messages.close(),
                     () => interactions.close(),
                     () => turnAccessRequests?.close(),
@@ -3022,6 +3120,12 @@ export async function createExecutionRuntimeHostComposition(context, options = {
                 catch (error) {
                     errors.push(error);
                 }
+                try {
+                    await sessionCheckpoints?.close();
+                }
+                catch (error) {
+                    errors.push(error);
+                }
                 try {
                     await closeRuntimeHostDomainModules(domainModules);
                 }
@@ -3044,6 +3148,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         };
         return {
             handlers,
+            sessionCheckpoints,
             moduleIds: Object.freeze(domainModules.map(({ id }) => id)),
             workspaceExecution: requireWorkspaceExecution(workspaceExecution),
             plugins: pluginPlatform,
@@ -3128,6 +3233,12 @@ export async function createExecutionRuntimeHostComposition(context, options = {
     }
     catch (error) {
         const errors = [error];
+        try {
+            await sessionCheckpoints?.close();
+        }
+        catch (closeError) {
+            errors.push(closeError);
+        }
         archiveEvidence?.close();
         try {
             await modelMetadataRefresh?.close();
@@ -3153,6 +3264,7 @@ export async function createExecutionRuntimeHostComposition(context, options = {
         try {
             await sessionEffects?.close();
             await promptSuggestions?.close();
+            await checkins?.close();
         }
         catch (closeError) {
             errors.push(closeError);

package/node_modules/@maka/runtime-host/dist/server/execution-model-authority.js

@@ -215,6 +215,43 @@ export function createHostPromptSuggestionModel(input) {
         return result.finishReason === 'length' ? undefined : result.text;
     };
 }
+const CHECKIN_MAX_OUTPUT_TOKENS = 2_048;
+const CHECKIN_REASONING_MAX_OUTPUT_TOKENS = 8_192;
+/**
+ * Creates the root-scoped check-in call. It reads many Sessions, so it runs on
+ * the user's default model (resolved by the coordinator before any read)
+ * rather than borrowing any one Session's.
+ */
+export function createHostCheckinModel(input) {
+    const authority = createAuxiliaryModelCallAuthority(input);
+    return async ({ target, prompt, abortSignal, }) => {
+        try {
+            const callId = authority.newId();
+            const result = await runHostAuxiliaryModelCall(authority, {
+                transportContextId: callId,
+                header: target,
+                callKind: 'session_checkin',
+                callId: `session_checkin_${callId}`,
+                abortSignal,
+                reasoning: 'least',
+                buildRequest: (_target, thinkingLevel) => ({
+                    prompt,
+                    maxOutputTokens: thinkingLevel === 'off'
+                        ? CHECKIN_MAX_OUTPUT_TOKENS
+                        : CHECKIN_REASONING_MAX_OUTPUT_TOKENS,
+                    maxRetries: 0,
+                }),
+            });
+            return result.finishReason === 'length'
+                ? { ok: false, errorClass: 'invalid_response' }
+                : { ok: true, text: result.text };
+        }
+        catch (error) {
+            const errorClass = auxiliaryModelErrorClass(error, abortSignal);
+            return { ok: false, errorClass: errorClass === 'persistence' ? 'unknown' : errorClass };
+        }
+    };
+}
 /** Creates tool-free Session title and recap calls on canonical Host model authority. */
 export function createHostSessionEffectModel(input) {
     const authority = createAuxiliaryModelCallAuthority(input);
@@ -649,14 +686,21 @@ async function resolveDailyReviewHeader(runtimePolicy, modelKey) {
             thinkingLevel: 'off',
         };
     }
+    const header = await resolveDefaultModelHeader(runtimePolicy);
+    if (!header) {
+        throw new AuxiliaryModelCallConfigurationError('Daily Review has no canonical default model target');
+    }
+    return header;
+}
+/** The connection and model the user chose as default, or undefined when none is set. */
+export async function resolveDefaultModelHeader(runtimePolicy) {
     const catalog = await runtimePolicy.connectionCatalog.getSnapshot();
     const target = catalog.defaultTarget;
     const connection = target
         ? catalog.connections.find((candidate) => candidate.connectionId === target.connectionId)
         : undefined;
-    if (!target || !connection) {
-        throw new AuxiliaryModelCallConfigurationError('Daily Review has no canonical default model target');
-    }
+    if (!target || !connection)
+        return undefined;
     return {
         llmConnectionId: connection.connectionId,
         llmConnectionSlug: connection.slug,

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

@@ -25,6 +25,8 @@ import { buildGoalTools } from '@maka/runtime/goal-tools';
 import { isSessionNotFoundError } from '@maka/storage/execution-stores';
 import { authenticateInteractiveGoalAuthorityWriter, } from '@maka/storage/goal-authority';
 import { projectGoalState } from './goal-projection.js';
+import { GOAL_EVENT_WAIT_SUMMARY_LIMITS, } from '../protocol/goal.js';
+import { truncateUtf8 } from '@maka/core/diagnostic-log';
 import { waitForHostedExecutionTerminal } from './hosted-execution-wait.js';
 import { goalTurnOutcomeFromHostedExecution } from './goal-execution-coordinator.js';
 import { buildGoalEvaluationContext } from './goal-evaluation-context.js';
@@ -34,6 +36,7 @@ export class HostGoalCoordinator {
         'goal.query': (input) => this.#query(input.sessionId),
         'goal.arm': (input) => this.#arm(input),
         'goal.control': (input) => this.#control(input),
+        'goal.event-wait.cancel': (input) => this.#cancelEventWait(input),
     };
     manager;
     continuation;
@@ -139,6 +142,7 @@ export class HostGoalCoordinator {
                     agentRunStore: options.stores.agentRunStore,
                 },
                 authority: (sessionId) => this.#authorityBySession.get(sessionId),
+                changed: this.#onProjectionChanged,
                 mutate: (sessionId, operation) => this.#mutateWait(sessionId, operation),
                 settleAdditional: (sessionId, tokensNow, controlLease) => this.#mutateGoal(async () => {
                     const goal = this.manager.get(sessionId);
@@ -158,8 +162,9 @@ export class HostGoalCoordinator {
                 gate: (sessionId) => this.continuation.gateEventWait(sessionId),
                 canRegister: (sessionId, turnId) => this.continuation.mutationStanding(sessionId, turnId).kind === 'held',
                 deliver: (pending) => this.continuation.recoverPendingContinuation(pending),
-                pause: (sessionId, reason, controlLease) => this.#mutateGoal(async () => {
-                    if (!this.manager.matchesControlLease(sessionId, controlLease))
+                pause: (sessionId, reason, controlLease, waitId) => this.#mutateGoal(async () => {
+                    if (!this.manager.matchesControlLease(sessionId, controlLease) ||
+                        this.#authorityBySession.get(sessionId)?.record.activeEventWait?.waitId !== waitId)
                         return;
                     this.manager.pause(sessionId, { reason });
                     this.continuation.invalidateSession(sessionId);
@@ -245,8 +250,125 @@ export class HostGoalCoordinator {
         await this.eventWaitBridge?.start();
     }
     readProjection(sessionId) {
+        // Canonical/query callers hold the Session lane. Do not wait for the
+        // mutation lane here: a committed wait write can have a delayed receipt
+        // while Root admission must still publish and start. #project rechecks the
+        // adopted binding after I/O and excludes durably admitted/suppressed waits.
+        return this.#project(sessionId);
+    }
+    async #project(sessionId) {
+        const authority = this.#authorityBySession.get(sessionId);
+        const gate = authority?.record.activeEventWait;
+        const wait = gate && this.#stores.eventWaitStore
+            ? await this.#stores.eventWaitStore.read({ sessionId, waitId: gate.waitId })
+            : undefined;
         const goal = this.manager.get(sessionId);
-        return goal ? projectGoalState(goal) : null;
+        if (!goal)
+            return null;
+        const projection = projectGoalState(goal);
+        const current = this.#authorityBySession.get(sessionId);
+        if (!wait ||
+            !gate ||
+            !current ||
+            current.record.activeEventWait?.waitId !== gate.waitId ||
+            !sameGoalControlLease(current.record.controlLease, wait.record.goalControlLease) ||
+            !this.manager.matchesControlLease(sessionId, wait.record.goalControlLease) ||
+            wait.record.delivery ||
+            wait.record.status === 'cancelled' ||
+            !['active', 'waiting'].includes(goal.status))
+            return projection;
+        const r = wait.record, observation = r.observation;
+        // Checking is an attempt reservation, not a new source fact. Its retained
+        // checkpoint describes the last completed observation until this read settles.
+        const observationOutcome = observation?.outcome === 'checking' && observation.lastObservedAt !== null
+            ? observation.consecutiveErrors > 0
+                ? 'unknown'
+                : 'pending'
+            : observation?.outcome;
+        return {
+            ...projection,
+            eventWait: {
+                waitId: r.waitId,
+                controlGeneration: r.goalControlLease.generation,
+                waitRevision: wait.authorityRevision,
+                resource: {
+                    providerId: r.resource.providerId,
+                    resourceType: r.resource.resourceType,
+                    resourceId: truncateUtf8(r.resource.resourceId, GOAL_EVENT_WAIT_SUMMARY_LIMITS.resourceIdBytes, '…'),
+                },
+                reason: gate.reason,
+                deadlineAt: r.deadlineAt,
+                phase: r.status === 'waiting' ? 'observing' : 'awaiting_admission',
+                observation: r.status !== 'waiting'
+                    ? null
+                    : {
+                        state: observationOutcome === 'unknown'
+                            ? 'unknown'
+                            : observationOutcome === 'pending'
+                                ? 'pending'
+                                : 'checking',
+                        lastObservedAt: observation?.lastObservedAt ?? null,
+                        reasonCode: observation?.reason
+                            ? truncateUtf8(observation.reason, GOAL_EVENT_WAIT_SUMMARY_LIMITS.reasonCodeBytes, '…')
+                            : null,
+                    },
+                outcome: r.status === 'resolved'
+                    ? r.resolution.outcome
+                    : r.status === 'expired'
+                        ? 'expired'
+                        : null,
+            },
+        };
+    }
+    #cancelEventWait(input) {
+        return this.#sessionAdmission.run(input.sessionId, () => this.#mutateGoal(async () => {
+            if (this.#draining)
+                return hostDraining();
+            let header;
+            try {
+                header = await this.#stores.sessionStore.readHeaderSnapshot(input.sessionId);
+            }
+            catch (error) {
+                if (isSessionNotFoundError(error))
+                    return notFound('Session does not exist');
+                throw error;
+            }
+            if (header.isArchived)
+                return sessionArchived('Archived Session cannot cancel a wait');
+            const wait = await this.#stores.eventWaitStore?.read({
+                sessionId: input.sessionId,
+                waitId: input.waitId,
+            });
+            const current = this.#authorityBySession.get(input.sessionId)?.record;
+            let outcome = 'conflict';
+            if (wait?.record.goalControlLease.goalId === input.goalId &&
+                wait.record.goalControlLease.generation === input.controlGeneration) {
+                if (wait.record.delivery?.kind === 'admitted')
+                    outcome = 'already_admitted';
+                else if (wait.record.status === 'cancelled' ||
+                    wait.record.delivery?.kind === 'suppressed')
+                    outcome = 'already_cancelled';
+                else if (current?.activeEventWait?.waitId === input.waitId &&
+                    current.goal.id === input.goalId &&
+                    current.controlLease.generation === input.controlGeneration &&
+                    current.goal.revision === input.expectedGoalRevision) {
+                    this.manager.pause(input.sessionId, {
+                        reason: 'Event wait cancelled. The background task keeps running.',
+                    });
+                    this.continuation.invalidateSession(input.sessionId);
+                    await this.#flushGoalPersistence();
+                    outcome = 'cancelled';
+                }
+            }
+            return {
+                ok: true,
+                result: {
+                    sessionId: input.sessionId,
+                    outcome,
+                    goal: await this.#project(input.sessionId),
+                },
+            };
+        }));
     }
     beginObservedTurn(sessionId, turnId) {
         return this.continuation.beginObservedTurn(sessionId, turnId);
@@ -391,7 +513,7 @@ export class HostGoalCoordinator {
             }
             return {
                 ok: true,
-                result: { sessionId, goal: this.readProjection(sessionId) },
+                result: { sessionId, goal: await this.readProjection(sessionId) },
             };
         });
     }