@abot-ai/runtime 1.5.0 → 1.6.0

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

@@ -1,5 +1,4 @@
 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)
@@ -13,13 +12,6 @@ export function dispatchLocalLearningCall(service, method, args) {
             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");

package/dist/src/runtime/local-host/app-native-permissions.d.ts

@@ -0,0 +1,20 @@
+import { prepareMacPermissions } from "../../computer-access/companion/native-permissions.js";
+import { resolveSystemTarget } from "../../computer-access/targets.js";
+import { type NativePermissionStatus } from "../../computer-access/native-permission-contract.js";
+import type { LocalRuntimePeer } from "./contracts.js";
+export declare function isLocalNativePermissionMethod(method: string): boolean;
+/** Runs beside the native SYSTEM executor, even when Web is only an attached client. */
+export declare class LocalNativePermissions {
+    private readonly dependencies;
+    private readonly ownerId;
+    private active?;
+    private stopped;
+    constructor(dependencies?: {
+        platform?: string;
+        prepare?: typeof prepareMacPermissions;
+        resolveTarget?: typeof resolveSystemTarget;
+    });
+    status(): Promise<NativePermissionStatus>;
+    call(method: string, args: readonly unknown[], peer: LocalRuntimePeer): Promise<unknown>;
+    stop(): void;
+}

package/dist/src/runtime/local-host/app-native-permissions.js

@@ -0,0 +1,76 @@
+import { randomUUID } from "node:crypto";
+import { hostname } from "node:os";
+import { prepareMacPermissions } from "../../computer-access/companion/native-permissions.js";
+import { resolveSystemTarget } from "../../computer-access/targets.js";
+import { readNativePermissionInput } from "../../computer-access/native-permission-contract.js";
+export function isLocalNativePermissionMethod(method) {
+    if (method === "nativePermissions.status")
+        return true;
+    return method === "nativePermissions.prepare";
+}
+/** Runs beside the native SYSTEM executor, even when Web is only an attached client. */
+export class LocalNativePermissions {
+    dependencies;
+    ownerId = randomUUID();
+    active;
+    stopped = false;
+    constructor(dependencies = {}) {
+        this.dependencies = dependencies;
+    }
+    async status() {
+        if (this.stopped)
+            return { available: false, reason: "runtime_owner_unavailable" };
+        if ((this.dependencies.platform ?? process.platform) !== "darwin")
+            return { available: false, reason: "native_macos_unavailable" };
+        try {
+            const target = await (this.dependencies.resolveTarget ?? resolveSystemTarget)("macos");
+            if (target.transport !== "native")
+                return { available: false, reason: "native_macos_unavailable" };
+        }
+        catch {
+            return { available: false, reason: "native_macos_unavailable" };
+        }
+        if (this.stopped)
+            return { available: false, reason: "runtime_owner_unavailable" };
+        return { available: true, ownerId: this.ownerId, computerName: hostname(), executablePath: process.execPath };
+    }
+    async call(method, args, peer) {
+        if (method === "nativePermissions.status" && args.length === 0)
+            return this.status();
+        if (method !== "nativePermissions.prepare")
+            throw new Error("local_runtime_method_unknown");
+        if (args.length !== 1)
+            throw new Error("macos_permissions_input_invalid");
+        const input = readNativePermissionInput(args[0]);
+        if (!input)
+            throw new Error("macos_permissions_input_invalid");
+        if (input.ownerId !== this.ownerId)
+            throw new Error("macos_permissions_owner_changed");
+        if (!(await this.status()).available)
+            throw new Error("macos_permissions_owner_unavailable");
+        if (this.stopped)
+            throw new Error("macos_permissions_owner_unavailable");
+        if (this.active)
+            throw new Error("macos_permissions_busy");
+        const stop = new AbortController();
+        this.active = stop;
+        const disconnect = peer.onClose(() => stop.abort());
+        const deadline = setTimeout(() => stop.abort(), 50_000);
+        try {
+            stop.signal.throwIfAborted();
+            const { ownerId, ...action } = input;
+            const result = await (this.dependencies.prepare ?? prepareMacPermissions)(action, stop.signal);
+            stop.signal.throwIfAborted();
+            return { ...result, ownerId };
+        }
+        finally {
+            clearTimeout(deadline);
+            disconnect();
+            this.active = undefined;
+        }
+    }
+    stop() {
+        this.stopped = true;
+        this.active?.abort();
+    }
+}

package/dist/src/runtime/local-host/app-owner.js

@@ -6,6 +6,7 @@ import { LocalRuntimeOwnerActivity } from "./owner-activity.js";
 import { dispatchLocalLearningCall } from "./app-learning-dispatch.js";
 import { projectLearningChangedEvent } from "./learning-events.js";
 import { SavedRequestApprovals } from "./saved-approvals.js";
+import { isLocalNativePermissionMethod, LocalNativePermissions } from "./app-native-permissions.js";
 export async function createLocalRuntimeOwner(config, overrides = {}) {
     const listeners = new Set();
     const publish = (event) => {
@@ -20,6 +21,7 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
     };
     const controls = new LocalRequestControls(publish);
     const activity = new LocalRuntimeOwnerActivity();
+    const nativePermissions = new LocalNativePermissions();
     const application = createRuntimeApplication(config, {
         ...overrides,
         scheduledRequestOptions: (run) => controls.scheduled(run),
@@ -51,6 +53,8 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
     return {
         call(method, args, peer) {
             return activity.run(async () => {
+                if (isLocalNativePermissionMethod(method))
+                    return nativePermissions.call(method, args, peer);
                 if (method === "controls.register")
                     return controls.register(peer);
                 if (method === "request.active")
@@ -68,8 +72,12 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
                         return;
                     return controls.attach(args[0], args[1], peer);
                 }
-                if (method === "request.steer")
+                if (method === "request.steer") {
+                    const sessionId = controls.activeSessionId(args[0]);
+                    if (sessionId)
+                        await application.services.sessions.assertInteractiveSession?.(sessionId);
                     return controls.steer(args[0], args[1]);
+                }
                 if (method === "request.cancel") {
                     if (await savedApprovals.cancel(args[0], args[1], args[2]))
                         return { accepted: true };
@@ -101,6 +109,7 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
             if (shutdown)
                 return shutdown;
             activity.stop();
+            nativePermissions.stop();
             application.services.requestAdmission?.close();
             memory.stop();
             controls.stop();
@@ -127,6 +136,8 @@ async function runPeerRequest(application, controls, activity, savedApprovals, a
     const message = args[0];
     if (!message || typeof message.requestId !== "string")
         throw new Error("local_runtime_request_invalid");
+    if (typeof message.sessionId === "string")
+        await application.services.sessions.assertInteractiveSession?.(message.sessionId);
     const options = controls.ordinary(message.requestId, peer, (args[1] ?? {}), typeof message.sessionId === "string" ? message.sessionId : "");
     const durable = args[1]?.durableApprovals === true;
     if (durable)

package/dist/src/runtime/local-host/app-request-control.d.ts

@@ -21,6 +21,7 @@ export declare class LocalRequestControls {
     ordinary(requestId: string, peer: LocalRuntimePeer, options: LocalRequestRunOptions, sessionId?: string, resumedWait?: SessionWaitExpectation): RuntimeRequestOptions;
     scheduled(run: SchedulerRun): RuntimeRequestOptions;
     steer(requestId: unknown, update: unknown): unknown;
+    activeSessionId(requestId: unknown): string | undefined;
     finish(requestId: string): void;
     cancel(requestId: unknown, sessionId: unknown, wait?: unknown): RequestCancellationResult;
     private matchesResumedWaitCancellation;

package/dist/src/runtime/local-host/app-request-control.js

@@ -77,6 +77,11 @@ export class LocalRequestControls {
             text: input.text,
         });
     }
+    activeSessionId(requestId) {
+        return typeof requestId === "string"
+            ? this.active.get(requestId)?.sessionId
+            : undefined;
+    }
     finish(requestId) {
         const entry = this.active.get(requestId);
         this.active.delete(requestId);

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

@@ -1,6 +1,7 @@
 import type { RuntimeEnvironmentServices } from "../composition.js";
-export declare const LOCAL_SESSION_METHODS: readonly ["getOrCreateSession", "getAllSessions", "listSessions", "getSessionById", "getSessionSnapshot", "getRequestReplayById", "updateSessionTitle", "updateSessionRuntimeMode", "appendMessage", "appendContextEntry", "upsertArtifactPaths", "startRequestStream", "appendRequestEvent", "deleteSession", "deleteSessionWithStats", "resetSession", "clearSessionMessages", "deleteMessage", "deleteMessageWithStats", "compareAndSwapSessionMemoryCheckpoint"];
+export declare const LOCAL_SESSION_METHODS: readonly ["getOrCreateSession", "createAssistantConversation", "getAllSessions", "listSessions", "getSessionById", "getSessionSnapshot", "getRequestReplayById", "updateSessionTitle", "updateSessionRuntimeMode", "appendMessage", "appendContextEntry", "upsertArtifactPaths", "startRequestStream", "appendRequestEvent", "deleteSession", "deleteSessionWithStats", "resetSession", "clearSessionMessages", "deleteMessage", "deleteMessageWithStats", "compareAndSwapSessionMemoryCheckpoint"];
 export declare const LOCAL_PROJECT_METHODS: readonly ["list", "get", "create", "browseFolders", "createSession"];
 export declare const LOCAL_ATTACHMENT_METHODS: readonly ["saveAttachment", "validateAttachmentReferences", "resolveAttachment", "deleteAttachment", "deleteSessionAttachments"];
 export declare const LOCAL_SCHEDULER_METHODS: readonly ["tick", "create", "list", "get", "update", "pause", "resume", "cancel", "runNow", "deleteSession", "listRuns"];
+export declare const LOCAL_AUTOMATION_METHODS: readonly ["list", "create", "createDraftPlan", "applyDraftPlan", "getDraft", "deleteDraft", "archive", "restore", "getPublishedDefinition", "updateDraft", "getSavedAgent", "listSavedAgents", "saveAgentFromDraft", "validate", "catalog", "getGrant", "replaceGrant", "publish", "activate", "pause", "runNow", "listRuns", "getRun", "getStepEvidence", "stopRun", "rerun"];
 export declare function dispatchLocalServiceCall(services: RuntimeEnvironmentServices, method: string, args: readonly unknown[]): Promise<unknown>;

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

@@ -1,5 +1,6 @@
 export const LOCAL_SESSION_METHODS = [
     "getOrCreateSession",
+    "createAssistantConversation",
     "getAllSessions",
     "listSessions",
     "getSessionById",
@@ -47,6 +48,34 @@ export const LOCAL_SCHEDULER_METHODS = [
     "deleteSession",
     "listRuns",
 ];
+export const LOCAL_AUTOMATION_METHODS = [
+    "list",
+    "create",
+    "createDraftPlan",
+    "applyDraftPlan",
+    "getDraft",
+    "deleteDraft",
+    "archive",
+    "restore",
+    "getPublishedDefinition",
+    "updateDraft",
+    "getSavedAgent",
+    "listSavedAgents",
+    "saveAgentFromDraft",
+    "validate",
+    "catalog",
+    "getGrant",
+    "replaceGrant",
+    "publish",
+    "activate",
+    "pause",
+    "runNow",
+    "listRuns",
+    "getRun",
+    "getStepEvidence",
+    "stopRun",
+    "rerun",
+];
 function selectServiceMethod(target, method, methods) {
     if (!methods.includes(method))
         throw new Error("local_runtime_method_unknown");
@@ -69,5 +98,7 @@ export async function dispatchLocalServiceCall(services, method, args) {
         return selectServiceMethod(services.attachments, operation, LOCAL_ATTACHMENT_METHODS)(...args);
     if (service === "scheduler")
         return selectServiceMethod(services.scheduler, operation, LOCAL_SCHEDULER_METHODS)(...args);
+    if (service === "automations")
+        return selectServiceMethod(services.automations, operation, LOCAL_AUTOMATION_METHODS)(...args);
     throw new Error("local_runtime_method_unknown");
 }

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

@@ -1,6 +1,6 @@
 import type { LearningChangedEvent, PassiveLearningService } from "../passive-learning/contracts.js";
 import type { LocalRuntimeCallHandler } from "./contracts.js";
-export type PassiveLearningManagement = Pick<PassiveLearningService, "status" | "configure" | "clearPending" | "restartCollection" | "batches" | "batch" | "candidates" | "dismissProposal">;
+export type PassiveLearningManagement = Pick<PassiveLearningService, "status" | "configure" | "clearPending" | "restartCollection" | "batches" | "batch" | "candidates">;
 /** Read models and invalidations only; collection is never owned by a client. */
 export declare function createLocalLearningClient(call: LocalRuntimeCallHandler): {
     service: PassiveLearningManagement;

package/dist/src/runtime/local-host/client-learning.js

@@ -10,7 +10,6 @@ export function createLocalLearningClient(call) {
         batches: (input) => call("learning.batches", [input]),
         batch: (id) => call("learning.batch", [id]),
         candidates: () => call("learning.candidates", []),
-        dismissProposal: (id) => call("learning.dismissProposal", [id]),
     };
     return {
         service,

package/dist/src/runtime/local-host/client-native-permissions.d.ts

@@ -0,0 +1,4 @@
+import { type NativePermissionClient } from "../../computer-access/native-permission-contract.js";
+import type { LocalRuntimeCallHandler } from "./contracts.js";
+/** No connection election or replay; old owners fail closed without blocking host status. */
+export declare function createLocalNativePermissionClient(call: LocalRuntimeCallHandler): NativePermissionClient;

package/dist/src/runtime/local-host/client-native-permissions.js

@@ -0,0 +1,37 @@
+import { isHostRecord } from "../../computer-access/companion/protocol.js";
+import { readMacPermissionResult } from "../../computer-access/companion/permission-protocol.js";
+import { isNativePermissionStatus } from "../../computer-access/native-permission-contract.js";
+function boundPermissionWait(pending, milliseconds) {
+    let deadline;
+    return Promise.race([
+        pending,
+        new Promise((_resolve, reject) => {
+            deadline = setTimeout(() => reject(new Error("macos_permissions_owner_unavailable")), milliseconds);
+        }),
+    ]).finally(() => clearTimeout(deadline));
+}
+/** No connection election or replay; old owners fail closed without blocking host status. */
+export function createLocalNativePermissionClient(call) {
+    let metadata;
+    return {
+        async status() {
+            metadata ??= call("nativePermissions.status", []).finally(() => { metadata = undefined; });
+            try {
+                const result = await boundPermissionWait(metadata, 2_000);
+                if (isNativePermissionStatus(result))
+                    return result;
+            }
+            catch { /* old or disconnected owners do not invalidate Companion readiness */ }
+            return { available: false, reason: "runtime_owner_unavailable" };
+        },
+        async prepare(input) {
+            const result = await boundPermissionWait(call("nativePermissions.prepare", [input]), 55_000);
+            if (!isHostRecord(result) || result.ownerId !== input.ownerId)
+                throw new Error("macos_permissions_owner_changed");
+            const permissions = readMacPermissionResult(result);
+            if (!permissions)
+                throw new Error("macos_permissions_result_invalid");
+            return { ...permissions, ownerId: input.ownerId };
+        },
+    };
+}

package/dist/src/runtime/local-host/client-services.d.ts

@@ -7,6 +7,279 @@ export declare function createLocalServiceClients(call: LocalRuntimeCallHandler)
     sessions: SessionStore;
     attachments: RuntimeAttachmentStore;
     scheduler: Omit<SchedulerService, "start" | "stop">;
+    automations: {
+        list: () => Promise<{
+            latestRunId?: string | undefined;
+            latestRunStatus?: import("../scheduler/contracts.js").SchedulerRunStatus | "stopping" | "completed_with_skips" | undefined;
+            publishedRevision?: number;
+            status: "active" | "paused" | "draft" | "archived";
+            id: string;
+            title: string;
+            draftRevision: number;
+            updatedAt: string;
+        }[]>;
+        create: (title: string, templateId?: string) => Promise<Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: import("../automations/definition-contracts.js").AutomationRevision;
+            updatedAt: string;
+            archivedAt?: string;
+            storageRevision?: number;
+        }>>;
+        getDraft: (automationId: string) => Promise<import("../automations/storage-records.js").AutomationDraftRecord | null>;
+        deleteDraft: (automationId: string, expectedRevision: number) => Promise<void>;
+        archive: (automationId: string, expectedRevision: number) => Promise<Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: import("../automations/definition-contracts.js").AutomationRevision;
+            updatedAt: string;
+            archivedAt?: string;
+            storageRevision?: number;
+        }>>;
+        restore: (automationId: string, expectedRevision: number) => Promise<Readonly<{
+            id: string;
+            automationId: string;
+            revision: number;
+            definition: import("../automations/definition-contracts.js").AutomationRevision;
+            updatedAt: string;
+            archivedAt?: string;
+            storageRevision?: number;
+        }>>;
+        getPublishedDefinition: (automationId: string) => Promise<Readonly<{
+            schemaVersion: 1;
+            automationId: string;
+            revision: number;
+            title: string;
+            objective: string;
+            workingDirectory?: string;
+            trigger: import("../automations/definition-contracts.js").AutomationTrigger;
+            source?: import("../automations/definition-contracts.js").FolderSource;
+            inputs: Readonly<Record<string, import("../automations/definition-contracts.js").AutomationJsonValue>>;
+            body: import("../automations/definition-contracts.js").SequenceNode;
+            limits: import("../automations/limits.js").AutomationLimits;
+        }> | null>;
+        updateDraft: (automationId: string, expectedRevision: number, mutation: unknown) => Promise<import("../automations/storage-records.js").AutomationDraftRecord>;
+        createDraftPlan: (title: string, value: unknown, accept?: import("../automations/draft-management.js").AutomationDraftPlanAcceptance) => Promise<{
+            draft: Readonly<{
+                id: string;
+                automationId: string;
+                revision: number;
+                definition: import("../automations/definition-contracts.js").AutomationRevision;
+                updatedAt: string;
+                archivedAt?: string;
+                storageRevision?: number;
+            }>;
+            aliases: Readonly<Record<string, string>>;
+        }>;
+        applyDraftPlan: (automationId: string, expectedRevision: number, value: unknown, accept?: import("../automations/draft-management.js").AutomationDraftPlanAcceptance) => Promise<{
+            draft: Readonly<{
+                id: string;
+                automationId: string;
+                revision: number;
+                definition: import("../automations/definition-contracts.js").AutomationRevision;
+                updatedAt: string;
+                archivedAt?: string;
+                storageRevision?: number;
+            }>;
+            aliases: Readonly<Record<string, string>>;
+        }>;
+        getSavedAgent: (agentId: string, revision?: number) => Promise<import("../automations/storage-records.js").AutomationSavedAgentRecord | null>;
+        listSavedAgents: () => Promise<import("../automations/storage-records.js").AutomationSavedAgentRecord[]>;
+        saveAgentFromDraft: (input: {
+            automationId: string;
+            nodeId: string;
+            expectedDraftRevision: number;
+            agentId?: string;
+            expectedAgentRevision?: number;
+        }) => Promise<import("../automations/storage-records.js").AutomationSavedAgentRecord>;
+        validate: (automationId: string) => Promise<readonly Readonly<{
+            code: string;
+            path: string;
+            message: string;
+        }>[]>;
+        catalog: (automationId: string) => Promise<{
+            templates: {
+                id: string;
+                title: string;
+                category: string;
+                description: string;
+                setup: string;
+                toolNames: string[];
+                stepCount: number;
+                agentCount: number;
+                parallelGroupCount: number;
+                level: string;
+                highlights: readonly string[];
+                outputFiles: string[];
+            }[];
+            operations: Readonly<{
+                toolName: string;
+                operationId: string;
+                contractVersion: number;
+                label: string;
+                pluginName?: string;
+                catalogGroups: readonly import("../../capabilities/tool-types.js").ToolCatalogGroup[];
+                toolDescription?: string;
+                permissionMode: "full_access" | "full_plus";
+                effect: "read_only" | "mutating" | "mixed";
+                approval: "request_policy" | "always";
+                input: import("../../capabilities/tool-types.js").ToolNormalInvocationInput;
+                fixedParams?: import("../../capabilities/tool-types.js").ToolNormalInvocationOperation["fixedParams"];
+                payload?: import("../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+                attachmentInput?: import("../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
+                selectionControlIds?: readonly string[];
+            }>[];
+            grantableOperations: Readonly<{
+                toolName: string;
+                operationId: string;
+                contractVersion: number;
+                label: string;
+                pluginName?: string;
+                catalogGroups: readonly import("../../capabilities/tool-types.js").ToolCatalogGroup[];
+                toolDescription?: string;
+                permissionMode: "full_access" | "full_plus";
+                effect: "read_only" | "mutating" | "mixed";
+                approval: "request_policy" | "always";
+                input: import("../../capabilities/tool-types.js").ToolNormalInvocationInput;
+                fixedParams?: import("../../capabilities/tool-types.js").ToolNormalInvocationOperation["fixedParams"];
+                payload?: import("../../capabilities/tool-types.js").ToolNormalInvocationPayload;
+                attachmentInput?: import("../../capabilities/tool-types.js").ToolNormalInvocationAttachmentInput;
+                selectionControlIds?: readonly string[];
+            }>[];
+            models: {
+                provider?: string | undefined;
+                id: string;
+                label: string;
+            }[];
+            savedAgents: {
+                id: string;
+                revision: number;
+                title: string;
+                modelProfileId: string;
+                agent: import("../automations/definition-contracts.js").AgentNode;
+            }[];
+        }>;
+        getGrant: (automationId: string) => Promise<import("../automations/storage-records.js").AutomationGrantRecord | null>;
+        replaceGrant: (input: {
+            automationId: string;
+            expectedGrantRevision: number;
+            mode: import("../scheduler/tool-permission-mode.js").SchedulerToolPermissionMode;
+            operations: readonly import("../automations/definition-contracts.js").OperationRef[];
+            actionId: string;
+        }) => Promise<import("../automations/storage-records.js").AutomationGrantRecord>;
+        publish: (automationId: string, expectedRevision: number) => Promise<{
+            definition: Readonly<{
+                id: string;
+                automationId: string;
+                revision: number;
+                definition: import("../automations/definition-contracts.js").AutomationRevision;
+                publishedAt: string;
+                dependencyFingerprint?: string;
+            }>;
+            job: import("../scheduler/contracts.js").SchedulerAutomationJob;
+        }>;
+        activate(automationId: string): Promise<import("../scheduler/contracts.js").SchedulerAutomationJob>;
+        pause(automationId: string): Promise<import("../scheduler/contracts.js").SchedulerAutomationJob>;
+        runNow(automationId: string, idempotencyKey?: string): Promise<import("../scheduler/contracts.js").SchedulerAutomationRun>;
+        listRuns: (automationId: string, query?: import("../scheduler/contracts.js").SchedulerRunListQuery) => Promise<import("../scheduler/contracts.js").SchedulerAutomationRun[]>;
+        getRun: (runId: string) => Promise<{
+            reportState?: "expired" | undefined;
+            reportExpiredAt?: string | undefined;
+            detailsExpiredAt?: string | undefined;
+            automationId: string;
+            definition: Readonly<{
+                schemaVersion: 1;
+                automationId: string;
+                revision: number;
+                title: string;
+                objective: string;
+                workingDirectory?: string;
+                trigger: import("../automations/definition-contracts.js").AutomationTrigger;
+                source?: import("../automations/definition-contracts.js").FolderSource;
+                inputs: Readonly<Record<string, import("../automations/definition-contracts.js").AutomationJsonValue>>;
+                body: import("../automations/definition-contracts.js").SequenceNode;
+                limits: import("../automations/limits.js").AutomationLimits;
+            }>;
+            nodes: {
+                errorCode?: string | undefined;
+                nodeId: string;
+                status: "failed" | "pending" | "cancelled" | "succeeded" | "running" | "ready" | "skipped" | "interrupted";
+            }[];
+            report: Readonly<{
+                runId: string;
+                automationId: string;
+                definitionRevision: number;
+                outcome: "succeeded" | "completed_with_skips" | "failed" | "cancelled" | "interrupted" | "missed";
+                startedAt: string | null;
+                finishedAt: string;
+                inputIds: readonly string[];
+                inputVersions: readonly Readonly<{
+                    inputId: string;
+                    sourceId: string;
+                    canonicalPath: string;
+                    contentVersion: string;
+                }>[];
+                nodeResults: readonly Readonly<{
+                    nodeId: string;
+                    title?: string;
+                    status: string;
+                    errorCode?: string;
+                    resultRef?: string;
+                }>[];
+                uncertainEffects: readonly Readonly<{
+                    nodeId: string;
+                    attemptId: string;
+                }>[];
+                lateEvidence: readonly Readonly<{
+                    nodeId: string;
+                    attemptId: string;
+                    revision: number;
+                    observedAt: string;
+                    status: "succeeded" | "failed" | "rejected";
+                    errorCode?: string;
+                }>[];
+                artifacts: readonly Readonly<{
+                    id: string;
+                    nodeId?: string;
+                    kind: string;
+                }>[];
+                effectSummary?: import("../automations/step-evidence-effects.js").AutomationRunEffectSummary;
+                modelCalls: number | null;
+                toolCalls: number | null;
+                toolAttempts?: number;
+            }> | null;
+            outputSummary: Readonly<{
+                entries: readonly import("../automations/run-output-summary.js").AutomationRunOutputEntry[];
+                omitted: number;
+            }>;
+            id: string;
+            jobId: string;
+            environmentId: string;
+            target: Readonly<{
+                kind: "automation";
+                automationId: string;
+                definitionRevision: number;
+            }>;
+            title: string;
+            timeZone: string;
+            jobRevision: number;
+            scheduledAt: string;
+            admittedAt?: string;
+            startedAt?: string;
+            finishedAt?: string;
+            trigger: "schedule" | "manual";
+            idempotencyKey?: string;
+            replayOf?: string;
+            status: import("../scheduler/contracts.js").SchedulerRunStatus | "stopping" | "completed_with_skips";
+            error?: string;
+            reportRef?: string;
+        }>;
+        getStepEvidence: (runId: string, nodeId: string, full?: boolean) => Promise<import("../automations/step-evidence.js").AutomationStepEvidence>;
+        stopRun: (runId: string) => Promise<import("../scheduler/contracts.js").SchedulerAutomationRun>;
+        rerun: (runId: string, idempotencyKey: string, confirmed: true) => Promise<import("../scheduler/contracts.js").SchedulerAutomationRun>;
+    };
     projects: Readonly<{
         list: () => Promise<readonly import("../projects/contracts.js").RuntimeProject[]>;
         get: (id: string) => Promise<import("../projects/contracts.js").RuntimeProject | null>;

package/dist/src/runtime/local-host/client-services.js

@@ -1,5 +1,5 @@
 import { bindManagedSessionAttachmentDeletion } from "../session/session-attachment-deletion.js";
-import { LOCAL_SESSION_METHODS, LOCAL_PROJECT_METHODS, LOCAL_ATTACHMENT_METHODS, LOCAL_SCHEDULER_METHODS, } from "./app-service-dispatch.js";
+import { LOCAL_SESSION_METHODS, LOCAL_PROJECT_METHODS, LOCAL_ATTACHMENT_METHODS, LOCAL_SCHEDULER_METHODS, LOCAL_AUTOMATION_METHODS, } from "./app-service-dispatch.js";
 /** Projections of owner APIs; lifecycle remains with the managed application. */
 export function createLocalServiceClients(call) {
     const service = (prefix, methods) => Object.fromEntries(methods.map((method) => [
@@ -9,7 +9,8 @@ export function createLocalServiceClients(call) {
     const sessions = service("sessions", LOCAL_SESSION_METHODS);
     const attachments = service("attachments", LOCAL_ATTACHMENT_METHODS);
     const scheduler = service("scheduler", LOCAL_SCHEDULER_METHODS);
+    const automations = service("automations", LOCAL_AUTOMATION_METHODS);
     bindManagedSessionAttachmentDeletion(sessions, attachments);
     const projects = service("projects", LOCAL_PROJECT_METHODS);
-    return { sessions, attachments, scheduler, projects };
+    return { sessions, attachments, scheduler, automations, projects };
 }

package/dist/src/runtime/local-host/learning-preferences-input.js

@@ -14,6 +14,7 @@ const PREFERENCE_KEYS = [
     "collectionWindow",
     "proactiveEnabled",
     "proactiveModelProfileId",
+    "sparkToolPermissionMode",
     "proactiveIntervalMinutes",
     "proactiveWindow",
     "proactiveMessagesPerDay",

package/dist/src/runtime/model/context-compaction-admission.d.ts

@@ -0,0 +1,21 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import { type RequestMessagesBudgetAssessment } from "../context/request-context-budget.js";
+import type { ModelStepContextCompactionController } from "./context-compaction-contracts.js";
+import { type ContextCompactionIdentity } from "./context-compaction-diagnostics.js";
+type CompactionEnvelope = Readonly<{
+    messages: readonly ChatMessage[];
+    assessment: RequestMessagesBudgetAssessment;
+}>;
+export declare function requiresContextCompaction(eligible: boolean, assessment: RequestMessagesBudgetAssessment): boolean;
+export declare function hasReducedProjection(candidate: RequestMessagesBudgetAssessment, previous: RequestMessagesBudgetAssessment): boolean;
+export declare function isCompactedEnvelopeAdmissible(candidate: RequestMessagesBudgetAssessment, original: RequestMessagesBudgetAssessment): boolean;
+/** The model boundary owns budget decisions; stages own source selection only. */
+export declare function admitCompactedContext(params: CompactionEnvelope & Readonly<{
+    controller: ModelStepContextCompactionController | undefined;
+    assess(messages: readonly ChatMessage[]): Promise<RequestMessagesBudgetAssessment>;
+    assertCurrent(): void;
+    abortSignal: AbortSignal;
+    identity: ContextCompactionIdentity;
+    onEvent?: (name: string, extra?: Record<string, unknown>) => void;
+}>): Promise<CompactionEnvelope>;
+export {};