@dougbots/avenor-core 0.14.0 → 0.15.0

package/dist/index.d.ts

@@ -149,6 +149,15 @@ declare class RpcError extends Error {
   readonly data?: unknown;
   constructor(code: number, message: string, data?: unknown);
 }
+type OwnerAuthFailureKind = 'unauthenticated' | 'unsupported' | 'timeout';
+/** A classified owner-authentication rejection, not generic transport failure. */
+declare class OwnerAuthError extends Error {
+  readonly kind: OwnerAuthFailureKind;
+  constructor(kind: OwnerAuthFailureKind, options?: {
+    code?: number;
+    reason?: string;
+  });
+}
 declare class Client {
   private socket;
   private rl;
@@ -171,6 +180,22 @@ declare class Client {
   call(method: string, params?: unknown, opts?: {
     timeoutMs?: number;
   }): Promise<unknown>;
+  /**
+   * Send a credential-free identity probe. The control server returns the
+   * startup token only after it has published its own owner record.
+   */
+  identity(timeoutMs?: number): Promise<string>;
+  /**
+   * Present the owner capability on this connection. The caller must already
+   * have bound the connection to a trusted peer: an owner attach checks the
+   * socket's ownership and identity, and an owned start proves the child with
+   * its attempt token.
+   */
+  authenticateOwner(capability: {
+    id: string;
+    secret: string;
+  }, timeoutMs?: number): Promise<void>;
+  private sendCall;
   subscribe(options?: SubscribeOptions): Promise<void>;
   events(options?: SubscribeOptions): AsyncIterableIterator<Event>;
   history(options: HistoryOptions): Promise<HistoryResult>;
@@ -216,8 +241,42 @@ declare class Client {
 }
 declare function dial(socketPath: string, opts?: {
   callTimeoutMs?: number;
+  connectTimeoutMs?: number;
 }): Promise<Client>;
 //#endregion
+//#region src/owner-attach.d.ts
+/** The owner record published beside a control socket is absent. */
+declare class OwnerRecordMissingError extends Error {
+  readonly socketPath: string;
+  constructor(socketPath: string);
+}
+/** The record or the socket it names no longer describes the live path. */
+declare class StaleOwnerRecordError extends Error {
+  readonly socketPath: string;
+  readonly reason: string;
+  constructor(socketPath: string, reason: string);
+}
+/**
+ * The control socket path is not bound to this euid, or its directory is
+ * writable by another user. No credential byte may be sent to that peer.
+ */
+declare class ForeignPeerError extends Error {
+  readonly socketPath: string;
+  readonly euid: number;
+  readonly reason: string;
+  readonly peerUID?: number | undefined;
+  constructor(socketPath: string, euid: number, reason: string, peerUID?: number | undefined);
+}
+interface OwnerAttachOptions {
+  timeoutMs?: number;
+}
+/**
+ * Load the owner record, bind the socket path to this euid and require it to be
+ * the record's socket, dial, re-check the socket identity and authenticate. The
+ * whole attach is bounded by the timeout.
+ */
+declare function attachOwner(socketPath: string, options?: OwnerAttachOptions): Promise<Client>;
+//#endregion
 //#region src/run-events.d.ts
 type RunChunkRole = 'assistant' | 'thought' | 'user';
 interface RunPermissionOption {
@@ -452,7 +511,11 @@ declare class Supervisor {
 declare function socketsRoot(): string;
 //#endregion
 //#region src/tools/get-supervisor-client.d.ts
-declare function getSupervisorClient(supervisorId: string | undefined): Promise<{
+interface SupervisorClientOptions {
+  /** Attach with the socket's published owner capability instead of a bare dial. */
+  owner?: boolean;
+}
+declare function getSupervisorClient(supervisorId: string | undefined, options?: SupervisorClientOptions): Promise<{
   client: Client;
   isSingleton: boolean;
   sup: Supervisor | null;
@@ -660,6 +723,18 @@ interface AskResult {
   reply: string;
   from_run_id: string;
 }
+declare function extractReplyMessage(result: Record<string, unknown>): string;
+/**
+ * Build the failure message every ask path reports: the broker message id plus
+ * whether the ask edge is still pending (withdrawable via avenor_cancel) or
+ * already gone.
+ */
+declare function formatAskFailure(messageId: string, pending: boolean, detail: string): string;
+/**
+ * Reduce a caller-supplied ask timeout to what the broker accepts: a positive
+ * finite number of milliseconds, or undefined to keep the broker's own wait.
+ */
+declare function normalizeAskTimeoutMs(timeoutMs: number | undefined): number | undefined;
 declare const askTool: (args: AskToolArgs) => Promise<AskResult>;
 //#endregion
 //#region src/tools/peers.d.ts
@@ -805,4 +880,4 @@ type WorkflowReadyResult = Record<string, unknown>;
 declare function createWorkflowReadyTool(getSupervisorClient: GetSupervisorClient): (args: WorkflowReadyToolArgs) => Promise<WorkflowReadyResult>;
 declare const workflowReadyTool: (args: WorkflowReadyToolArgs) => Promise<WorkflowReadyResult>;
 //#endregion
-export { type AskResult, type AskToolArgs, type BrokerReceiveArgs, type BrokerReceiveResult, type BrokerReplyArgs, type BrokerReplyResult, type CancelResult, type CancelToolArgs, type Client, DEFAULT_RUN_REDUCER_LIMITS, type Event, type ExecutionIdentity, type FollowUpToolArgs, type FollowUpToolResult, type HistoryOptions, type HistoryResult, type InboundAsk, type InspectResult, type KillResult, type KillToolArgs, type NormalizedRunEvent, type ObserveRunOptions, type PeerEntry, type PeersResult, type ResultResult, type ResultToolArgs, RpcError, type RunChunkRole, type RunIdentity, type RunInfo, type RunObserver, type RunObserverClient, type RunPermissionOption, type RunPermissionSummary, RunReducer, type RunReducerLimits, type RunSnapshot, type RunSnapshotSeed, type RunToolState, type RunToolSummary, type RunTranscriptEntry, type SpawnMetadata, type SpawnParams, type SpawnResult, type SpawnSelectionInput, type SpawnToolArgs, type SpawnToolResult, type StatusListResult, type StatusResult, type StatusToolArgs, type StatusView, type SubscribeOptions, Supervisor, type SupervisorOptions, THINKING_LEVELS, type ThinkingLevel, type ThinkingOutcome, type WorkflowCompleteParams, type WorkflowCompleteResult, type WorkflowCompleteToolArgs, type WorkflowControllerCreateParams, type WorkflowControllerStatusResult, type WorkflowControllerStatusToolArgs, type WorkflowEventsResult, type WorkflowEventsToolArgs, type WorkflowGateOperation, type WorkflowGateParams, type WorkflowGateResult, type WorkflowGateToolArgs, type WorkflowHeartbeatParams, type WorkflowInspectResult, type WorkflowInspectToolArgs, type WorkflowReadyResult, type WorkflowReadyToolArgs, type WorkflowStatusResult, type WorkflowStatusToolArgs, type WorkflowWaitResult, type WorkflowWaitToolArgs, answerPermissionTool, askTool, brokerReceiveTool, brokerReplyTool, cancelTool, createRunSnapshot, createWorkflowCompleteTool, createWorkflowControllerStatusTool, createWorkflowEventsTool, createWorkflowGateTool, createWorkflowInspectTool, createWorkflowReadyTool, createWorkflowStatusTool, createWorkflowWaitTool, dial, evaluateThinkingPolicy, eventsTool, extractEventText, findAvenorBinary, followUpTool, getInstallDir, getVersion, inspectTool, installerBinaryPath, isThinkingLevel, killTool, normalizeRunEvent, observeRun, peersTool, reduceRunSnapshot, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, validateThinking, validateThinkingForBackend, validateThinkingForBackendResume, workflowCompleteTool, workflowControllerStatusTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowReadyTool, workflowStatusTool, workflowWaitTool };
+export { type AskResult, type AskToolArgs, type BrokerReceiveArgs, type BrokerReceiveResult, type BrokerReplyArgs, type BrokerReplyResult, type CancelResult, type CancelToolArgs, type Client, DEFAULT_RUN_REDUCER_LIMITS, type Event, type ExecutionIdentity, type FollowUpToolArgs, type FollowUpToolResult, ForeignPeerError, type HistoryOptions, type HistoryResult, type InboundAsk, type InspectResult, type KillResult, type KillToolArgs, type NormalizedRunEvent, type ObserveRunOptions, type OwnerAttachOptions, OwnerAuthError, OwnerRecordMissingError, type PeerEntry, type PeersResult, type ResultResult, type ResultToolArgs, RpcError, type RunChunkRole, type RunIdentity, type RunInfo, type RunObserver, type RunObserverClient, type RunPermissionOption, type RunPermissionSummary, RunReducer, type RunReducerLimits, type RunSnapshot, type RunSnapshotSeed, type RunToolState, type RunToolSummary, type RunTranscriptEntry, type SpawnMetadata, type SpawnParams, type SpawnResult, type SpawnSelectionInput, type SpawnToolArgs, type SpawnToolResult, StaleOwnerRecordError, type StatusListResult, type StatusResult, type StatusToolArgs, type StatusView, type SubscribeOptions, Supervisor, type SupervisorOptions, THINKING_LEVELS, type ThinkingLevel, type ThinkingOutcome, type WorkflowCompleteParams, type WorkflowCompleteResult, type WorkflowCompleteToolArgs, type WorkflowControllerCreateParams, type WorkflowControllerStatusResult, type WorkflowControllerStatusToolArgs, type WorkflowEventsResult, type WorkflowEventsToolArgs, type WorkflowGateOperation, type WorkflowGateParams, type WorkflowGateResult, type WorkflowGateToolArgs, type WorkflowHeartbeatParams, type WorkflowInspectResult, type WorkflowInspectToolArgs, type WorkflowReadyResult, type WorkflowReadyToolArgs, type WorkflowStatusResult, type WorkflowStatusToolArgs, type WorkflowWaitResult, type WorkflowWaitToolArgs, answerPermissionTool, askTool, attachOwner, brokerReceiveTool, brokerReplyTool, cancelTool, createRunSnapshot, createWorkflowCompleteTool, createWorkflowControllerStatusTool, createWorkflowEventsTool, createWorkflowGateTool, createWorkflowInspectTool, createWorkflowReadyTool, createWorkflowStatusTool, createWorkflowWaitTool, dial, evaluateThinkingPolicy, eventsTool, extractEventText, extractReplyMessage, findAvenorBinary, followUpTool, formatAskFailure, getInstallDir, getVersion, inspectTool, installerBinaryPath, isThinkingLevel, killTool, normalizeAskTimeoutMs, normalizeRunEvent, observeRun, peersTool, reduceRunSnapshot, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, validateThinking, validateThinkingForBackend, validateThinkingForBackendResume, workflowCompleteTool, workflowControllerStatusTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowReadyTool, workflowStatusTool, workflowWaitTool };

package/dist/index.js

@@ -1,10 +1,10 @@
-import { n as getVersion, r as installerBinaryPath, t as getInstallDir } from "./install-path-C7QXqbJO.js";
+import { n as getVersion, r as installerBinaryPath, t as getInstallDir } from "./install-path-DKsk-86J.js";
 import * as net from "node:net";
 import * as readline from "node:readline";
-import { execSync, spawn } from "node:child_process";
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
+import { execSync, spawn } from "node:child_process";
+import * as os from "node:os";
 import * as crypto from "node:crypto";
 import { umpire } from "@umpire/core";
 import { fromJson } from "@umpire/json";
@@ -35,6 +35,67 @@ var RpcError = class extends Error {
 		this.data = data;
 	}
 };
+/**
+* A call or connect that produced no result inside the caller's timeout. It is
+* a transport outcome, not a peer's structured rejection.
+*/
+var CallTimeoutError = class extends Error {
+	code = "ETIMEDOUT";
+	constructor(message = "read response: timeout") {
+		super(message);
+		this.name = "CallTimeoutError";
+	}
+};
+const OWNER_AUTH_VERSION = 1;
+const OWNER_UNAUTHENTICATED_CODE = -32011;
+const UNSUPPORTED_OWNER_AUTH_CODE = -32012;
+const OWNER_AUTH_TIMEOUT_CODE = -32013;
+/** A classified owner-authentication rejection, not generic transport failure. */
+var OwnerAuthError = class extends Error {
+	kind;
+	constructor(kind, options = {}) {
+		const label = kind === "unauthenticated" ? "owner authentication rejected" : kind === "unsupported" ? "unsupported owner authentication" : "owner authentication timed out";
+		super(options.reason ? `${label}: ${options.reason}` : label);
+		this.kind = kind;
+		this.name = "OwnerAuthError";
+	}
+};
+/**
+* Map authenticate_owner failures onto the three client-side classes. A peer
+* that never answered the handshake call timed the capability out, which is an
+* authentication verdict; a dial that never connected rejects before this
+* mapping runs.
+*/
+function classifyOwnerAuthError(err) {
+	if (err instanceof CallTimeoutError) return new OwnerAuthError("timeout");
+	if (err instanceof RpcError) {
+		const reason = ownerAuthReason(err.data);
+		switch (err.code) {
+			case OWNER_UNAUTHENTICATED_CODE: return new OwnerAuthError("unauthenticated", {
+				code: err.code,
+				reason
+			});
+			case UNSUPPORTED_OWNER_AUTH_CODE: return new OwnerAuthError("unsupported", {
+				code: err.code,
+				reason
+			});
+			case OWNER_AUTH_TIMEOUT_CODE: return new OwnerAuthError("timeout", {
+				code: err.code,
+				reason
+			});
+			default: return new OwnerAuthError("unsupported", {
+				code: err.code,
+				reason
+			});
+		}
+	}
+	return err;
+}
+function ownerAuthReason(data) {
+	if (typeof data !== "object" || data === null) return void 0;
+	const reason = data.reason;
+	return typeof reason === "string" ? reason : void 0;
+}
 var Client = class {
 	socket;
 	rl;
@@ -134,7 +195,41 @@ var Client = class {
 		else this.dropped++;
 	}
 	async call(method, params, opts) {
-		if (this.isClosed()) throw new Error("control socket is closed");
+		const MAX_TIMER_MS = 2147483647;
+		const requested = opts?.timeoutMs !== void 0 ? !Number.isFinite(opts.timeoutMs) || opts.timeoutMs > MAX_TIMER_MS - 1e4 ? MAX_TIMER_MS : Math.max(this.callTimeout, opts.timeoutMs + 1e4) : this.callTimeout;
+		const timeout = Number.isFinite(requested) ? Math.min(requested, MAX_TIMER_MS) : MAX_TIMER_MS;
+		return this.sendCall(method, params, timeout);
+	}
+	/**
+	* Send a credential-free identity probe. The control server returns the
+	* startup token only after it has published its own owner record.
+	*/
+	async identity(timeoutMs) {
+		const result = await this.sendCall("identity", void 0, timeoutMs ?? this.callTimeout);
+		return typeof result?.token === "string" ? result.token : "";
+	}
+	/**
+	* Present the owner capability on this connection. The caller must already
+	* have bound the connection to a trusted peer: an owner attach checks the
+	* socket's ownership and identity, and an owned start proves the child with
+	* its attempt token.
+	*/
+	async authenticateOwner(capability, timeoutMs) {
+		let result;
+		try {
+			result = await this.sendCall("authenticate_owner", {
+				version: OWNER_AUTH_VERSION,
+				capability_id: capability.id,
+				secret: capability.secret
+			}, timeoutMs ?? this.callTimeout);
+		} catch (err) {
+			throw classifyOwnerAuthError(err);
+		}
+		const value = result;
+		if (!value || value.authenticated !== true || value.version !== OWNER_AUTH_VERSION || value.capability_id !== capability.id) throw new OwnerAuthError("unsupported", { reason: "unexpected-result" });
+	}
+	sendCall(method, params, timeout) {
+		if (this.isClosed()) return Promise.reject(/* @__PURE__ */ new Error("control socket is closed"));
 		this.startReadLoop();
 		const id = ++this.nextID;
 		const req = {
@@ -144,13 +239,10 @@ var Client = class {
 		};
 		if (params !== void 0) req.params = params;
 		const data = JSON.stringify(req) + "\n";
-		const MAX_TIMER_MS = 2147483647;
-		const requested = opts?.timeoutMs !== void 0 ? !Number.isFinite(opts.timeoutMs) || opts.timeoutMs > MAX_TIMER_MS - 1e4 ? MAX_TIMER_MS : Math.max(this.callTimeout, opts.timeoutMs + 1e4) : this.callTimeout;
-		const timeout = Number.isFinite(requested) ? Math.min(requested, MAX_TIMER_MS) : MAX_TIMER_MS;
 		return new Promise((resolve, reject) => {
 			const timer = setTimeout(() => {
 				this.pending.delete(id);
-				reject(/* @__PURE__ */ new Error("read response: timeout"));
+				reject(new CallTimeoutError());
 			}, timeout);
 			this.pending.set(id, {
 				resolve,
@@ -436,19 +528,305 @@ var Client = class {
 function dial(socketPath, opts) {
 	return new Promise((resolve, reject) => {
 		const socket = net.createConnection({ path: socketPath });
-		const onConnect = () => {
+		let timer;
+		const cleanup = () => {
+			if (timer !== void 0) clearTimeout(timer);
+			socket.removeListener("connect", onConnect);
 			socket.removeListener("error", onError);
+		};
+		const onConnect = () => {
+			cleanup();
 			resolve(new Client(socket, opts));
 		};
 		const onError = (err) => {
-			socket.removeListener("connect", onConnect);
+			cleanup();
 			reject(/* @__PURE__ */ new Error(`dial control socket: ${err.message}`));
 		};
+		if (opts?.connectTimeoutMs !== void 0) timer = setTimeout(() => {
+			cleanup();
+			socket.on("error", () => {});
+			socket.destroy();
+			reject(new CallTimeoutError(`dial control socket: timed out after ${opts.connectTimeoutMs}ms`));
+		}, opts.connectTimeoutMs);
 		socket.on("connect", onConnect);
 		socket.on("error", onError);
 	});
 }
 //#endregion
+//#region src/owner-attach.ts
+const OWNER_RECORD_VERSION = 1;
+const OWNER_RECORD_MAX_BYTES = 64 * 1024;
+const OWNER_ATTACH_TIMEOUT_MS = 5e3;
+const OWNER_PROBE_TIMEOUT_MS = 250;
+/** The owner record published beside a control socket is absent. */
+var OwnerRecordMissingError = class extends Error {
+	socketPath;
+	constructor(socketPath) {
+		super(`owner record missing for control socket ${socketPath}`);
+		this.socketPath = socketPath;
+		this.name = "OwnerRecordMissingError";
+	}
+};
+/**
+* The control socket path has no directory entry, so no listener holds that
+* path.
+*/
+var OwnerSocketAbsentError = class extends Error {
+	socketPath;
+	code = "ENOENT";
+	constructor(socketPath) {
+		super(`control socket ${socketPath} is absent`);
+		this.socketPath = socketPath;
+		this.name = "OwnerSocketAbsentError";
+	}
+};
+/** The record or the socket it names no longer describes the live path. */
+var StaleOwnerRecordError = class extends Error {
+	socketPath;
+	reason;
+	constructor(socketPath, reason) {
+		super(`stale owner record for control socket ${socketPath}: ${reason}`);
+		this.socketPath = socketPath;
+		this.reason = reason;
+		this.name = "StaleOwnerRecordError";
+	}
+};
+/**
+* The control socket path is not bound to this euid, or its directory is
+* writable by another user. No credential byte may be sent to that peer.
+*/
+var ForeignPeerError = class extends Error {
+	socketPath;
+	euid;
+	reason;
+	peerUID;
+	constructor(socketPath, euid, reason, peerUID) {
+		super(`control socket ${socketPath} ${reason}, not uid ${euid}: refusing to send owner credentials`);
+		this.socketPath = socketPath;
+		this.euid = euid;
+		this.reason = reason;
+		this.peerUID = peerUID;
+		this.name = "ForeignPeerError";
+	}
+};
+function ownerRecordPath(socketPath) {
+	return `${socketPath}.owner.json`;
+}
+function lstatBig(path) {
+	return fs.lstatSync(path, { bigint: true });
+}
+function processEUID() {
+	const geteuid = process.geteuid;
+	if (!geteuid) throw new Error("control socket ownership requires a POSIX effective uid");
+	return geteuid();
+}
+function stale(socketPath, reason) {
+	return new StaleOwnerRecordError(socketPath, reason);
+}
+function inspectOwnerRecord(recordPath, socketPath) {
+	let info;
+	try {
+		info = lstatBig(recordPath);
+	} catch (err) {
+		if (err.code === "ENOENT") throw new OwnerRecordMissingError(socketPath);
+		throw stale(socketPath, `stat ${recordPath}: ${errorMessage$1(err)}`);
+	}
+	if (info.isSymbolicLink()) throw stale(socketPath, `${recordPath} is a symlink`);
+	if (!info.isFile()) throw stale(socketPath, `${recordPath} is not a regular file`);
+	if (Number(info.mode & 511n) !== 384) throw stale(socketPath, `${recordPath} has mode ${(Number(info.mode) & 511).toString(8)}, want 600`);
+	if (Number(info.uid) !== processEUID()) throw stale(socketPath, `${recordPath} is not owned by uid ${processEUID()}`);
+	if (info.size > BigInt(OWNER_RECORD_MAX_BYTES)) throw stale(socketPath, `${recordPath} is too large`);
+	return info;
+}
+function rejectSymlinkedParent(recordPath, socketPath) {
+	const parent = path.dirname(recordPath);
+	let info;
+	try {
+		info = lstatBig(parent);
+	} catch (err) {
+		throw stale(socketPath, `stat ${parent}: ${errorMessage$1(err)}`);
+	}
+	if (info.isSymbolicLink()) throw stale(socketPath, `${recordPath} has a symlinked parent ${parent}`);
+}
+function decodeOwnerRecord(body, socketPath) {
+	let parsed;
+	try {
+		parsed = JSON.parse(body);
+	} catch (err) {
+		throw stale(socketPath, `decode ${ownerRecordPath(socketPath)}: ${errorMessage$1(err)}`);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw stale(socketPath, `${ownerRecordPath(socketPath)} is not an object`);
+	const value = parsed;
+	const expected = [
+		"version",
+		"socket",
+		"socket_identity",
+		"capability_id",
+		"secret",
+		"owner_pid"
+	];
+	for (const key of Object.keys(value)) if (!expected.includes(key)) throw stale(socketPath, `${ownerRecordPath(socketPath)} has unknown field ${key}`);
+	const identity = value.socket_identity;
+	if (typeof value.version !== "number" || typeof value.socket !== "string" || typeof value.capability_id !== "string" || typeof value.secret !== "string" || typeof value.owner_pid !== "number" || typeof identity !== "object" || identity === null || typeof identity.dev !== "string" || typeof identity.ino !== "string") throw stale(socketPath, `${ownerRecordPath(socketPath)} is malformed`);
+	if (value.version !== OWNER_RECORD_VERSION) throw stale(socketPath, `${ownerRecordPath(socketPath)} has version ${value.version}`);
+	if (value.socket !== socketPath) throw stale(socketPath, `${ownerRecordPath(socketPath)} names socket ${value.socket}`);
+	return {
+		version: value.version,
+		socket: value.socket,
+		socket_identity: {
+			dev: identity.dev,
+			ino: identity.ino
+		},
+		capability_id: value.capability_id,
+		secret: value.secret,
+		owner_pid: value.owner_pid
+	};
+}
+/** Load and validate the owner record published beside socketPath. */
+function loadOwnerRecord(socketPath) {
+	const recordPath = ownerRecordPath(socketPath);
+	rejectSymlinkedParent(recordPath, socketPath);
+	const inspected = inspectOwnerRecord(recordPath, socketPath);
+	const fd = fs.openSync(recordPath, "r");
+	try {
+		const opened = fs.fstatSync(fd, { bigint: true });
+		if (opened.dev !== inspected.dev || opened.ino !== inspected.ino) throw stale(socketPath, `${recordPath} changed while reading`);
+		return decodeOwnerRecord(fs.readFileSync(fd, "utf8"), socketPath);
+	} finally {
+		fs.closeSync(fd);
+	}
+}
+function socketFileIdentity(socketPath) {
+	let info;
+	try {
+		info = lstatBig(socketPath);
+	} catch (err) {
+		if (err.code === "ENOENT") throw new OwnerSocketAbsentError(socketPath);
+		throw stale(socketPath, `stat ${socketPath}: ${errorMessage$1(err)}`);
+	}
+	if (!info.isSocket()) throw stale(socketPath, `${socketPath} is not a socket`);
+	return info;
+}
+/** Require identity to be the socket the record names. */
+function requireRecordedSocket(socketPath, record, identity) {
+	if (identity.dev !== record.socket_identity.dev || identity.ino !== record.socket_identity.ino) throw stale(socketPath, `${socketPath} does not match the published record`);
+	return identity;
+}
+/**
+* Require the live socket to be the one the record names. Returns the socket's
+* device and inode as decimal strings.
+*/
+function validateOwnerRecordSocket(socketPath, record) {
+	const live = socketFileIdentity(socketPath);
+	return requireRecordedSocket(socketPath, record, {
+		dev: String(live.dev),
+		ino: String(live.ino)
+	});
+}
+/**
+* Bind the socket path to this euid before any credential byte: the socket file
+* must be a socket this euid owns, in a directory this euid or root owns that is
+* not group- or other-writable unless it is sticky.
+*/
+function bindOwnerSocket(socketPath, euid = processEUID()) {
+	const info = socketFileIdentity(socketPath);
+	if (Number(info.uid) !== euid) throw new ForeignPeerError(socketPath, euid, `is owned by uid ${info.uid}`, Number(info.uid));
+	const parent = path.dirname(socketPath);
+	let parentInfo;
+	try {
+		parentInfo = lstatBig(parent);
+	} catch (err) {
+		throw new ForeignPeerError(socketPath, euid, `has an unreadable directory ${parent}: ${errorMessage$1(err)}`);
+	}
+	if (parentInfo.isSymbolicLink()) throw new ForeignPeerError(socketPath, euid, `is reached through the symlink ${parent}`);
+	const parentUID = Number(parentInfo.uid);
+	if (parentUID !== euid && parentUID !== 0) throw new ForeignPeerError(socketPath, euid, `lives in ${parent}, owned by uid ${parentUID}`);
+	const writable = (parentInfo.mode & 18n) !== 0n;
+	const sticky = (parentInfo.mode & 512n) !== 0n;
+	if (writable && !sticky) throw new ForeignPeerError(socketPath, euid, `lives in ${parent}, which is group/other-writable without the sticky bit`);
+	return {
+		dev: String(info.dev),
+		ino: String(info.ino)
+	};
+}
+/** Probe a control socket path without presenting any credential. */
+function probeControlSocket(socketPath, timeoutMs = OWNER_PROBE_TIMEOUT_MS) {
+	return new Promise((resolve) => {
+		const socket = net.createConnection({ path: socketPath });
+		let done = false;
+		const finish = (state) => {
+			if (done) return;
+			done = true;
+			clearTimeout(timer);
+			socket.destroy();
+			resolve(state);
+		};
+		const timer = setTimeout(() => finish("uncertain"), timeoutMs);
+		socket.once("connect", () => finish("live"));
+		socket.once("error", (err) => {
+			finish(err.code === "ECONNREFUSED" || err.code === "ENOENT" ? "dead" : "uncertain");
+		});
+	});
+}
+function connectOwnerSocket(socketPath, timeoutMs) {
+	return new Promise((resolve, reject) => {
+		const socket = net.createConnection({ path: socketPath });
+		const timer = setTimeout(() => {
+			socket.destroy();
+			reject(new CallTimeoutError(`dial ${socketPath}: timed out`));
+		}, timeoutMs);
+		socket.once("connect", () => {
+			clearTimeout(timer);
+			resolve(socket);
+		});
+		socket.once("error", (err) => {
+			clearTimeout(timer);
+			reject(err);
+		});
+	});
+}
+function remainingMs(deadline) {
+	return Math.max(1, deadline - Date.now());
+}
+/**
+* Load the owner record, bind the socket path to this euid and require it to be
+* the record's socket, dial, re-check the socket identity and authenticate. The
+* whole attach is bounded by the timeout.
+*/
+async function attachOwner(socketPath, options = {}) {
+	return attachOwnerWithSeams(socketPath, options);
+}
+/** The attach itself, with the seams the package's tests inject. */
+async function attachOwnerWithSeams(socketPath, options = {}) {
+	const deadline = Date.now() + (options.timeoutMs ?? OWNER_ATTACH_TIMEOUT_MS);
+	const euid = options.euid ?? processEUID();
+	const record = loadOwnerRecord(socketPath);
+	requireRecordedSocket(socketPath, record, bindOwnerSocket(socketPath, euid));
+	options.beforeDial?.();
+	const socket = await connectOwnerSocket(socketPath, remainingMs(deadline));
+	let client;
+	try {
+		validateOwnerRecordSocket(socketPath, record);
+		client = new Client(socket);
+	} catch (err) {
+		socket.destroy();
+		throw err;
+	}
+	try {
+		await client.authenticateOwner({
+			id: record.capability_id,
+			secret: record.secret
+		}, remainingMs(deadline));
+	} catch (err) {
+		client.close();
+		throw err;
+	}
+	return client;
+}
+function errorMessage$1(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+//#endregion
 //#region src/value-fields.ts
 function asRecord(value) {
 	if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
@@ -1331,6 +1709,88 @@ function ensureRunPaths(runId) {
 }
 //#endregion
 //#region src/supervisor.ts
+const STARTUP_TIMEOUT_MS = 1e4;
+const STARTUP_PROBE_CALL_TIMEOUT_MS = 1e3;
+const CHILD_REAP_GRACE_MS = 5e3;
+function isOwnerRejection(err) {
+	return err instanceof OwnerAuthError || err instanceof ForeignPeerError || err instanceof OwnerRecordMissingError || err instanceof StaleOwnerRecordError;
+}
+function classifyAttachError(err) {
+	return isOwnerRejection(err) ? "auth-rejected" : "uncertain";
+}
+function errorMessage(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+function sleep$1(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** Wait until the Go server has removed its socket, bounded by the timeout. */
+async function waitForSocketRemoval(socketPath, timeoutMs = CHILD_REAP_GRACE_MS) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		try {
+			fs.lstatSync(socketPath);
+		} catch {
+			return;
+		}
+		await sleep$1(50);
+	}
+}
+/** Wait for the child to exit on its own, bounded by the timeout. */
+async function waitForChildExit(child, timeoutMs) {
+	if (child.exitCode !== null || child.signalCode !== null) return true;
+	return new Promise((resolve) => {
+		const onExit = () => {
+			clearTimeout(timer);
+			resolve(true);
+		};
+		const timer = setTimeout(() => {
+			child.removeListener("exit", onExit);
+			resolve(false);
+		}, timeoutMs);
+		child.once("exit", onExit);
+	});
+}
+/** Terminate the captured child and wait for it to exit. */
+async function reapChild(child) {
+	if (child.exitCode !== null || child.signalCode !== null) return;
+	const exited = new Promise((resolve) => child.once("exit", () => resolve()));
+	try {
+		child.kill("SIGTERM");
+	} catch {
+		return;
+	}
+	const escalate = setTimeout(() => {
+		try {
+			child.kill("SIGKILL");
+		} catch {}
+	}, CHILD_REAP_GRACE_MS);
+	await exited;
+	clearTimeout(escalate);
+}
+/**
+* Classify an existing control socket path without presenting a credential.
+* A bound unix listener never refuses, so ECONNREFUSED (or an absent path)
+* proves no listener holds it; anything else is uncertain.
+*/
+async function attachExistingSupervisor(socketPath) {
+	const probe = await probeControlSocket(socketPath);
+	if (probe !== "live") return {
+		state: probe,
+		error: probe === "uncertain" ? /* @__PURE__ */ new Error(`control socket probe for ${socketPath} was inconclusive`) : void 0
+	};
+	try {
+		return {
+			client: await attachOwner(socketPath),
+			state: "live"
+		};
+	} catch (err) {
+		return {
+			state: classifyAttachError(err),
+			error: err instanceof Error ? err : new Error(String(err))
+		};
+	}
+}
 function retainLiveIdentity(runInfo, liveStatus) {
 	const value = (candidate) => typeof candidate === "string" && candidate.length > 0 ? candidate : void 0;
 	const liveIdentity = (effectiveKey, directKey) => {
@@ -1458,26 +1918,20 @@ var Supervisor = class Supervisor {
 			await fs.promises.access(socketPath, fs.constants.R_OK | fs.constants.W_OK);
 			socketExists = true;
 		} catch {}
-		if (socketExists) try {
-			const probeClient = await dial(socketPath, { callTimeoutMs: 2e3 });
-			try {
-				await probeClient.status();
-				probeClient.close();
-				const client = await dial(socketPath);
+		if (socketExists) {
+			const existing = await attachExistingSupervisor(socketPath);
+			if (existing.client) {
 				const sup = new Supervisor(binaryPath, socketPath, opts);
-				sup.client = client;
+				sup.client = existing.client;
+				const previous = Supervisor.instance;
+				if (previous && previous.socketPath === socketPath && previous.childProcess) {
+					sup.childProcess = previous.childProcess;
+					previous.childProcess = null;
+				}
 				Supervisor.instance = sup;
 				return sup;
-			} catch {
-				probeClient.close();
-				try {
-					await fs.promises.unlink(socketPath);
-				} catch {}
 			}
-		} catch {
-			try {
-				await fs.promises.unlink(socketPath);
-			} catch {}
+			if (existing.state !== "dead") throw existing.error ?? /* @__PURE__ */ new Error(`control socket ${socketPath} is not attachable`);
 		}
 		const sup = new Supervisor(binaryPath, socketPath, opts);
 		await sup.startProcess();
@@ -1486,18 +1940,48 @@ var Supervisor = class Supervisor {
 	}
 	startProcess() {
 		return new Promise((resolve, reject) => {
-			let resolved = false;
-			this.childProcess = spawn(this.binaryPath, [
+			let settled = false;
+			let ignoreChildExit = false;
+			const attemptToken = crypto.randomBytes(32).toString("hex");
+			const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+			const child = spawn(this.binaryPath, [
 				"stable",
 				"--control-socket",
 				this.socketPath,
 				"--idle-timeout",
 				"30m"
-			], { detached: false });
-			this.childProcess.on("exit", (code, signal) => {
-				if (!resolved) {
-					resolved = true;
-					reject(/* @__PURE__ */ new Error(`avenor exited with code ${code}${signal ? " signal " + signal : ""} during startup`));
+			], {
+				detached: false,
+				env: {
+					...process.env,
+					AVENOR_CONTROL_IDENTITY_TOKEN: attemptToken
+				}
+			});
+			this.childProcess = child;
+			const settleFailure = (err) => {
+				if (settled) return;
+				settled = true;
+				ignoreChildExit = true;
+				reapChild(child).finally(() => {
+					if (this.childProcess === child) this.childProcess = null;
+					reject(err);
+				});
+			};
+			child.on("exit", (code, signal) => {
+				if (ignoreChildExit) return;
+				if (!settled) {
+					const exitError = /* @__PURE__ */ new Error(`avenor exited with code ${code}${signal ? " signal " + signal : ""} during startup`);
+					settled = true;
+					ignoreChildExit = true;
+					(async () => {
+						if (this.childProcess === child) this.childProcess = null;
+						try {
+							this.client = await attachOwner(this.socketPath);
+							resolve();
+						} catch {
+							reject(exitError);
+						}
+					})();
 					return;
 				}
 				this.crashed = true;
@@ -1509,29 +1993,85 @@ var Supervisor = class Supervisor {
 					this.client = null;
 				}
 			});
-			this.childProcess.on("error", (err) => {
-				if (!resolved) {
-					resolved = true;
-					reject(/* @__PURE__ */ new Error(`failed to start avenor: ${err.message}`));
-				}
+			child.on("error", (err) => {
+				settleFailure(/* @__PURE__ */ new Error(`failed to start avenor: ${err.message}`));
 			});
-			const timeout = setTimeout(() => {
-				if (!resolved) {
-					resolved = true;
-					reject(/* @__PURE__ */ new Error("timed out waiting for avenor socket"));
+			const attachOwned = async () => {
+				while (!settled) {
+					if (Date.now() >= deadline) {
+						settleFailure(/* @__PURE__ */ new Error("timed out waiting for avenor socket"));
+						return;
+					}
+					if (child.exitCode !== null || child.signalCode !== null) return;
+					let client;
+					try {
+						client = await dial(this.socketPath, {
+							callTimeoutMs: this.callTimeoutMs,
+							connectTimeoutMs: Math.max(1, deadline - Date.now())
+						});
+					} catch {
+						await sleep$1(100);
+						continue;
+					}
+					if (settled) {
+						client.close();
+						return;
+					}
+					let token;
+					try {
+						token = await client.identity(STARTUP_PROBE_CALL_TIMEOUT_MS);
+					} catch {
+						client.close();
+						if (settled) return;
+						await sleep$1(100);
+						continue;
+					}
+					if (settled) {
+						client.close();
+						return;
+					}
+					if (token !== attemptToken) {
+						client.close();
+						settled = true;
+						ignoreChildExit = true;
+						await reapChild(child);
+						try {
+							this.client = await attachOwner(this.socketPath);
+							resolve();
+						} catch (err) {
+							reject(/* @__PURE__ */ new Error(`supervisor exited during startup: ${errorMessage(err)}`));
+						}
+						return;
+					}
+					try {
+						const record = loadOwnerRecord(this.socketPath);
+						validateOwnerRecordSocket(this.socketPath, record);
+						if (record.owner_pid !== child.pid) throw new StaleOwnerRecordError(this.socketPath, `record names pid ${record.owner_pid}, not this child ${child.pid}`);
+						await client.authenticateOwner({
+							id: record.capability_id,
+							secret: record.secret
+						}, STARTUP_PROBE_CALL_TIMEOUT_MS * 2);
+						this.client = client;
+						settled = true;
+						resolve();
+						return;
+					} catch (err) {
+						client.close();
+						if (settled) return;
+						if (err instanceof OwnerRecordMissingError || err instanceof StaleOwnerRecordError) {
+							await sleep$1(100);
+							continue;
+						}
+						if (err instanceof OwnerSocketAbsentError) {
+							await sleep$1(100);
+							continue;
+						}
+						settleFailure(err instanceof Error ? err : new Error(String(err)));
+						return;
+					}
 				}
-			}, 1e4);
-			const retryDial = async () => {
-				while (!resolved) try {
-					await new Promise((r) => setTimeout(r, 100));
-					this.client = await dial(this.socketPath, { callTimeoutMs: this.callTimeoutMs });
-					clearTimeout(timeout);
-					resolved = true;
-					resolve();
-					return;
-				} catch {}
 			};
-			retryDial();
+			attachOwned();
 		});
 	}
 	get supervisorId() {
@@ -1654,22 +2194,25 @@ var Supervisor = class Supervisor {
 		return runInfo;
 	}
 	async close(options = {}) {
-		if (this.client && !options.skipShutdown) try {
-			await this.client.shutdown("graceful");
-		} catch {}
+		let shutdownSent = false;
+		if (this.client && !options.skipShutdown) {
+			shutdownSent = true;
+			try {
+				await this.client.shutdown("graceful");
+			} catch {}
+		}
 		if (this.childProcess) {
-			this.childProcess.kill();
+			const child = this.childProcess;
 			this.childProcess = null;
-		}
+			if (!shutdownSent || !await waitForChildExit(child, CHILD_REAP_GRACE_MS)) await reapChild(child);
+			await waitForSocketRemoval(this.socketPath);
+		} else if (shutdownSent) await waitForSocketRemoval(this.socketPath);
 		if (this.client) {
 			try {
 				this.client.close();
 			} catch {}
 			this.client = null;
 		}
-		try {
-			await fs.promises.unlink(this.socketPath);
-		} catch {}
 		this.crashed = false;
 		this.crashCode = null;
 		this.runs.clear();
@@ -1705,7 +2248,7 @@ function validateObservedAt(observedAt) {
 }
 //#endregion
 //#region src/tools/get-supervisor-client.ts
-async function getSupervisorClient(supervisorId) {
+async function getSupervisorClient(supervisorId, options = {}) {
 	if (supervisorId === void 0) {
 		const sup = await Supervisor.get();
 		return {
@@ -1724,7 +2267,7 @@ async function getSupervisorClient(supervisorId) {
 		supervisorId: id
 	};
 	return {
-		client: await dial(id),
+		client: options.owner ? await attachOwner(id) : await dial(id),
 		isSingleton: false,
 		sup: null,
 		supervisorId: id
@@ -1870,7 +2413,7 @@ async function executeSpawnTool(args, getSupervisorClient) {
 	if (args.agent) baseParams.agent = args.agent;
 	if (args.thinking !== void 0) baseParams.thinking = args.thinking;
 	if (args.supervisorId) {
-		const { client, isSingleton, sup, supervisorId } = await getSupervisorClient(args.supervisorId);
+		const { client, isSingleton, sup, supervisorId } = await getSupervisorClient(args.supervisorId, { owner: true });
 		if (isSingleton && sup) {
 			const runInfo = await sup.spawn(baseParams, runId);
 			return {
@@ -2814,7 +3357,7 @@ async function answerPermissionTool(args) {
 	let requestId = args.requestId;
 	let supervisorId;
 	let isSingleton = false;
-	if (args.supervisorId) ({client, isSingleton, sup, supervisorId} = await getSupervisorClient(args.supervisorId));
+	if (args.supervisorId) ({client, isSingleton, sup, supervisorId} = await getSupervisorClient(args.supervisorId, { owner: true }));
 	else {
 		sup = await Supervisor.get();
 		client = sup.getClient();
@@ -2881,7 +3424,7 @@ function rejectNotResumableStatus(sentinel) {
 }
 async function executeFollowUpTool(args, getSupervisorClient) {
 	if (args.supervisorId) {
-		const { client, isSingleton, sup, supervisorId } = await getSupervisorClient(args.supervisorId);
+		const { client, isSingleton, sup, supervisorId } = await getSupervisorClient(args.supervisorId, { owner: true });
 		try {
 			validateRunId(args.runId);
 			let runInfo;
@@ -3045,7 +3588,7 @@ async function shutdownTool(args) {
 			await Promise.all(cleanups);
 			await sup.close({ skipShutdown: true });
 		} else {
-			const client = await dial(supervisorId);
+			const client = await attachOwner(supervisorId);
 			try {
 				await client.shutdown(args.force ? "force" : "graceful");
 			} finally {
@@ -3104,11 +3647,26 @@ function extractReplyMessage(result) {
 	}
 	return JSON.stringify(result);
 }
+/**
+* Build the failure message every ask path reports: the broker message id plus
+* whether the ask edge is still pending (withdrawable via avenor_cancel) or
+* already gone.
+*/
+function formatAskFailure(messageId, pending, detail) {
+	return pending ? `ask failed (message_id: ${messageId} — pass to avenor_cancel to withdraw): ${detail}` : `ask failed (message_id: ${messageId} — the pending ask was already withdrawn): ${detail}`;
+}
+/**
+* Reduce a caller-supplied ask timeout to what the broker accepts: a positive
+* finite number of milliseconds, or undefined to keep the broker's own wait.
+*/
+function normalizeAskTimeoutMs(timeoutMs) {
+	return timeoutMs !== void 0 && Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : void 0;
+}
 async function executeAskTool(args, getSupervisorClient) {
-	const { client, isSingleton, sup, supervisorId } = await getSupervisorClient(args.supervisorId);
+	const { client, isSingleton, sup, supervisorId } = await getSupervisorClient(args.supervisorId, { owner: true });
 	try {
 		const target = (isSingleton && sup ? findLocalRunByReference(sup, args.toRunId) : findExternalRun(supervisorId, args.toRunId))?.runtimeId ?? args.toRunId;
-		const timeoutMs = args.timeoutMs !== void 0 && Number.isFinite(args.timeoutMs) && args.timeoutMs > 0 ? args.timeoutMs : void 0;
+		const timeoutMs = normalizeAskTimeoutMs(args.timeoutMs);
 		try {
 			const result = await client.brokerAsk(target, args.message, void 0, timeoutMs);
 			return {
@@ -3119,10 +3677,7 @@ async function executeAskTool(args, getSupervisorClient) {
 			if (error instanceof RpcError && error.data && typeof error.data === "object") {
 				const data = error.data;
 				const messageId = data.message_id;
-				if (typeof messageId === "string" && messageId) {
-					if (data.pending === false) throw new Error(`ask failed (message_id: ${messageId} — the pending ask was already withdrawn): ${error.message}`);
-					throw new Error(`ask failed (message_id: ${messageId} — pass to avenor_cancel to withdraw): ${error.message}`);
-				}
+				if (typeof messageId === "string" && messageId) throw new Error(formatAskFailure(messageId, data.pending !== false, error.message));
 			}
 			throw error;
 		}
@@ -3151,7 +3706,7 @@ const peersTool = createPeersTool(getSupervisorClient);
 //#endregion
 //#region src/tools/cancel.ts
 async function executeCancelTool(args, getSupervisorClient) {
-	const { client, isSingleton } = await getSupervisorClient(args.supervisorId);
+	const { client, isSingleton } = await getSupervisorClient(args.supervisorId, { owner: true });
 	try {
 		await client.brokerCancel(args.messageId);
 		return { cancelled: true };
@@ -3183,7 +3738,7 @@ async function resolveRuntimeId(client, reference) {
 }
 async function executeKillTool(args, getSupervisorClient) {
 	validateRunId(args.runId);
-	const { client, isSingleton, sup, supervisorId } = await getSupervisorClient(args.supervisorId);
+	const { client, isSingleton, sup, supervisorId } = await getSupervisorClient(args.supervisorId, { owner: true });
 	try {
 		const runtimeId = (isSingleton && sup ? findLocalRunByReference(sup, args.runId) : findExternalRun(supervisorId, args.runId))?.runtimeId ?? await resolveRuntimeId(client, args.runId);
 		await client.cancel(runtimeId);
@@ -3217,7 +3772,7 @@ const brokerReceiveTool = createBrokerReceiveTool(getSupervisorClient);
 //#endregion
 //#region src/tools/broker-reply.ts
 async function executeBrokerReply(args, getSupervisorClient) {
-	const { client, isSingleton } = await getSupervisorClient(args.supervisorId);
+	const { client, isSingleton } = await getSupervisorClient(args.supervisorId, { owner: true });
 	try {
 		await client.brokerReply(args.toRunId, args.replyTo, args.message);
 		return { ok: true };
@@ -3342,4 +3897,4 @@ function createWorkflowReadyTool(getSupervisorClient) {
 }
 const workflowReadyTool = createWorkflowReadyTool(getSupervisorClient);
 //#endregion
-export { DEFAULT_RUN_REDUCER_LIMITS, RpcError, RunReducer, Supervisor, THINKING_LEVELS, answerPermissionTool, askTool, brokerReceiveTool, brokerReplyTool, cancelTool, createRunSnapshot, createWorkflowCompleteTool, createWorkflowControllerStatusTool, createWorkflowEventsTool, createWorkflowGateTool, createWorkflowInspectTool, createWorkflowReadyTool, createWorkflowStatusTool, createWorkflowWaitTool, dial, evaluateThinkingPolicy, eventsTool, extractEventText, findAvenorBinary, followUpTool, getInstallDir, getVersion, inspectTool, installerBinaryPath, isThinkingLevel, killTool, normalizeRunEvent, observeRun, peersTool, reduceRunSnapshot, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, validateThinking, validateThinkingForBackend, validateThinkingForBackendResume, workflowCompleteTool, workflowControllerStatusTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowReadyTool, workflowStatusTool, workflowWaitTool };
+export { DEFAULT_RUN_REDUCER_LIMITS, ForeignPeerError, OwnerAuthError, OwnerRecordMissingError, RpcError, RunReducer, StaleOwnerRecordError, Supervisor, THINKING_LEVELS, answerPermissionTool, askTool, attachOwner, brokerReceiveTool, brokerReplyTool, cancelTool, createRunSnapshot, createWorkflowCompleteTool, createWorkflowControllerStatusTool, createWorkflowEventsTool, createWorkflowGateTool, createWorkflowInspectTool, createWorkflowReadyTool, createWorkflowStatusTool, createWorkflowWaitTool, dial, evaluateThinkingPolicy, eventsTool, extractEventText, extractReplyMessage, findAvenorBinary, followUpTool, formatAskFailure, getInstallDir, getVersion, inspectTool, installerBinaryPath, isThinkingLevel, killTool, normalizeAskTimeoutMs, normalizeRunEvent, observeRun, peersTool, reduceRunSnapshot, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, validateThinking, validateThinkingForBackend, validateThinkingForBackendResume, workflowCompleteTool, workflowControllerStatusTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowReadyTool, workflowStatusTool, workflowWaitTool };

package/dist/postinstall.js

@@ -1,6 +1,6 @@
-import { n as getVersion, r as installerBinaryPath, t as getInstallDir } from "./install-path-C7QXqbJO.js";
-import { execSync } from "node:child_process";
+import { n as getVersion, r as installerBinaryPath, t as getInstallDir } from "./install-path-DKsk-86J.js";
 import * as fs from "node:fs";
+import { execSync } from "node:child_process";
 import * as crypto from "node:crypto";
 //#region src/postinstall.ts
 function platformMapping(platform, arch) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougbots/avenor-core",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "type": "module",
   "repository": {
     "type": "git",

package/dist/{install-path-C7QXqbJO.js → install-path-DKsk-86J.js}

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
+import * as os from "node:os";
 //#region src/install-path.ts
 const SEMVER_RE = /^[0-9]+\.[0-9]+\.[0-9]+(-[a-zA-Z0-9.-]+)?$/;
 function getVersion(packageJsonPath) {