@abot-ai/runtime 1.5.0 → 1.7.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,8 @@ 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";
+import { steeringInputDiagnosticFields, steeringResultDiagnosticFields, traceLocalRequest, traceLocalRequestFailure, } from "./local-request-diagnostics.js";
 export async function createLocalRuntimeOwner(config, overrides = {}) {
     const listeners = new Set();
     const publish = (event) => {
@@ -20,6 +22,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),
@@ -29,7 +32,7 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
     const unsubscribe = application.subscribeScheduledEvents((event) => {
         publish({ type: "scheduled.event", event });
         if (event.type === "completed" || event.type === "failed")
-            controls.finish(String(event.requestId));
+            controls.finish(String(event.requestId), event.type === "completed" ? "scheduled_completed" : "scheduled_failed");
     });
     const unsubscribeLearning = application.services.passiveLearning?.subscribe((change) => {
         const event = projectLearningChangedEvent(change);
@@ -51,6 +54,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 +73,31 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
                         return;
                     return controls.attach(args[0], args[1], peer);
                 }
-                if (method === "request.steer")
-                    return controls.steer(args[0], args[1]);
+                if (method === "request.steer") {
+                    const sessionId = controls.activeSessionId(args[0]);
+                    const fields = {
+                        ...steeringInputDiagnosticFields(args[0], args[1]),
+                        sessionId,
+                        peerId: peer.id,
+                        ownerEpoch: savedApprovals.ownerEpoch,
+                        environmentId: config.runtimeId,
+                    };
+                    traceLocalRequest("steer.owner_received", fields);
+                    try {
+                        if (sessionId)
+                            await application.services.sessions.assertInteractiveSession?.(sessionId);
+                        const result = controls.steer(args[0], args[1]);
+                        traceLocalRequest("steer.owner_result", {
+                            ...fields,
+                            ...steeringResultDiagnosticFields(result),
+                        });
+                        return result;
+                    }
+                    catch (error) {
+                        traceLocalRequestFailure("steer.owner_failed", fields, error);
+                        throw error;
+                    }
+                }
                 if (method === "request.cancel") {
                     if (await savedApprovals.cancel(args[0], args[1], args[2]))
                         return { accepted: true };
@@ -101,6 +129,7 @@ export async function createLocalRuntimeOwner(config, overrides = {}) {
             if (shutdown)
                 return shutdown;
             activity.stop();
+            nativePermissions.stop();
             application.services.requestAdmission?.close();
             memory.stop();
             controls.stop();
@@ -127,23 +156,49 @@ 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");
+    const diagnosticFields = {
+        requestId: message.requestId,
+        sessionId: typeof message.sessionId === "string" ? message.sessionId : undefined,
+        peerId: peer.id,
+        ownerEpoch: savedApprovals.ownerEpoch,
+        environmentId: application.services.config.runtimeId,
+    };
+    traceLocalRequest("run.received", diagnosticFields);
+    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)
         options.approvalExecution = { activation: savedApprovals.activation() };
+    traceLocalRequest("run.control_ready", {
+        ...diagnosticFields,
+        activationId: options.approvalExecution?.activation.activationId,
+    });
     const socket = {
         send(data) {
             controls.send(message.requestId, JSON.parse(data));
         },
     };
+    let diagnosticStage = "acceptance";
     try {
         await peer.callClient("request.accepted", [message.requestId]);
         activity.assertAcceptingRequests();
+        diagnosticStage = "execution";
+        traceLocalRequest("run.execution_started", diagnosticFields);
         const result = await application.requests.handle(socket, message, options);
+        traceLocalRequest("run.handler_settled", {
+            ...diagnosticFields,
+            awaitingApproval: result?.kind === "awaiting_approval",
+        });
+        diagnosticStage = "delivery_drain";
         await controls.drain(message.requestId);
         return result;
     }
+    catch (error) {
+        traceLocalRequestFailure("run.failed", { ...diagnosticFields, stage: diagnosticStage }, error);
+        throw error;
+    }
     finally {
-        controls.finish(message.requestId);
+        controls.finish(message.requestId, "ordinary_handler_finally");
     }
 }

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

@@ -4,6 +4,7 @@ import { type RequestCancellationResult } from "../request/cancellation.js";
 import { type RequestSteeringUpdate } from "../request/request-steering.js";
 import type { SchedulerRun } from "../scheduler/contracts.js";
 import type { LocalRuntimePeer } from "./contracts.js";
+import { type LocalRequestFinishSource } from "./local-request-diagnostics.js";
 import type { LocalPendingToolApproval, LocalToolApprovalDecisionResult } from "./request-approval-contracts.js";
 export type LocalRequestRunOptions = {
     approvalAvailable?: boolean;
@@ -21,12 +22,14 @@ 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;
-    finish(requestId: string): void;
+    activeSessionId(requestId: unknown): string | undefined;
+    finish(requestId: string, source?: LocalRequestFinishSource): void;
     cancel(requestId: unknown, sessionId: unknown, wait?: unknown): RequestCancellationResult;
     private matchesResumedWaitCancellation;
     private claimFinalization;
     stop(): void;
     private open;
+    private diagnosticFields;
     hasActiveRequest(requestId: unknown, sessionId: unknown): boolean;
     listApprovals(sessionId?: unknown): LocalPendingToolApproval[];
     decideApproval(input: unknown, peer: LocalRuntimePeer): LocalToolApprovalDecisionResult;

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

@@ -3,6 +3,8 @@ import { createRequestCancellationError, } from "../request/cancellation.js";
 import { createRequestSteeringInbox, } from "../request/request-steering.js";
 import { hasApprovalDecisionIdentity, LocalRequestApprovals, } from "./app-request-approvals.js";
 import { LocalRequestDelivery } from "./app-request-delivery.js";
+import { createRequestControlDiagnosticId } from "../observability/request-control-diagnostics.js";
+import { steeringInputDiagnosticFields, steeringResultDiagnosticFields, traceLocalRequest, } from "./local-request-diagnostics.js";
 export class LocalRequestControls {
     publish;
     active = new Map();
@@ -31,16 +33,23 @@ export class LocalRequestControls {
             }
         }
         catch (error) {
-            this.finish(requestId);
+            this.finish(requestId, "initial_steering_rejected");
             throw error;
         }
         const control = this.active.get(requestId);
         control.resumedWait = resumedWait;
         control.peer = peer;
         control.delivery.attach(peer);
+        traceLocalRequest("control.attached", {
+            ...this.diagnosticFields(requestId, control),
+            peerId: peer.id,
+            generation: resumedWait?.generation,
+            waitId: resumedWait?.waitId,
+            revision: resumedWait?.revision,
+        });
         return {
             abortSignal: control.abort.signal,
-            claimFinalization: () => this.claimFinalization(control),
+            claimFinalization: () => this.claimFinalization(requestId, control),
             requestSteering: steering,
             ...(options.approvalAvailable
                 ? { toolApprovalController: this.approvals(requestId, control) }
@@ -54,7 +63,7 @@ export class LocalRequestControls {
         const peer = this.controlPeers.values().next().value;
         return {
             abortSignal: control.abort.signal,
-            claimFinalization: () => this.claimFinalization(control),
+            claimFinalization: () => this.claimFinalization(run.requestId, control),
             requestSteering: steering,
             ...(peer
                 ? { toolApprovalController: this.approvals(run.requestId, control) }
@@ -62,24 +71,70 @@ export class LocalRequestControls {
         };
     }
     steer(requestId, update) {
-        if (typeof requestId !== "string")
+        const inputFields = steeringInputDiagnosticFields(requestId, update);
+        if (typeof requestId !== "string") {
+            traceLocalRequest("steer.rejected", {
+                ...inputFields,
+                diagnosticReason: "invalid_request_id",
+                reason: "request_not_active",
+            });
             return { ok: false, reason: "request_not_active" };
+        }
         const control = this.active.get(requestId);
-        if (!control || control.abort.signal.aborted)
+        const fields = {
+            ...inputFields,
+            ...this.diagnosticFields(requestId, control),
+        };
+        if (!control || control.abort.signal.aborted) {
+            traceLocalRequest("steer.rejected", {
+                ...fields,
+                diagnosticReason: control ? "control_aborted" : "control_missing",
+                reason: "request_not_active",
+            });
             return { ok: false, reason: "request_not_active" };
-        if (!update || typeof update !== "object")
+        }
+        if (!update || typeof update !== "object") {
+            traceLocalRequest("steer.rejected", {
+                ...fields,
+                diagnosticReason: "invalid_update_shape",
+                reason: "invalid_steer_request",
+            });
             return { ok: false, reason: "invalid_steer_request" };
+        }
         const input = update;
-        if (typeof input.steerId !== "string" || typeof input.text !== "string")
+        if (typeof input.steerId !== "string" || typeof input.text !== "string") {
+            traceLocalRequest("steer.rejected", {
+                ...fields,
+                diagnosticReason: "invalid_update_shape",
+                reason: "invalid_steer_request",
+            });
             return { ok: false, reason: "invalid_steer_request" };
-        return control.steering.append({
+        }
+        const result = control.steering.append({
             steerId: input.steerId,
             text: input.text,
         });
+        traceLocalRequest("steer.result", {
+            ...fields,
+            diagnosticReason: "inbox_result",
+            ...steeringResultDiagnosticFields(result),
+        });
+        return result;
     }
-    finish(requestId) {
+    activeSessionId(requestId) {
+        return typeof requestId === "string"
+            ? this.active.get(requestId)?.sessionId
+            : undefined;
+    }
+    finish(requestId, source = "unspecified") {
         const entry = this.active.get(requestId);
         this.active.delete(requestId);
+        traceLocalRequest("control.finished", {
+            ...this.diagnosticFields(requestId, entry),
+            controlPresent: false,
+            removed: Boolean(entry),
+            source,
+        });
         this.pendingApprovals.cancel(requestId);
         entry?.delivery.finish();
         void entry?.steering.close();
@@ -97,6 +152,7 @@ export class LocalRequestControls {
         if (!this.matchesResumedWaitCancellation(control, wait))
             return { accepted: false, reason: "request_not_active" };
         control.abort.abort(createRequestCancellationError());
+        traceLocalRequest("cancel.accepted", this.diagnosticFields(String(requestId), control));
         return { accepted: true };
     }
     matchesResumedWaitCancellation(control, input) {
@@ -116,16 +172,18 @@ export class LocalRequestControls {
             return false;
         return command.revision === wait.revision;
     }
-    claimFinalization(control) {
+    claimFinalization(requestId, control) {
         // In-flight requests retain this exact control until canonical finalization.
         control.abort.signal.throwIfAborted();
         control.finalizing = true;
+        traceLocalRequest("finalization.claimed", this.diagnosticFields(requestId, control));
     }
     stop() {
         this.stopped = true;
         this.controlPeers.clear();
         for (const [requestId, control] of this.active) {
             control.abort.abort(createRequestInterruptionError());
+            traceLocalRequest("control.interrupted", this.diagnosticFields(requestId, control));
         }
         // Accepted requests retain their controls and inboxes until finalization.
     }
@@ -134,8 +192,13 @@ export class LocalRequestControls {
             throw new Error("local_runtime_owner_stopped");
         if (!requestId || this.active.has(requestId))
             throw new Error("local_runtime_request_already_active");
-        const steering = createRequestSteeringInbox({ requestId });
+        const inboxId = createRequestControlDiagnosticId("owner_inbox");
+        const steering = createRequestSteeringInbox({
+            requestId,
+            diagnostics: { inboxId, origin: "local_owner" },
+        });
         this.active.set(requestId, {
+            inboxId,
             steering,
             sessionId,
             abort: new AbortController(),
@@ -143,8 +206,30 @@ export class LocalRequestControls {
             delivery: new LocalRequestDelivery(requestId),
             ...(run ? { run } : {}),
         });
+        traceLocalRequest("control.opened", {
+            requestId,
+            sessionId,
+            inboxId,
+            scheduled: Boolean(run),
+            activeControlCount: this.active.size,
+        });
         return steering;
     }
+    diagnosticFields(requestId, control) {
+        return {
+            requestId,
+            sessionId: control?.sessionId,
+            inboxId: control?.inboxId,
+            controlPresent: Boolean(control),
+            aborted: control?.abort.signal.aborted,
+            finalizing: control?.finalizing,
+            ownerStopped: this.stopped,
+            activeControlCount: this.active.size,
+            generation: control?.resumedWait?.generation,
+            waitId: control?.resumedWait?.waitId,
+            revision: control?.resumedWait?.revision,
+        };
+    }
     hasActiveRequest(requestId, sessionId) {
         if (typeof requestId !== "string")
             return false;

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-requests.js

@@ -1,3 +1,4 @@
+import { steeringInputDiagnosticFields, steeringResultDiagnosticFields, traceLocalRequest, traceLocalRequestFailure, } from "./local-request-diagnostics.js";
 import { PendingClientRequest, hasLiveApprovalAttachment, hasApprovalEndedBeforeAttachment, isApprovalTransportLoss, shouldRetainDetachedRequest, } from "./pending-client-request.js";
 /** Client projections only. The owner validates and commits every steering update. */
 export class LocalRuntimeClientRequests {
@@ -55,11 +56,37 @@ export class LocalRuntimeClientRequests {
             return outcome;
         },
         steer: async (requestId, input) => {
-            await this.active.get(requestId)?.accepted;
-            return (await this.call("request.steer", [
-                requestId,
-                input,
-            ]));
+            const state = this.active.get(requestId);
+            const fields = {
+                ...steeringInputDiagnosticFields(requestId, input),
+                sessionId: state?.sessionId,
+                clientStatePresentAtEntry: Boolean(state),
+                detachedAtEntry: state?.detached,
+            };
+            traceLocalRequest("steer.client_requested", fields);
+            await state?.accepted;
+            const current = this.active.get(requestId);
+            const dispatchFields = {
+                ...fields,
+                clientStatePresentAtDispatch: Boolean(current),
+                clientStateUnchanged: current === state,
+            };
+            traceLocalRequest("steer.client_dispatch_attempted", dispatchFields);
+            try {
+                const result = (await this.call("request.steer", [
+                    requestId,
+                    input,
+                ]));
+                traceLocalRequest("steer.client_result", {
+                    ...dispatchFields,
+                    ...steeringResultDiagnosticFields(result),
+                });
+                return result;
+            }
+            catch (error) {
+                traceLocalRequestFailure("steer.client_failed", dispatchFields, error);
+                throw error;
+            }
         },
     };
     approvals = {