@abot-ai/runtime 1.5.0 → 1.6.0

package/dist/src/computer-access/host-observation.d.ts

@@ -7,7 +7,7 @@ export type SystemHostFacts = Readonly<{
 export declare function readSystemHostFacts(): SystemHostFacts;
 export declare function isWslHostRuntime(facts: SystemHostFacts): boolean;
 export declare function observeSystemHost(facts?: SystemHostFacts): {
-    readonly runtimeOs: "unsupported" | SystemTargetId;
+    readonly runtimeOs: SystemTargetId | "unsupported";
     readonly kernelRelease: string;
     readonly environment: "container";
     readonly inferredHostOs: "unknown";
@@ -15,10 +15,10 @@ export declare function observeSystemHost(facts?: SystemHostFacts): {
     readonly windowsExecutionRequiresProbe: false;
     readonly guiSessionStatus: "not_checked";
 } | {
-    readonly runtimeOs: "unsupported" | SystemTargetId;
+    readonly runtimeOs: SystemTargetId | "unsupported";
     readonly kernelRelease: string;
     readonly environment: "wsl_guest" | "not_identified_as_wsl";
-    readonly inferredHostOs: "unsupported" | SystemTargetId;
+    readonly inferredHostOs: SystemTargetId | "unsupported";
     readonly hostInferenceSource: "wsl_kernel_signature" | "runtime_platform_only";
     readonly windowsExecutionRequiresProbe: boolean;
     readonly guiSessionStatus: "not_checked";

package/dist/src/computer-access/native-permission-contract.d.ts

@@ -0,0 +1,23 @@
+import { type MacPermissionAction, type MacPermissionResult } from "./companion/permission-protocol.js";
+export type NativePermissionStatus = Readonly<{
+    available: true;
+    ownerId: string;
+    computerName: string;
+    executablePath: string;
+}> | Readonly<{
+    available: false;
+    reason: string;
+}>;
+export type NativePermissionInput = MacPermissionAction & Readonly<{
+    ownerId: string;
+}>;
+export type NativePermissionResult = MacPermissionResult & Readonly<{
+    ownerId: string;
+}>;
+export type NativePermissionClient = Readonly<{
+    status(): Promise<NativePermissionStatus>;
+    prepare(input: NativePermissionInput): Promise<NativePermissionResult>;
+}>;
+export declare function readNativePermissionInput(value: unknown): NativePermissionInput | undefined;
+export declare function isNativePermissionEnvironment(value: unknown): value is string;
+export declare function isNativePermissionStatus(value: unknown): value is NativePermissionStatus;

package/dist/src/computer-access/native-permission-contract.js

@@ -0,0 +1,38 @@
+import { isHostIdentifier, isHostRecord } from "./companion/protocol.js";
+import { isMacPermissionAction } from "./companion/permission-protocol.js";
+export function readNativePermissionInput(value) {
+    if (!isHostRecord(value))
+        return undefined;
+    const { ownerId, ...action } = value;
+    if (!isHostIdentifier(ownerId))
+        return undefined;
+    if (!isMacPermissionAction(action))
+        return undefined;
+    return { ownerId, ...action };
+}
+export function isNativePermissionEnvironment(value) {
+    if (typeof value !== "string")
+        return false;
+    if (!value.trim() || value.length > 256)
+        return false;
+    return !/[\u0000-\u001f\u007f]/u.test(value);
+}
+export function isNativePermissionStatus(value) {
+    if (!isHostRecord(value))
+        return false;
+    if (value.available === false)
+        return typeof value.reason === "string" && value.reason.length <= 256;
+    if (value.available !== true)
+        return false;
+    if (!isHostIdentifier(value.ownerId))
+        return false;
+    if (typeof value.computerName !== "string" || value.computerName.length > 256)
+        return false;
+    if (!value.computerName.trim() || /[\u0000-\u001f\u007f]/u.test(value.computerName))
+        return false;
+    if (typeof value.executablePath !== "string" || value.executablePath.length > 4096)
+        return false;
+    if (/[\u0000-\u001f\u007f]/u.test(value.executablePath))
+        return false;
+    return value.executablePath.startsWith("/");
+}

package/dist/src/model-gateway/policy/invocation-policy.js

@@ -171,8 +171,17 @@ export function resolveModelInvocation(requestBody) {
         ...(selectedInvocationProfile?.format
             ? { format: selectedInvocationProfile.format }
             : {}),
-        ...(calibration.instructions
+        ...(calibration.instructions && !omitsCalibrationInstructions(requestBody.format)
             ? { instructions: calibration.instructions }
             : {}),
     };
 }
+/** A caller-owned text contract may isolate itself from the selected slot's prose. */
+function omitsCalibrationInstructions(format) {
+    if (!format || typeof format !== "object" || Array.isArray(format))
+        return false;
+    const requested = format;
+    if (requested.type !== "text")
+        return false;
+    return requested.calibrationInstructions === "omit";
+}

package/dist/src/model-gateway/providers/openai/payload.js

@@ -70,6 +70,9 @@ function readFiniteNumber(value) {
         ? value
         : undefined;
 }
+function hasExplicitlyDisabledOpenAIReasoning(invocation) {
+    return invocation.profile.supportsThinking === true && invocation.think === "none";
+}
 export function buildOpenAIResponsesPayload(requestBody, payloadOptions = {}) {
     validateModelGatewayMessages(requestBody.messages);
     const invocation = resolveModelInvocation(requestBody);
@@ -103,6 +106,11 @@ export function buildOpenAIResponsesPayload(requestBody, payloadOptions = {}) {
     if (formatProjection.format) {
         payload.text = { format: formatProjection.format };
     }
+    // Without an explicit provider disable, hidden reasoning may consume output.
+    // A missing or false control declaration does not disable provider defaults.
+    if (!hasExplicitlyDisabledOpenAIReasoning(invocation)) {
+        return payload;
+    }
     const outputTokenLimit = resolveModelStepOutputTokenLimit(requestBody.modelStep);
     if (outputTokenLimit === undefined) {
         return payload;

package/dist/src/model-gateway/structured-output/ollama-format.js

@@ -112,6 +112,11 @@ export function projectOllamaFormat(format) {
     if (!isPlainObject(format)) {
         return { format: undefined, diagnostics: [] };
     }
+    const requestsPlainTextOutput = format.type === "text";
+    if (requestsPlainTextOutput) {
+        rejectMisplacedProjectionMetadata(format);
+        return { format: undefined, diagnostics: [] };
+    }
     if (isModelGatewayJsonSchemaFormat(format)) {
         return projectWrappedJsonSchema(format);
     }

package/dist/src/model-gateway/structured-output/openai-format.js

@@ -51,6 +51,11 @@ export function projectOpenAIResponsesFormat(format) {
     if (!isPlainObject(format)) {
         return emptyProjection(undefined);
     }
+    const requestsPlainTextOutput = format.type === "text";
+    if (requestsPlainTextOutput) {
+        rejectMisplacedProjectionMetadata(format);
+        return emptyProjection(undefined);
+    }
     if (isModelGatewayJsonSchemaFormat(format)) {
         return hasUnsupportedRootUnion(format.schema)
             ? rootUnionFallback(format.name, format.schema)

package/dist/src/model-gateway/types.d.ts

@@ -56,6 +56,7 @@ export type ModelGatewayJsonSchemaFormat = {
         path: string;
     }>[];
 };
+/** Text requests may set calibrationInstructions: "omit" to retain only caller-owned instructions. */
 export type ModelGatewayFormat = "json" | ModelGatewayJsonSchemaFormat | Record<string, unknown>;
 export type ModelPreferenceScope = "main" | "all";
 export type ModelPreference = {
@@ -69,6 +70,7 @@ export type ModelGatewayProfileConfig = {
     model: string;
     /** Declared physical context capacity. Required after profile materialization. */
     contextWindowTokens?: number;
+    /** Explicit reasoning-control support, not a request to enable or disable thinking. */
     supportsThinking?: boolean;
     capabilities?: ModelGatewayProfileCapabilities;
     options?: Record<string, unknown>;
@@ -218,6 +220,7 @@ export type ModelProfile = {
     providerConfig?: ModelGatewayProviderConfig;
     model: string;
     contextWindowTokens: number;
+    /** Declared control support; false does not disable provider-default reasoning. */
     supportsThinking: boolean;
     capabilities: Required<ModelGatewayProfileCapabilities>;
     options: Record<string, unknown>;

package/dist/src/plugin-contract/manifest.d.ts

@@ -1,4 +1,4 @@
-import type { ToolCatalogGroup, ToolDevelopmentRole, ToolEventPresentation, ToolNormalInvocationApproval, ToolNormalInvocationEffect, ToolNormalInvocationFixedValue, ToolNormalInvocationInput, ToolNormalInvocationPayload, ToolPayloadChannelSpec, ToolRoutingCapability, ToolRuntimePathBinding } from "../capabilities/tool-types.js";
+import type { ToolCatalogGroup, ToolDevelopmentRole, ToolEventPresentation, ToolNormalInvocationApproval, ToolNormalInvocationAttachmentInput, ToolNormalInvocationEffect, ToolNormalInvocationFixedValue, ToolNormalInvocationInput, ToolNormalInvocationPayload, ToolPayloadChannelSpec, ToolRoutingCapability, ToolRuntimePathBinding } from "../capabilities/tool-types.js";
 export declare const AGENT_PLUGIN_MANIFEST_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
 export declare const ABOT_RUNTIME_EXTENSION = "ai.abot.runtime";
 export declare const ABOT_RUNTIME_EXTENSION_VERSION: 1;
@@ -10,6 +10,7 @@ export type AgentPluginOperationManifest = Readonly<{
     approval: ToolNormalInvocationApproval;
     fixedParams?: Readonly<Record<string, ToolNormalInvocationFixedValue>>;
     payload?: ToolNormalInvocationPayload;
+    attachmentInput?: ToolNormalInvocationAttachmentInput;
 }>;
 export type AgentPluginCapabilityManifest = Readonly<{
     requiredPermissionMode?: import("../capabilities/tool-permission-mode.js").ToolRequiredPermissionMode;

package/dist/src/plugin-sdk/context-text-result.d.ts

@@ -0,0 +1,10 @@
+import type { ToolImplementationOutput } from "../plugin-contract/entrypoint.js";
+import type { ToolResultBudget } from "../capabilities/result-budget.js";
+import type { ToolContextTextField } from "../capabilities/tool-context-text.js";
+export type { ToolContextTextField } from "../capabilities/tool-context-text.js";
+/**
+ * Keeps ordinary results unchanged. An opted-in host can receive oversized
+ * exact text in the same fields, with metadata still bounded. This is delivery
+ * to runtime evidence, not permission to exceed the model's context window.
+ */
+export declare function deliverPluginTextResult(result: ToolImplementationOutput, fields: readonly ToolContextTextField[], budget?: ToolResultBudget): ToolImplementationOutput;

package/dist/src/plugin-sdk/context-text-result.js

@@ -0,0 +1,19 @@
+import { enforcePluginResultByteBudget } from "./results.js";
+/**
+ * Keeps ordinary results unchanged. An opted-in host can receive oversized
+ * exact text in the same fields, with metadata still bounded. This is delivery
+ * to runtime evidence, not permission to exceed the model's context window.
+ */
+export function deliverPluginTextResult(result, fields, budget) {
+    const assessed = enforcePluginResultByteBudget(result, budget);
+    if (!canHandOffContextText(result, assessed, budget))
+        return assessed;
+    return enforcePluginResultByteBudget({ ...result, contextTextFields: Object.freeze([...fields]) }, budget);
+}
+function canHandOffContextText(original, assessed, budget) {
+    if (budget?.acceptsContextText !== true)
+        return false;
+    if (assessed === original)
+        return false;
+    return assessed.errorCode === "plugin_result_too_large";
+}

package/dist/src/plugin-sdk/index.d.ts

@@ -4,6 +4,7 @@ export * from "./parameters.js";
 export * from "./paths.js";
 export * from "./plugin.js";
 export * from "./results.js";
+export * from "./context-text-result.js";
 export * from "../capabilities/tool-media.js";
 export * from "./tool-availability-brief.js";
 export * from "./tool-availability-overview.js";

package/dist/src/plugin-sdk/index.js

@@ -4,6 +4,7 @@ export * from "./parameters.js";
 export * from "./paths.js";
 export * from "./plugin.js";
 export * from "./results.js";
+export * from "./context-text-result.js";
 export * from "../capabilities/tool-media.js";
 export * from "./tool-availability-brief.js";
 export * from "./tool-availability-overview.js";

package/dist/src/plugin-sdk/results.d.ts

@@ -1,21 +1,24 @@
 import type { ToolImplementationOutput } from "../plugin-contract/entrypoint.js";
+import { type ToolResultBudget } from "../capabilities/result-budget.js";
+export type { ToolResultBudget, ToolResultBudgetAssessment, } from "../capabilities/result-budget.js";
 type ResultCommon = Pick<ToolImplementationOutput, "actions" | "data" | "exitCode" | "progress" | "stderr" | "stdout" | "media">;
+/** Legacy standalone SDK bound; invocation-aware producers also pass the host assessor. */
 export declare const PLUGIN_RESULT_SERIALIZED_MAX_BYTES: number;
-export declare function enforcePluginResultByteBudget(result: ToolImplementationOutput): ToolImplementationOutput;
+export declare function enforcePluginResultByteBudget(result: ToolImplementationOutput, resultBudget?: ToolResultBudget): ToolImplementationOutput;
 export type SuccessResultInput = ResultCommon & Readonly<{
     output: string;
     producedNewInformation?: boolean;
 }>;
-export declare function successResult(input: SuccessResultInput): ToolImplementationOutput;
+export declare function successResult(input: SuccessResultInput, resultBudget?: ToolResultBudget): ToolImplementationOutput;
 export type FailureResultInput = ResultCommon & Readonly<{
+    interruption?: ToolImplementationOutput["interruption"];
     errorCode: string;
     message: string;
     output?: string;
 }>;
-export declare function failureResult(input: FailureResultInput): ToolImplementationOutput;
+export declare function failureResult(input: FailureResultInput, resultBudget?: ToolResultBudget): ToolImplementationOutput;
 export declare function failureFromError(error: unknown, options: Readonly<{
     fallbackCode: string;
     fallbackMessage: string;
     operation?: string;
 }>): ToolImplementationOutput;
-export {};

package/dist/src/plugin-sdk/results.js

@@ -1,6 +1,9 @@
+import { hasValidToolContextText } from "../capabilities/tool-context-text.js";
+import { CAPABILITY_RESULT_ENVELOPE_MAX_BYTES, } from "../capabilities/result-budget.js";
 import { isPluginParameterError, } from "./parameters.js";
 import { runtimeToolPathErrorCode } from "./paths.js";
-export const PLUGIN_RESULT_SERIALIZED_MAX_BYTES = 128 * 1024;
+/** Legacy standalone SDK bound; invocation-aware producers also pass the host assessor. */
+export const PLUGIN_RESULT_SERIALIZED_MAX_BYTES = CAPABILITY_RESULT_ENVELOPE_MAX_BYTES;
 function resultBoundsFailure(code, message) {
     return {
         ok: false,
@@ -10,24 +13,45 @@ function resultBoundsFailure(code, message) {
         errorCode: code,
     };
 }
-export function enforcePluginResultByteBudget(result) {
-    let serialized;
+export function enforcePluginResultByteBudget(result, resultBudget) {
+    let requiresContextTextHost = false;
+    let serializedBytes;
+    let envelopeBytes;
+    let maxBytes = PLUGIN_RESULT_SERIALIZED_MAX_BYTES;
+    let fitsDeclaredBudget = true;
     try {
+        if (!hasValidToolContextText(result)) {
+            return resultBoundsFailure("plugin_context_text_invalid", "The plugin declared invalid context text fields.");
+        }
+        requiresContextTextHost = result.contextTextFields !== undefined;
+        const lacksContextTextHost = requiresContextTextHost && resultBudget?.acceptsContextText !== true;
+        if (lacksContextTextHost) {
+            return resultBoundsFailure("plugin_context_text_unavailable", "The host does not support context-managed tool text.");
+        }
         const candidate = JSON.stringify(result);
         if (candidate === undefined) {
             return resultBoundsFailure("plugin_result_not_json_safe", "The plugin produced a result that is not JSON-safe.");
         }
-        serialized = candidate;
+        const assessment = resultBudget?.assess(result);
+        serializedBytes =
+            assessment?.serializedBytes ?? Buffer.byteLength(candidate, "utf8");
+        envelopeBytes = assessment?.envelopeBytes ?? serializedBytes;
+        maxBytes = Math.min(assessment?.maxBytes ?? maxBytes, maxBytes);
+        fitsDeclaredBudget = assessment?.fits ?? true;
     }
     catch {
         return resultBoundsFailure("plugin_result_not_json_safe", "The plugin produced a result that is not JSON-safe.");
     }
-    if (Buffer.byteLength(serialized, "utf8") > PLUGIN_RESULT_SERIALIZED_MAX_BYTES) {
-        return resultBoundsFailure("plugin_result_too_large", `The plugin result exceeds the ${PLUGIN_RESULT_SERIALIZED_MAX_BYTES}-byte safety limit.`);
+    const hasResultDeliveryHeadroom = fitsDeclaredBudget && envelopeBytes <= maxBytes;
+    if (!hasResultDeliveryHeadroom) {
+        const message = requiresContextTextHost
+            ? `The plugin result envelope is ${envelopeBytes} bytes (${serializedBytes} total bytes) and exceeds the ${maxBytes}-byte delivery limit.`
+            : `The plugin result is ${serializedBytes} bytes and exceeds the ${maxBytes}-byte delivery limit.`;
+        return resultBoundsFailure("plugin_result_too_large", message);
     }
     return result;
 }
-export function successResult(input) {
+export function successResult(input, resultBudget) {
     return enforcePluginResultByteBudget({
         ok: true,
         ...(input.media !== undefined ? { media: input.media } : {}),
@@ -39,11 +63,12 @@ export function successResult(input) {
         ...(input.stdout !== undefined ? { stdout: input.stdout } : {}),
         ...(input.stderr !== undefined ? { stderr: input.stderr } : {}),
         ...(input.data !== undefined ? { data: input.data } : {}),
-    });
+    }, resultBudget);
 }
-export function failureResult(input) {
+export function failureResult(input, resultBudget) {
     return enforcePluginResultByteBudget({
         ok: false,
+        ...(input.interruption ? { interruption: input.interruption } : {}),
         ...(input.media !== undefined ? { media: input.media } : {}),
         output: input.output ?? input.message,
         producedNewInformation: false,
@@ -55,7 +80,7 @@ export function failureResult(input) {
         ...(input.data !== undefined ? { data: input.data } : {}),
         error: input.message,
         errorCode: input.errorCode,
-    });
+    }, resultBudget);
 }
 export function failureFromError(error, options) {
     const pathCode = runtimeToolPathErrorCode(error);

package/dist/src/runtime/adapters/co-worker-resources.d.ts

@@ -1,6 +1,7 @@
 import type { RuntimeConfig, ModelGatewayClient, SessionStore } from "../ports.js";
 import type { LongTermMemoryService } from "../long-term-memory/contracts.js";
 import type { LearningBackgroundContext, LearningBackgroundDependencies } from "../passive-learning/background-dependencies.js";
+import type { SessionRequestAdmission } from "../request/session-admission.js";
 /** The environment shares one budget; foreground chat keeps its original clients. */
 export declare function createCoWorkerResourceDependencies(options: {
     config: RuntimeConfig;
@@ -10,4 +11,5 @@ export declare function createCoWorkerResourceDependencies(options: {
     ownerId: string;
     context: LearningBackgroundContext;
     sessions?: SessionStore;
+    deliveryAdmission?: Pick<SessionRequestAdmission, "run">;
 }): LearningBackgroundDependencies;

package/dist/src/runtime/adapters/co-worker-resources.js

@@ -61,8 +61,8 @@ export function createCoWorkerResourceDependencies(options) {
         supportsParallel: () => original.supportsParallelBatches?.(context.preferences().proactiveModelProfileId ?? context.preferences().modelProfileId ?? "") ?? false,
     });
     const proactive = learning && options.sessions ? new CoWorkerProactiveAgent({ directory: options.directory,
-        context, memory: learning, sessions: options.sessions, budget,
-        model: createRuntimeProactiveModel({ config: options.config, models: proactiveGateway }) }) : undefined;
+        context, memory: learning, sessions: options.sessions, budget, deliveryAdmission: options.deliveryAdmission,
+        model: createRuntimeProactiveModel({ config: options.config, models: proactiveGateway, sessions: options.sessions }) }) : undefined;
     const model = createRuntimePassiveLearningModel({ ...options, models: gateway });
     const reassessment = memory.learning ? new ScheduledLearningReassessment({ directory: options.directory,
         environmentId: options.ownerId, context, memory: memory.learning, model,

package/dist/src/runtime/adapters/file-session-store.js

@@ -3,7 +3,13 @@ export function createFileSessionStore(options = {}) {
     const service = new SessionService(options);
     return {
         requestLifecycle: service.requestLifecycle,
+        assertInteractiveSession: service.assertInteractiveSession.bind(service),
+        createAutomationSession: service.createAutomationSession.bind(service),
+        runAsAutomationSession: service.runAsAutomationSession.bind(service),
+        releaseAutomationSession: service.releaseAutomationSession.bind(service),
+        reconcileAutomationSessions: service.reconcileAutomationSessions.bind(service),
         createAssistantConversation: service.createAssistantConversation.bind(service),
+        appendAssistantInitiative: service.appendAssistantInitiative.bind(service),
         getOrCreateSession: service.getOrCreateSession.bind(service),
         getAllSessions: service.getAllSessions.bind(service),
         listSessions: service.listSessions.bind(service),

package/dist/src/runtime/adapters/in-memory-session-store.js

@@ -4,10 +4,13 @@ import { assertValidSessionArtifactPathInputs, upsertSessionArtifactPaths, } fro
 import { clientVisibleMessages, compactRequestEvents, filterMessagesAfter, getRequestFinalState, getSessionRequest, isSameMessageId, normalizeAfterSeq, normalizeCursor, normalizeLimit, normalizeSessionTitle, toClientReplayEvent, toEpochMs, toSessionListItem, toSnapshotMessage, toSnapshotRequest, } from "../../sessions/record/projection.js";
 import { assertValidRequestId, assertValidSessionId, createContextEntryId, defaultCreateMessageId, pruneSupersededContextEntries, } from "../../sessions/record/rules.js";
 import { resolveSessionMemoryCheckpointCommit } from "../../sessions/memory/rules.js";
+import { assertSessionKindUnchanged, sessionKindCreationFields } from "../../sessions/spark-session.js";
+import { appendSparkInitiativeRecord } from "../../sessions/assistant-initiative-append.js";
 export function createInMemorySessionStore(options = {}) {
     const store = new InMemorySessionStore(options);
     return {
         getOrCreateSession: store.getOrCreateSession.bind(store),
+        appendAssistantInitiative: store.appendAssistantInitiative.bind(store),
         getAllSessions: store.getAllSessions.bind(store),
         listSessions: store.listSessions.bind(store),
         getSessionById: store.getSessionById.bind(store),
@@ -47,6 +50,7 @@ class InMemorySessionStore {
         const existing = this.sessions.get(sessionId);
         if (existing) {
             assertSessionProjectUnchanged(existing, options.project);
+            assertSessionKindUnchanged(existing, options.kind);
             return cloneSession(existing);
         }
         const timestamp = toIso(this.now);
@@ -55,7 +59,7 @@ class InMemorySessionStore {
             ...(options.project
                 ? { project: copySessionProject(options.project) }
                 : {}),
-            title: sessionId,
+            ...sessionKindCreationFields(sessionId, options),
             createdAt: timestamp,
             updatedAt: timestamp,
             lastAgentMode: "reasoning",
@@ -70,6 +74,14 @@ class InMemorySessionStore {
             .map(cloneSession)
             .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
     }
+    async appendAssistantInitiative(sessionId, input) {
+        return this.runSessionMutation(sessionId, async () => {
+            const record = appendSparkInitiativeRecord(this.sessions.get(sessionId) ?? null, sessionId, input, this.now());
+            input.assertCurrent?.();
+            this.saveSession(record);
+            return cloneSession(record);
+        });
+    }
     async listSessions(params = {}) {
         const limit = normalizeLimit(params.limit);
         const offset = normalizeCursor(params.cursor);
@@ -93,6 +105,7 @@ class InMemorySessionStore {
         }
         return {
             sessionId,
+            ...(session.kind ? { kind: session.kind } : {}),
             ...(session.project ? { project: session.project } : {}),
             title: session.title,
             messages: filterMessagesAfter(clientVisibleMessages(session.messages), options.afterMessageId).map((message) => toSnapshotMessage(sessionId, message, session.requests ?? [])),

package/dist/src/runtime/adapters/long-term-memory/onboarding-service.d.ts

@@ -1,8 +1,9 @@
 import { type ModelProviderAdapterRegistry } from "../../../model-gateway/index.js";
-import type { LongTermMemoryOnboardingService } from "../../long-term-memory/onboarding/contracts.js";
+import type { LongTermMemoryOnboardingConfigRepository, LongTermMemoryOnboardingService } from "../../long-term-memory/onboarding/contracts.js";
 export declare function createLocalLongTermMemoryOnboardingService(params: {
     rootDir: string;
     providerAdapters: ModelProviderAdapterRegistry;
     configPath?: string;
     fetchImpl?: typeof fetch;
+    repository?: LongTermMemoryOnboardingConfigRepository;
 }): LongTermMemoryOnboardingService;

package/dist/src/runtime/adapters/long-term-memory/onboarding-service.js

@@ -3,10 +3,11 @@ import { createLongTermMemoryOnboardingService } from "../../long-term-memory/on
 import { createFileLongTermMemoryOnboardingConfigRepository } from "./onboarding-config-repository.js";
 const EMBEDDING_PROBE_TEXT = "ABot long-term memory embedding capability probe.";
 export function createLocalLongTermMemoryOnboardingService(params) {
-    const repository = createFileLongTermMemoryOnboardingConfigRepository({
-        rootDir: params.rootDir,
-        ...(params.configPath ? { configPath: params.configPath } : {}),
-    });
+    const repository = params.repository ??
+        createFileLongTermMemoryOnboardingConfigRepository({
+            rootDir: params.rootDir,
+            ...(params.configPath ? { configPath: params.configPath } : {}),
+        });
     return createLongTermMemoryOnboardingService({
         repository,
         probe: async (input) => {

package/dist/src/runtime/adapters/passive-learning-runtime.d.ts

@@ -1,11 +1,13 @@
 import type { RuntimeConfig, ModelGatewayClient, SessionStore } from "../ports.js";
 import type { LongTermMemoryService } from "../long-term-memory/contracts.js";
+import type { SessionRequestAdmission } from "../request/session-admission.js";
 /** The environment owns learning; the paired desktop owns native collection. */
 export declare function createRuntimePassiveLearning(params: {
     config: RuntimeConfig;
     models: ModelGatewayClient;
     memory: LongTermMemoryService;
     sessions?: SessionStore;
+    deliveryAdmission?: Pick<SessionRequestAdmission, "run">;
 }): Readonly<{
     start(): Promise<void>;
     stop(): Promise<void>;
@@ -21,7 +23,6 @@ export declare function createRuntimePassiveLearning(params: {
     flush(): Promise<void>;
     beginInteractive(): () => void;
     subscribe(listener: (event?: import("../passive-learning/contracts.js").LearningChangedEvent) => void): () => void;
-    dismissProposal?(id: string): Promise<void>;
     sessionDeleted?(sessionId: string): Promise<void>;
     notifyKnowledgeChanged?(): void;
     candidates?(): Promise<readonly Omit<import("../long-term-memory/maturation/contracts.js").LearningCandidateRecord, "embedding">[]>;

package/dist/src/runtime/adapters/passive-learning-runtime.js

@@ -17,7 +17,7 @@ export function createRuntimePassiveLearning(params) {
         model: createRuntimePassiveLearningModel({ config, models }),
         backgroundDependencies: (context) => createCoWorkerResourceDependencies({
             config, models, memory, context, ownerId, directory: join(config.paths.runtimeDir, "passive-learning"),
-            sessions: params.sessions,
+            sessions: params.sessions, deliveryAdmission: params.deliveryAdmission,
         }),
         connect: (input) => connectHostObservations({
             ...input,