@abot-ai/runtime 1.3.1 → 1.5.0

package/dist/src/runtime/context/session-memory/controller.js

@@ -2,6 +2,7 @@ import { SESSION_MEMORY_CHECKPOINT_KIND, } from "../../../sessions/memory/contra
 import { assertValidSessionMemoryCheckpoint, resolveApplicableSessionMemoryCheckpoint, } from "../../../sessions/memory/rules.js";
 import { createSessionMemoryMessageReferences, resolveCoveredTurnCount, snapshotSessionMemorySource, } from "../../../sessions/memory/source.js";
 import { selectSessionMemoryProjection } from "./selection.js";
+import { validateRequestSessionMemorySnapshot, } from "./snapshot-state.js";
 export function createRequestSessionMemory(params) {
     return new RequestSessionMemoryController(params);
 }
@@ -13,11 +14,20 @@ class RequestSessionMemoryController {
     persistedCheckpointRevision;
     constructor(params) {
         this.params = params;
-        this.source = snapshotSessionMemorySource(params.session);
-        this.checkpoint = resolveApplicableSessionMemoryCheckpoint(params.session);
-        this.persistedCheckpointRevision = normalizeCheckpointRevision(params.session.sessionMemoryCheckpoint?.revision);
+        const state = resolveInitialSessionMemoryState(params);
+        this.source = state.source;
+        this.checkpoint = state.checkpoint;
+        this.persistedCheckpointRevision = state.persistedCheckpointRevision;
         this.now = params.now ?? (() => new Date());
     }
+    snapshot() {
+        return Object.freeze({
+            kind: "request_session_memory_v1",
+            source: this.source,
+            ...(this.checkpoint ? { checkpoint: this.checkpoint } : {}),
+            persistedCheckpointRevision: this.persistedCheckpointRevision,
+        });
+    }
     project() {
         return selectSessionMemoryProjection({
             sessionId: this.params.sessionId,
@@ -80,6 +90,17 @@ class RequestSessionMemoryController {
         });
     }
 }
+function resolveInitialSessionMemoryState(params) {
+    if ("snapshot" in params)
+        return validateRequestSessionMemorySnapshot(params.snapshot);
+    const checkpoint = resolveApplicableSessionMemoryCheckpoint(params.session);
+    return Object.freeze({
+        kind: "request_session_memory_v1",
+        source: snapshotSessionMemorySource(params.session),
+        ...(checkpoint ? { checkpoint } : {}),
+        persistedCheckpointRevision: normalizeCheckpointRevision(params.session.sessionMemoryCheckpoint?.revision),
+    });
+}
 function normalizeCheckpointRevision(revision) {
     if (revision === undefined ||
         !Number.isSafeInteger(revision) ||

package/dist/src/runtime/context/session-memory/selection.js

@@ -1,3 +1,4 @@
+import { isAssistantInitiativeMessage } from "../../../sessions/assistant-initiative.js";
 import { resolveCoveredTurnCount, } from "../../../sessions/memory/source.js";
 import { SESSION_MEMORY_PROTECTED_TURN_COUNT, } from "./contracts.js";
 import { buildSessionMemoryCheckpointMessage } from "./projection.js";
@@ -7,6 +8,12 @@ export function selectSessionMemoryProjection(params) {
         throw new Error("session_memory_checkpoint_coverage_invalid");
     }
     const uncoveredTurns = params.source.turns.slice(coveredTurnCount);
+    const uncoveredMessageIds = new Set(uncoveredTurns.flatMap(({ userMessages, assistant }) => [...userMessages, assistant].map(({ id }) => id)));
+    const historyMessages = params.source.historyMessages.filter(function retainsOriginalHistoryMessage(message) {
+        if (isAssistantInitiativeMessage(message))
+            return true;
+        return uncoveredMessageIds.has(message.id);
+    });
     const compactableTurnCount = Math.max(0, uncoveredTurns.length - SESSION_MEMORY_PROTECTED_TURN_COUNT);
     const priorConversationMessages = params.checkpoint
         ? Object.freeze([
@@ -15,10 +22,7 @@ export function selectSessionMemoryProjection(params) {
         : Object.freeze([]);
     return Object.freeze({
         priorConversationMessages,
-        historyMessages: Object.freeze(uncoveredTurns.flatMap(({ userMessages, assistant }) => [
-            ...userMessages.map(toRequestHistoryMessage),
-            toRequestHistoryMessage(assistant),
-        ])),
+        historyMessages: Object.freeze(historyMessages.map(toRequestHistoryMessage)),
         compactableTurnCount,
         checkpointRevision: params.checkpoint?.revision ?? 0,
         sourceRevision: params.source.sourceRevision,
@@ -31,5 +35,6 @@ function toRequestHistoryMessage(message) {
         content: message.content,
         createdAt: message.createdAt,
         ...(message.requestId ? { requestId: message.requestId } : {}),
+        ...(isAssistantInitiativeMessage(message) ? { assistantInitiativeId: message.initiative.proposalId } : {}),
     });
 }

package/dist/src/runtime/context/session-memory/snapshot-state.d.ts

@@ -0,0 +1,9 @@
+import type { SessionMemoryCheckpoint } from "../../../sessions/memory/contracts.js";
+import { type SessionMemorySourceSnapshot } from "../../../sessions/memory/source.js";
+export type RequestSessionMemorySnapshot = Readonly<{
+    kind: "request_session_memory_v1";
+    source: SessionMemorySourceSnapshot;
+    checkpoint?: SessionMemoryCheckpoint;
+    persistedCheckpointRevision: number;
+}>;
+export declare function validateRequestSessionMemorySnapshot(snapshot: RequestSessionMemorySnapshot): RequestSessionMemorySnapshot;

package/dist/src/runtime/context/session-memory/snapshot-state.js

@@ -0,0 +1,21 @@
+import { isDeepStrictEqual } from "node:util";
+import { assertValidSessionMemoryCheckpoint } from "../../../sessions/memory/rules.js";
+import { resolveCoveredTurnCount, snapshotSessionMemorySource, } from "../../../sessions/memory/source.js";
+export function validateRequestSessionMemorySnapshot(snapshot) {
+    if (snapshot?.kind !== "request_session_memory_v1")
+        throw new Error("session_memory_snapshot_invalid");
+    if (!Number.isSafeInteger(snapshot.persistedCheckpointRevision))
+        throw new Error("session_memory_snapshot_revision_invalid");
+    if (snapshot.persistedCheckpointRevision < 0)
+        throw new Error("session_memory_snapshot_revision_invalid");
+    const source = snapshotSessionMemorySource({
+        messages: [...snapshot.source.historyMessages],
+    });
+    if (!isDeepStrictEqual(source, snapshot.source))
+        throw new Error("session_memory_snapshot_source_invalid");
+    if (snapshot.checkpoint)
+        assertValidSessionMemoryCheckpoint(snapshot.checkpoint);
+    if (resolveCoveredTurnCount(source, snapshot.checkpoint) === undefined)
+        throw new Error("session_memory_snapshot_coverage_invalid");
+    return Object.freeze({ ...snapshot, source });
+}

package/dist/src/runtime/context/session-memory/snapshot.d.ts

@@ -0,0 +1,5 @@
+import type { CreateRequestSessionMemoryParams, RequestSessionMemory } from "./contracts.js";
+import type { RequestSessionMemorySnapshot } from "./snapshot-state.js";
+export type { RequestSessionMemorySnapshot } from "./snapshot-state.js";
+export declare function captureRequestSessionMemory(memory: RequestSessionMemory): RequestSessionMemorySnapshot;
+export declare function restoreRequestSessionMemory(snapshot: RequestSessionMemorySnapshot, params: Omit<CreateRequestSessionMemoryParams, "session" | "snapshot">): RequestSessionMemory;

package/dist/src/runtime/context/session-memory/snapshot.js

@@ -0,0 +1,9 @@
+import { createRequestSessionMemory } from "./controller.js";
+export function captureRequestSessionMemory(memory) {
+    if (!memory.snapshot)
+        throw new Error("session_memory_snapshot_unavailable");
+    return memory.snapshot();
+}
+export function restoreRequestSessionMemory(snapshot, params) {
+    return createRequestSessionMemory({ ...params, snapshot });
+}

package/dist/src/runtime/context/tool-media-projection.d.ts

@@ -0,0 +1,10 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import type { ModelStep } from "../../shared/model-steps.js";
+import type { RequestToolMediaStore } from "../attachments/request-tool-media.js";
+/** Hydrates only exact original evidence in the producing role's existing lane. */
+export declare function projectToolMediaMessages(params: {
+    messages: readonly ChatMessage[];
+    store?: RequestToolMediaStore;
+    modelStep: ModelStep;
+    supportsImages: boolean;
+}): ChatMessage[];

package/dist/src/runtime/context/tool-media-projection.js

@@ -0,0 +1,97 @@
+import { isToolResultMedia } from "../../capabilities/tool-media.js";
+/** Hydrates only exact original evidence in the producing role's existing lane. */
+export function projectToolMediaMessages(params) {
+    if (!isToolMediaConsumer(params.modelStep))
+        return [...params.messages];
+    return params.messages.map((message) => projectMessage(message, params));
+}
+function isToolMediaConsumer(step) {
+    return ["execution.decision", "execution.response", "worker.decision", "worker.result"].includes(step);
+}
+function projectMessage(message, params) {
+    const content = readRecord(message.content);
+    if (!content)
+        return message;
+    const evidence = readOriginalEvidence(message, content, params.modelStep);
+    if (!evidence.length)
+        return message;
+    const mediaDelivery = {
+        kind: "runtime_tool_media_delivery_v1",
+        authority: "passive_tool_evidence_not_user_intent",
+        status: params.supportsImages ? "delivered" : "unsupported_image_input",
+        ...(params.supportsImages ? {} : { message: "This model cannot receive the tool images. Image references are not visual evidence; use available text or report this limitation." }),
+    };
+    const attachments = [];
+    for (const item of evidence) {
+        for (const reference of item.media) {
+            if (!params.store)
+                throw new Error("tool_media_store_unavailable");
+            const owner = params.store.ownerOf(item.executionId, reference);
+            if (item.callId && item.callId !== owner.callId)
+                throw new Error("tool_media_call_mismatch");
+            const data = params.store.resolve(owner, reference);
+            if (!params.supportsImages)
+                continue;
+            attachments.push({
+                id: reference.id, kind: "image", mimeType: reference.mimeType,
+                storageRef: "request-tool-media", size: reference.size, data,
+                toolEvidence: { executionId: item.executionId },
+            });
+        }
+    }
+    if (message.toolCalls)
+        throw new Error("tool_media_lane_invalid");
+    return {
+        ...message,
+        content: JSON.stringify({ ...content, mediaDelivery }),
+        ...(attachments.length ? { attachments } : {}),
+    };
+}
+function readOriginalEvidence(message, content, step) {
+    if (message.role === "tool") {
+        if (!step.startsWith("execution."))
+            return [];
+        if (content.kind !== "runtime_execution_capability_result_v1")
+            return [];
+        const result = record(content.result);
+        if (!result || result.executionId !== message.toolCallId)
+            throw new Error("tool_media_result_binding_invalid");
+        return readExecutionEvidence(result);
+    }
+    if (!step.startsWith("worker.") || message.role !== "user")
+        return [];
+    if (content.kind !== "runtime_request_tool_results_v1")
+        return [];
+    if (!Array.isArray(content.results))
+        return [];
+    return content.results.flatMap((entry) => {
+        const result = record(entry);
+        return result ? readExecutionEvidence(result) : [];
+    });
+}
+function readExecutionEvidence(result) {
+    const adapter = record(result.adapterResult);
+    if (adapter?.kind !== "registered_tool_execution_result_v1")
+        return [];
+    const original = record(adapter.result);
+    if (!original || original.media === undefined)
+        return [];
+    if (!isToolResultMedia(original.media) || typeof result.executionId !== "string")
+        throw new Error("tool_media_result_invalid");
+    if (!original.media?.length)
+        return [];
+    return [{ executionId: result.executionId, ...(typeof result.callId === "string" ? { callId: result.callId } : {}), media: original.media }];
+}
+function record(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function readRecord(value) {
+    try {
+        return record(JSON.parse(value));
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/src/runtime/default-environment-adapters.js

@@ -1,3 +1,4 @@
+import { loadRuntimeCapabilityPlugins } from "./plugins/runtime-capability-plugins.js";
 import { join } from "node:path";
 import { buildContextBuckets, buildContextWindow } from "../sessions/index.js";
 import { createModelGatewayClient, embedModelGateway, invokeModelGateway, invokeRawModelGateway, } from "../model-gateway/client.js";
@@ -9,7 +10,7 @@ import { createSourceWorkspaceProvider } from "./adapters/source-workspace-provi
 import { createRuntimeEventBus } from "./events/runtime-emitter.js";
 import { configureDebugLogger } from "./observability/debug-logger.js";
 import { createConfiguredToolRegistry } from "./capabilities/configured-tool-registry.js";
-import { loadBundledRuntimePlugins, loadConfiguredRuntimePlugins, runtimePluginsToToolModules, } from "./plugins/loader.js";
+import { runtimePluginsToToolModules } from "./plugins/loader.js";
 import { createSchedulingToolModule } from "./capabilities/scheduling/tool-module.js";
 import { createFileLongTermMemoryRepository } from "./adapters/long-term-memory/file-repository.js";
 import { createInMemoryLongTermMemoryRepository } from "./adapters/long-term-memory/in-memory-repository.js";
@@ -29,9 +30,7 @@ export function createDefaultConversationContextProvider() {
     };
 }
 export function createDefaultToolRegistry(config, scheduling) {
-    const plugins = config
-        ? loadConfiguredRuntimePlugins(config)
-        : loadBundledRuntimePlugins();
+    const plugins = loadRuntimeCapabilityPlugins(config);
     return createConfiguredToolRegistry(config, [
         ...runtimePluginsToToolModules(plugins),
         ...(config && scheduling

package/dist/src/runtime/lifecycle/request-finalizer.d.ts

@@ -5,6 +5,7 @@ import { RequestLifecycle } from "../orchestration/lifecycle/request-lifecycle.j
 import type { RequestObservation, RequestOutputTextMode } from "../request/result.js";
 import type { RequestSessionStore } from "../request/session-store.js";
 import type { LongTermMemoryService, MemoryCandidate } from "../long-term-memory/contracts.js";
+import type { SessionTerminalMessage } from "../../sessions/request-lifecycle/contracts.js";
 type RequestFinalizationResult = {
     status: "completed";
     output: string;
@@ -21,6 +22,7 @@ export declare function finalizeRequest(params: {
     outputTextMode?: RequestOutputTextMode;
     events: EventSink;
     lifecycle: RequestLifecycle;
+    claimFinalization?: () => void;
     sessionStore: Pick<RequestSessionStore, "appendMessage">;
     sessionId: string;
     requestId: string;
@@ -29,5 +31,7 @@ export declare function finalizeRequest(params: {
     finalObservation?: RequestObservation;
     memoryCandidates?: readonly MemoryCandidate[];
     longTermMemory?: LongTermMemoryService;
+    composeInvalidFinalOutput?: () => Promise<string>;
+    persistResponse?: (message: SessionTerminalMessage) => Promise<void>;
 }): Promise<RequestFinalizationResult>;
 export {};

package/dist/src/runtime/lifecycle/request-finalizer.js

@@ -1,29 +1,43 @@
+import { throwIfRequestCancelled } from "../request/cancellation.js";
 import { finalizeResponse } from "../orchestration/final-response/finalization.js";
 import { scheduleFinalResponseMemory } from "../long-term-memory/finalization.js";
+import { traceDebug } from "../observability/debug-logger.js";
 export function failRequest(params) {
     params.events.event("thinking.completed");
     params.events.failed(params.error, params.details);
 }
 export async function finalizeRequest(params) {
-    if (!params.rawOutput.trim()) {
-        failRequest({
-            events: params.events,
-            error: "invalid_final_output",
-            details: {
-                reason: "empty_final_output",
-                stage: "chat_finalization",
-            },
+    throwIfRequestCancelled(params.lifecycle.signal);
+    const hasValidFinalOutput = params.rawOutput.trim().length > 0;
+    if (!hasValidFinalOutput) {
+        params.lifecycle.signal.throwIfAborted();
+        traceDebug("runtime.request", "final_output.invalid", {
+            requestId: params.requestId,
+            code: "invalid_final_output",
+            reason: "empty_final_output",
+            stage: "chat_finalization",
+            disposition: "degraded_authoring",
         });
-        return { status: "failed" };
     }
-    const output = params.outputTextMode === "exact"
-        ? params.rawOutput
-        : params.rawOutput.trim();
+    const output = await resolveFinalizationOutput(params.rawOutput, params.outputTextMode, params.lifecycle.signal, params.composeInvalidFinalOutput);
+    if (!hasValidFinalOutput)
+        params.lifecycle.signal.throwIfAborted();
+    const finalObservation = hasValidFinalOutput
+        ? params.finalObservation
+        : undefined;
+    const memoryCandidates = hasValidFinalOutput
+        ? params.memoryCandidates
+        : undefined;
     params.lifecycle.markProgress("valid_final_output");
     const finalizationState = { stage: "finalization" };
     params.lifecycle.updateState(finalizationState);
     params.events.runtimeState(finalizationState);
+    throwIfRequestCancelled(params.lifecycle.signal);
+    params.claimFinalization?.();
     await finalizeResponse({
+        ...(params.persistResponse
+            ? { persistResponse: params.persistResponse }
+            : {}),
         events: params.events,
         sessionStore: params.sessionStore,
         sessionId: params.sessionId,
@@ -32,15 +46,15 @@ export async function finalizeRequest(params) {
         output,
         grounding: "conversation",
         thinkingTrace: params.thinkingTrace,
-        ...(params.finalObservation
+        ...(finalObservation
             ? {
-                observationMeta: params.finalObservation.observationMeta,
-                observationContent: params.finalObservation.observationContent,
+                observationMeta: finalObservation.observationMeta,
+                observationContent: finalObservation.observationContent,
             }
             : {}),
         afterPersist: () => scheduleFinalResponseMemory({
             service: params.longTermMemory,
-            candidates: params.memoryCandidates,
+            candidates: memoryCandidates,
             requestId: params.requestId,
             sessionId: params.sessionId,
             onEvent: params.events.event.bind(params.events),
@@ -48,3 +62,18 @@ export async function finalizeRequest(params) {
     });
     return { status: "completed", output };
 }
+async function resolveFinalizationOutput(rawOutput, outputTextMode, signal, composeInvalidFinalOutput) {
+    const hasValidFinalOutput = rawOutput.trim().length > 0;
+    if (hasValidFinalOutput) {
+        return outputTextMode === "exact" ? rawOutput : rawOutput.trim();
+    }
+    const canComposeInvalidFinalOutput = composeInvalidFinalOutput !== undefined;
+    if (!canComposeInvalidFinalOutput)
+        throw new Error("invalid_final_output");
+    const authored = await composeInvalidFinalOutput();
+    signal.throwIfAborted();
+    const hasValidDegradedOutput = authored.trim().length > 0;
+    if (!hasValidDegradedOutput)
+        throw new Error("invalid_final_output");
+    return outputTextMode === "exact" ? authored : authored.trim();
+}

package/dist/src/runtime/local-application.d.ts

@@ -8,15 +8,59 @@ export type LocalRuntimeApplicationOptions = Readonly<{
 export declare function createLocalRuntimeApplication(config?: RuntimeConfig, options?: LocalRuntimeApplicationOptions): Readonly<{
     services: Readonly<{
         longTermMemory: import("./index.js").LongTermMemoryService;
+        passiveLearning: import("./local-host/client-learning.js").PassiveLearningManagement;
         sessions: import("./ports.js").SessionStore;
         attachments: import("./index.js").RuntimeAttachmentStore;
-        scheduler: Omit<import("./scheduler/contracts.js").SchedulerService, "stop" | "start">;
+        scheduler: Omit<import("./scheduler/contracts.js").SchedulerService, "start" | "stop">;
+        projects: Readonly<{
+            list: () => Promise<readonly import("./projects/contracts.js").RuntimeProject[]>;
+            get: (id: string) => Promise<import("./projects/contracts.js").RuntimeProject | null>;
+            create: (input: {
+                name?: string;
+                directory: string;
+            }) => Promise<import("./projects/contracts.js").RuntimeProject>;
+            browseFolders: (input?: {
+                path?: string;
+                cursor?: string;
+            }) => Promise<import("./projects/contracts.js").ProjectFolderPage>;
+            createSession: (projectId: string) => Promise<{
+                sessionId: string;
+                project: import("../sessions/project-binding.js").SessionProject;
+            }>;
+        }>;
         config: RuntimeConfig;
     }>;
     requests: RuntimeRequestHandler;
+    approvals: {
+        list: (sessionId?: string) => Promise<Readonly<{
+            sessionId: string;
+            run?: SchedulerRun;
+            request: import("./ports.js").ToolApprovalRequest;
+            wait?: Readonly<{
+                generation: string;
+                waitId: string;
+                revision: number;
+            }>;
+        }>[]>;
+        decide: (input: Readonly<{
+            sessionId: string;
+            requestId: string;
+            approvalId: string;
+            approved: boolean;
+            reason?: string;
+            generation?: string;
+            waitId?: string;
+            revision?: number;
+            commandId?: string;
+        }>) => Promise<import("./local-host/request-approval-contracts.js").LocalToolApprovalDecisionResult>;
+        attach: (requestId: string, sessionId: string, ws: Parameters<(ws: import("ws").default, message: import("./request/contracts.js").RunRequestMessage, options?: RuntimeRequestOptions) => Promise<import("./request/handler.js").RequestHandlerOutcome>>[0], options?: RuntimeRequestOptions, onAccepted?: () => void) => Promise<void>;
+    };
     start: () => Promise<void>;
     stop(): Promise<void>;
     getOwnership: () => "owner" | "client" | undefined;
+    isOwnerIdle: () => boolean;
+    stopIfIdle(): Promise<boolean>;
     subscribeScheduledEvents: (listener: (event: Record<string, unknown>) => void) => () => void;
+    subscribeLearningEvents: (listener: (event?: import("./passive-learning/contracts.js").LearningChangedEvent) => void) => () => void;
 }>;
 export type LocalRuntimeApplication = ReturnType<typeof createLocalRuntimeApplication>;

package/dist/src/runtime/local-application.js

@@ -6,22 +6,40 @@ import { createLocalRuntimeOwner } from "./local-host/app-owner.js";
 import { LocalRuntimeClientRequests } from "./local-host/client-requests.js";
 import { createLocalMemoryClient } from "./local-host/client-memory.js";
 import { createLocalServiceClients } from "./local-host/client-services.js";
+import { createLocalLearningClient } from "./local-host/client-learning.js";
 /** Managed library entry: attach to the environment owner or create it once. */
 export function createLocalRuntimeApplication(config = loadRuntimeConfig(), options = {}) {
     let connection;
     let startup;
+    let approvalConnection;
     let stopped = false;
     const call = async (method, args) => {
         await start();
         return connection.call(method, args);
     };
-    const client = new LocalRuntimeClientRequests(call, options.scheduledRequestOptions);
+    const client = new LocalRuntimeClientRequests(call, options.scheduledRequestOptions, async (method, args) => {
+        await start();
+        approvalConnection ??= attachApprovalConnection().finally(() => {
+            approvalConnection = undefined;
+        });
+        await approvalConnection;
+        return connection.call(method, args);
+    });
     const memory = createLocalMemoryClient(call, config.longTermMemory?.enabled === true);
+    const learning = createLocalLearningClient(call);
     const services = Object.freeze({
         config,
         ...createLocalServiceClients(call),
         longTermMemory: memory.service,
+        passiveLearning: learning.service,
     });
+    async function attachApprovalConnection() {
+        const reconnected = await connection.reconnect();
+        if (!reconnected)
+            return;
+        if (options.scheduledRequestOptions)
+            await connection.call("controls.register", []);
+    }
     async function connect() {
         const current = await createLocalRuntimeConnection({
             directory: join(config.paths.runtimeDir, "local-host"),
@@ -30,7 +48,10 @@ export function createLocalRuntimeApplication(config = loadRuntimeConfig(), opti
         });
         connection = current;
         try {
-            current.onClose(() => client.close(true));
+            current.onClose(() => {
+                client.close(true);
+                learning.close();
+            });
             current.setClientHandler(async (method, args) => {
                 if (method === "memory.event") {
                     memory.handleEvent(args);
@@ -38,7 +59,10 @@ export function createLocalRuntimeApplication(config = loadRuntimeConfig(), opti
                 }
                 return client.handleCallback(method, args);
             });
-            current.subscribe((event) => client.receive(event));
+            current.subscribe((event) => {
+                client.receive(event);
+                learning.receive(event);
+            });
             if (options.scheduledRequestOptions) {
                 await current.call("controls.register", []);
             }
@@ -64,6 +88,7 @@ export function createLocalRuntimeApplication(config = loadRuntimeConfig(), opti
     return Object.freeze({
         services,
         requests: client.requests,
+        approvals: client.approvals,
         start,
         async stop() {
             stopped = true;
@@ -72,10 +97,25 @@ export function createLocalRuntimeApplication(config = loadRuntimeConfig(), opti
             }
             finally {
                 client.close();
+                learning.close();
                 await connection?.close();
             }
         },
         getOwnership: () => connection?.ownership,
+        isOwnerIdle: () => !stopped && connection?.isOwnerIdle() === true,
+        stopIfIdle() {
+            if (stopped)
+                return Promise.resolve(false);
+            if (!connection?.isOwnerIdle())
+                return Promise.resolve(false);
+            // Do not await startup between checking admission and closing intake.
+            const closing = connection.closeIfIdle();
+            stopped = true;
+            client.close();
+            learning.close();
+            return closing;
+        },
         subscribeScheduledEvents: client.subscribe.bind(client),
+        subscribeLearningEvents: learning.subscribe,
     });
 }

package/dist/src/runtime/local-host/app-learning-dispatch.d.ts

@@ -0,0 +1,3 @@
+import type { PassiveLearningService } from "../passive-learning/contracts.js";
+/** An explicit management surface excludes collection ingress and lifecycle RPCs. */
+export declare function dispatchLocalLearningCall(service: PassiveLearningService | undefined, method: string, args: readonly unknown[]): Promise<unknown>;

package/dist/src/runtime/local-host/app-learning-dispatch.js

@@ -0,0 +1,54 @@
+import { readLearningPreferencesInput } from "./learning-preferences-input.js";
+import { isLearningEventId } from "./learning-events.js";
+/** An explicit management surface excludes collection ingress and lifecycle RPCs. */
+export function dispatchLocalLearningCall(service, method, args) {
+    if (!service)
+        throw new Error("passive_learning_unavailable");
+    if (method === "learning.status")
+        return service.status();
+    if (method === "learning.candidates") {
+        if (args.length !== 0)
+            throw new Error("passive_learning_candidates_invalid");
+        if (!service.candidates)
+            throw new Error("passive_learning_unavailable");
+        return service.candidates();
+    }
+    if (method === "learning.dismissProposal") {
+        if (args.length !== 1 || !isLearningEventId(args[0]))
+            throw new Error("passive_learning_proposal_invalid");
+        if (!service.dismissProposal)
+            throw new Error("passive_learning_unavailable");
+        return service.dismissProposal(args[0]);
+    }
+    if (method === "learning.clearPending") {
+        if (args.length !== 0)
+            throw new Error("passive_learning_clear_pending_invalid");
+        return service.clearPending();
+    }
+    if (method === "learning.restartCollection") {
+        if (args.length !== 0)
+            throw new Error("passive_learning_restart_collection_invalid");
+        if (!service.restartCollection)
+            throw new Error("passive_learning_unavailable");
+        return service.restartCollection();
+    }
+    if (method === "learning.configure") {
+        if (args.length !== 1)
+            throw new Error("passive_learning_preferences_invalid");
+        return service.configure(readLearningPreferencesInput(args[0]));
+    }
+    if (method === "learning.batches") {
+        const input = args[0];
+        if (input === undefined)
+            return service.batches();
+        if (!input || typeof input !== "object" || Array.isArray(input))
+            throw new Error("passive_learning_page_invalid");
+        return service.batches(input);
+    }
+    if (method === "learning.batch") {
+        if (typeof args[0] !== "string")
+            throw new Error("passive_learning_batch_invalid");
+        return service.batch(args[0]);
+    }
+    throw new Error("local_runtime_method_unknown");
+}