@abot-ai/runtime 1.5.0 → 1.7.0

package/dist/src/runtime/context/super-context-policy.js

@@ -0,0 +1,35 @@
+import { SUPERVISOR_WORKER_V1_AUTHORITY_SNAPSHOT, } from "../orchestration/role-calls/contracts.js";
+/** Opt-in follows the frozen registered contract, never a model or role name. */
+export function hasSuperContextContract(authority, contractId) {
+    const expected = SUPERVISOR_WORKER_V1_AUTHORITY_SNAPSHOT;
+    if (authority.id !== expected.id)
+        return false;
+    if (authority.version !== expected.version)
+        return false;
+    if (authority.definitionHash !== expected.definitionHash)
+        return false;
+    if (authority.rootContractId !== expected.rootContractId)
+        return false;
+    if (authority.modelWorkPlanAuthority !== expected.modelWorkPlanAuthority)
+        return false;
+    if ((authority.terminalTextMode ?? "normalized") !== "normalized")
+        return false;
+    if (!hasOrderedAuthorityValues(authority.availableSubordinateContractIds, expected.availableSubordinateContractIds))
+        return false;
+    if (!hasOrderedAuthorityValues(authority.capabilityAuthorities, expected.capabilityAuthorities))
+        return false;
+    switch (contractId) {
+        case "supervisor":
+        case "delegated.planner":
+        case "delegated.worker":
+        case "delegated.reviewer":
+            return true;
+        default:
+            return false;
+    }
+}
+function hasOrderedAuthorityValues(actual, expected) {
+    if (actual.length !== expected.length)
+        return false;
+    return actual.every((value, index) => value === expected[index]);
+}

package/dist/src/runtime/context/super-request-tool-results-checkpoint.d.ts

@@ -0,0 +1,6 @@
+import { type SuperCompactionIntegrityInput } from "./semantic-compaction/super-source-integrity.js";
+import type { SemanticCompactionCheckpoint } from "./semantic-compaction/contracts.js";
+import type { RequestToolResultsView } from "./request-tool-results.js";
+import type { ChatMessage } from "../../model-gateway/types.js";
+/** Validates all provenance before projecting a mixed checkpoint at handoff. */
+export declare function projectSuperCompactedRequestToolResults(view: RequestToolResultsView, checkpoint: SemanticCompactionCheckpoint, integrity: SuperCompactionIntegrityInput, message: ChatMessage): ChatMessage;

package/dist/src/runtime/context/super-request-tool-results-checkpoint.js

@@ -0,0 +1,29 @@
+import { assertSuperCompactionCheckpointIntegrity, } from "./semantic-compaction/super-source-integrity.js";
+import { projectCanonicalCapabilityResultCompactionSources } from "./capability-result-compaction-source.js";
+import { MODEL_STEPS } from "../../shared/model-steps.js";
+import { superWorkerCompactionFailureOwner, withSuperWorkerCompactionFailure, } from "./super-worker-compaction-failure.js";
+import { projectRequestToolResultsCheckpointMessage } from "./request-tool-results-checkpoint.js";
+import { bindRequestToolResultsMessage } from "./request-tool-results-message-binding.js";
+import { assertSuperWorkerCompactionSidecarBinding, readSuperWorkerCompactionSidecar, } from "./super-worker-compaction-sidecar.js";
+/** Validates all provenance before projecting a mixed checkpoint at handoff. */
+export function projectSuperCompactedRequestToolResults(view, checkpoint, integrity, message) {
+    const sidecar = readSuperWorkerCompactionSidecar(view);
+    if (!sidecar)
+        throw new Error("context_compaction_source_binding_required");
+    assertSuperWorkerCompactionSidecarBinding(sidecar, {
+        requestId: integrity.requestId,
+        callId: checkpoint.callId,
+        sourceRevision: integrity.head.revision,
+    });
+    return withSuperWorkerCompactionFailure(superWorkerCompactionFailureOwner(sidecar, MODEL_STEPS.WORKER_DECISION, "worker_checkpoint_projection", checkpoint.scopeId), () => {
+        assertSuperCompactionCheckpointIntegrity({ ...integrity, checkpoint });
+        const sources = projectCanonicalCapabilityResultCompactionSources({
+            head: integrity.head,
+            callId: checkpoint.callId,
+        });
+        const projected = projectRequestToolResultsCheckpointMessage(message, checkpoint, new Map(sources.map((source) => [source.sourceRef, source])));
+        if (!projected)
+            throw new Error("context_compaction_source_message_binding_invalid");
+        return bindRequestToolResultsMessage(view, projected.content);
+    });
+}

package/dist/src/runtime/context/super-worker-compaction-failure.d.ts

@@ -0,0 +1,5 @@
+import type { ModelStep } from "../../shared/model-steps.js";
+import type { SuperCompactionFailureOwner } from "./super-compaction-failure-owner.js";
+import type { SuperWorkerCompactionSidecar } from "./super-worker-compaction-sidecar.js";
+export { withSuperCompactionFailure as withSuperWorkerCompactionFailure } from "./super-compaction-failure-owner.js";
+export declare function superWorkerCompactionFailureOwner(sidecar: SuperWorkerCompactionSidecar | undefined, modelStep: ModelStep | undefined, phase: string, scopeId: string): SuperCompactionFailureOwner | undefined;

package/dist/src/runtime/context/super-worker-compaction-failure.js

@@ -0,0 +1,19 @@
+export { withSuperCompactionFailure as withSuperWorkerCompactionFailure } from "./super-compaction-failure-owner.js";
+export function superWorkerCompactionFailureOwner(sidecar, modelStep, phase, scopeId) {
+    if (!sidecar || !modelStep)
+        return undefined;
+    return Object.freeze({
+        head: sidecar.head,
+        binding: Object.freeze({
+            requestId: sidecar.requestId,
+            callId: sidecar.callId,
+            parentCallId: sidecar.parentCallId,
+            contractId: "delegated.worker",
+            invocationAttempt: sidecar.invocationAttempt,
+            sourceRevision: sidecar.sourceRevision,
+            modelStep,
+            phase,
+            scopeId,
+        }),
+    });
+}

package/dist/src/runtime/context/super-worker-compaction-projection.d.ts

@@ -0,0 +1,8 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+import { type SuperWorkerCompactionSidecar } from "./super-worker-compaction-sidecar.js";
+/** Runtime attachment is authority; a copied JSON capsule cannot mint it. */
+export declare function resolveSuperWorkerCompactionProjection(messages: readonly ChatMessage[], binding: Readonly<{
+    requestId: string;
+    callId: string;
+    sourceRevision: number;
+}>, supplied?: SuperWorkerCompactionSidecar, required?: boolean): SuperWorkerCompactionSidecar | undefined;

package/dist/src/runtime/context/super-worker-compaction-projection.js

@@ -0,0 +1,41 @@
+import { readBoundRequestToolResultsView } from "./request-tool-results-message-binding.js";
+import { assertSuperWorkerCompactionSidecarBinding, readSuperWorkerCompactionSidecar, } from "./super-worker-compaction-sidecar.js";
+/** Runtime attachment is authority; a copied JSON capsule cannot mint it. */
+export function resolveSuperWorkerCompactionProjection(messages, binding, supplied, required = false) {
+    let sidecar = supplied;
+    for (const message of messages) {
+        const view = readBoundRequestToolResultsView(message);
+        if (!view)
+            continue;
+        const bound = readSuperWorkerCompactionSidecar(view);
+        if (!bound)
+            continue;
+        assertSuperWorkerCompactionSidecarBinding(bound, binding);
+        if (sidecar && sidecar !== bound) {
+            throw new Error("context_compaction_source_binding_conflict");
+        }
+        sidecar = bound;
+    }
+    if (!sidecar && required)
+        throw new Error("context_compaction_source_binding_required");
+    if (!sidecar)
+        return undefined;
+    assertSuperWorkerCompactionSidecarBinding(sidecar, binding);
+    for (const message of messages) {
+        if (!isRequestToolResultsCapsule(message))
+            continue;
+        if (!readBoundRequestToolResultsView(message)) {
+            throw new Error("context_compaction_source_message_binding_invalid");
+        }
+    }
+    return sidecar;
+}
+function isRequestToolResultsCapsule(message) {
+    try {
+        return (JSON.parse(message.content)?.kind ===
+            "runtime_request_tool_results_v1");
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/runtime/context/super-worker-compaction-sidecar.d.ts

@@ -0,0 +1,21 @@
+import type { RoleCallLedgerHead } from "../orchestration/role-calls/index.js";
+import type { SemanticCompactionSource } from "./semantic-compaction/contracts.js";
+export type SuperWorkerCompactionSidecar = Readonly<{
+    head: RoleCallLedgerHead;
+    parentCallId: string | null;
+    invocationAttempt: number;
+    requestId: string;
+    callId: string;
+    sourceRevision: number;
+    sources: readonly SemanticCompactionSource[];
+    eligibleExecutionIds: readonly string[];
+}>;
+/** Only a verified SUPER producing Worker may mint a non-serializable sidecar. */
+export declare function bindSuperWorkerCompactionSources<T extends object>(carrier: T, head: RoleCallLedgerHead, callId: string): Readonly<T>;
+/** Copying a carrier never copies authority, including object/array spread. */
+export declare function readSuperWorkerCompactionSidecar(carrier: object): SuperWorkerCompactionSidecar | undefined;
+export declare function assertSuperWorkerCompactionSidecarBinding(sidecar: SuperWorkerCompactionSidecar, binding: Readonly<{
+    requestId: string;
+    callId: string;
+    sourceRevision?: number;
+}>): void;

package/dist/src/runtime/context/super-worker-compaction-sidecar.js

@@ -0,0 +1,67 @@
+import { projectCurrentRequestToolResults } from "./request-tool-results-supersession.js";
+import { projectCanonicalRequestToolResult } from "./canonical-capability-result.js";
+import { projectCanonicalCapabilityResultCompactionSources } from "./capability-result-compaction-source.js";
+import { hasSuperContextContract } from "./super-context-policy.js";
+const SOURCE_BINDING = Symbol("superWorkerCompactionSources");
+/** Only a verified SUPER producing Worker may mint a non-serializable sidecar. */
+export function bindSuperWorkerCompactionSources(carrier, head, callId) {
+    if (!hasSuperContextContract(head.policy.authority, "delegated.worker"))
+        return Object.freeze(carrier);
+    const call = head.state.calls.find((candidate) => candidate.callId === callId);
+    if (!call || call.roleId !== "worker")
+        return Object.freeze(carrier);
+    const results = head.state.capabilityExecutions
+        .filter((execution) => execution.callId === callId && execution.status === "settled")
+        .map((execution) => projectCanonicalRequestToolResult(head, execution));
+    const eligibleExecutionIds = Object.freeze(projectCurrentRequestToolResults(results)
+        .filter((result) => result.summaryProjection !== "superseded_target_evidence")
+        .map((result) => result.executionId));
+    const sidecarFields = {
+        parentCallId: call.parentCallId,
+        invocationAttempt: call.activationCount,
+        eligibleExecutionIds,
+        requestId: head.state.requestId,
+        callId,
+        sourceRevision: head.revision,
+        sources: projectCanonicalCapabilityResultCompactionSources({
+            head,
+            callId,
+        }),
+    };
+    Object.defineProperty(sidecarFields, "head", {
+        value: head,
+        enumerable: false,
+    });
+    const sidecar = Object.freeze(sidecarFields);
+    Object.defineProperty(carrier, SOURCE_BINDING, {
+        value: Object.freeze({ carrier, sidecar }),
+        enumerable: false,
+        writable: false,
+        configurable: false,
+    });
+    return Object.freeze(carrier);
+}
+/** Copying a carrier never copies authority, including object/array spread. */
+export function readSuperWorkerCompactionSidecar(carrier) {
+    const descriptor = Object.getOwnPropertyDescriptor(carrier, SOURCE_BINDING);
+    if (!descriptor)
+        return undefined;
+    const binding = descriptor.value;
+    if (!binding ||
+        binding.carrier !== carrier ||
+        !Object.isFrozen(binding) ||
+        descriptor.enumerable) {
+        throw new Error("context_compaction_source_binding_invalid");
+    }
+    return binding.sidecar;
+}
+export function assertSuperWorkerCompactionSidecarBinding(sidecar, binding) {
+    if (sidecar.requestId !== binding.requestId)
+        throw new Error("context_compaction_source_request_invalid");
+    if (sidecar.callId !== binding.callId)
+        throw new Error("context_compaction_source_call_invalid");
+    if (binding.sourceRevision !== undefined &&
+        sidecar.sourceRevision !== binding.sourceRevision) {
+        throw new Error("context_compaction_source_revision_invalid");
+    }
+}

package/dist/src/runtime/context/verified-compaction-projection.d.ts

@@ -0,0 +1,7 @@
+import type { ChatMessage } from "../../model-gateway/types.js";
+/** Request-local proof minted only by a verified checkpoint projection. */
+export declare function createVerifiedCompactionProjection(): Readonly<{
+    record(message: ChatMessage): void;
+    clear(): void;
+    contains(messages: readonly ChatMessage[]): boolean;
+}>;

package/dist/src/runtime/context/verified-compaction-projection.js

@@ -0,0 +1,16 @@
+/** Request-local proof minted only by a verified checkpoint projection. */
+export function createVerifiedCompactionProjection() {
+    const projected = new Map();
+    return Object.freeze({
+        record(message) {
+            projected.set(message, message.content);
+        },
+        clear() {
+            projected.clear();
+        },
+        contains(messages) {
+            return (projected.size > 0 &&
+                [...projected].every(([message, content]) => message.content === content && messages.includes(message)));
+        },
+    });
+}

package/dist/src/runtime/default-environment-adapters.d.ts

@@ -1,5 +1,6 @@
 import { type RuntimeAttachmentStore } from "./attachments/store.js";
 import type { ConversationContextProvider, EventSink, EventSinkFactory, ModelGatewayClient, RuntimeConfig, SessionStore, SkillProvider, ToolRegistry, WorkspaceProvider } from "./ports.js";
+import type { AutomationService } from "./automations/service.js";
 import type { SchedulerService } from "./scheduler/contracts.js";
 import { type LongTermMemoryService } from "./long-term-memory/index.js";
 export declare function createDefaultAttachmentStore(config: RuntimeConfig): RuntimeAttachmentStore;
@@ -8,6 +9,9 @@ export declare function createDefaultConversationContextProvider(): Conversation
 export declare function createDefaultToolRegistry(config?: RuntimeConfig, scheduling?: {
     service: SchedulerService;
     ready: () => Promise<void>;
+}, authoring?: {
+    getService: () => AutomationService;
+    ready: () => Promise<void>;
 }): ToolRegistry;
 export declare function createDefaultSkillProvider(config?: RuntimeConfig, options?: {
     toolRegistry?: Pick<ToolRegistry, "listDefinitions">;

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

@@ -12,6 +12,8 @@ import { configureDebugLogger } from "./observability/debug-logger.js";
 import { createConfiguredToolRegistry } from "./capabilities/configured-tool-registry.js";
 import { runtimePluginsToToolModules } from "./plugins/loader.js";
 import { createSchedulingToolModule } from "./capabilities/scheduling/tool-module.js";
+import { createAutomationDraftToolModule } from "./capabilities/automations/tool-module.js";
+import { createAutomationBuilderToolModule } from "./capabilities/automation-builder/tool-module.js";
 import { createFileLongTermMemoryRepository } from "./adapters/long-term-memory/file-repository.js";
 import { createInMemoryLongTermMemoryRepository } from "./adapters/long-term-memory/in-memory-repository.js";
 import { createLongTermMemoryService, } from "./long-term-memory/index.js";
@@ -29,7 +31,7 @@ export function createDefaultConversationContextProvider() {
         buildContextWindow,
     };
 }
-export function createDefaultToolRegistry(config, scheduling) {
+export function createDefaultToolRegistry(config, scheduling, authoring) {
     const plugins = loadRuntimeCapabilityPlugins(config);
     return createConfiguredToolRegistry(config, [
         ...runtimePluginsToToolModules(plugins),
@@ -38,6 +40,10 @@ export function createDefaultToolRegistry(config, scheduling) {
                 createSchedulingToolModule(scheduling.service, config, scheduling.ready),
             ]
             : []),
+        ...(config && authoring
+            ? [createAutomationDraftToolModule(authoring.getService, authoring.ready),
+                createAutomationBuilderToolModule(authoring.getService, authoring.ready)]
+            : []),
     ]);
 }
 export function createDefaultSkillProvider(config, options = {}) {

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

@@ -12,6 +12,281 @@ export declare function createLocalRuntimeApplication(config?: RuntimeConfig, op
         sessions: import("./ports.js").SessionStore;
         attachments: import("./index.js").RuntimeAttachmentStore;
         scheduler: Omit<import("./scheduler/contracts.js").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;
+                    outputChannels?: import("../capabilities/tool-types.js").ToolNormalInvocationOperation["outputChannels"];
+                    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;
+                    outputChannels?: import("../capabilities/tool-types.js").ToolNormalInvocationOperation["outputChannels"];
+                    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>;
@@ -55,6 +330,10 @@ export declare function createLocalRuntimeApplication(config?: RuntimeConfig, op
         }>) => 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>;
     };
+    nativePermissions: Readonly<{
+        status(): Promise<import("../computer-access/native-permission-contract.js").NativePermissionStatus>;
+        prepare(input: import("../computer-access/native-permission-contract.js").NativePermissionInput): Promise<import("../computer-access/native-permission-contract.js").NativePermissionResult>;
+    }>;
     start: () => Promise<void>;
     stop(): Promise<void>;
     getOwnership: () => "owner" | "client" | undefined;

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

@@ -7,6 +7,7 @@ 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";
+import { createLocalNativePermissionClient } from "./local-host/client-native-permissions.js";
 /** Managed library entry: attach to the environment owner or create it once. */
 export function createLocalRuntimeApplication(config = loadRuntimeConfig(), options = {}) {
     let connection;
@@ -27,6 +28,11 @@ export function createLocalRuntimeApplication(config = loadRuntimeConfig(), opti
     });
     const memory = createLocalMemoryClient(call, config.longTermMemory?.enabled === true);
     const learning = createLocalLearningClient(call);
+    const nativePermissions = createLocalNativePermissionClient((method, args) => {
+        if (stopped || !connection)
+            return Promise.reject(new Error("local_runtime_not_started"));
+        return connection.call(method, args);
+    });
     const services = Object.freeze({
         config,
         ...createLocalServiceClients(call),
@@ -89,6 +95,7 @@ export function createLocalRuntimeApplication(config = loadRuntimeConfig(), opti
         services,
         requests: client.requests,
         approvals: client.approvals,
+        nativePermissions,
         start,
         async stop() {
             stopped = true;