@dougbots/avenor-core 0.10.0 → 0.10.1

package/dist/index.d.ts

@@ -1,6 +1,34 @@
 import { n as getVersion, r as installerBinaryPath, t as getInstallDir } from "./install-path-DagQIDKB.js";
 import * as net from "node:net";
 
+//#region src/thinking-policy.d.ts
+/**
+ * Portable thinking-policy contract.
+ *
+ * THINKING_LEVELS is the single TypeScript source for the canonical tuple and
+ * is exported for hosts (MCP, OpenCode, Pi) to derive their enums from. It is
+ * verified against schemas/thinking_policy.umpire.json and the Go tuple by
+ * introspection and conformance tests so all languages agree.
+ *
+ * The backend policy (which canonical values each backend supports, on start
+ * vs. explicit resume) is modelled directly in the Umpire schema's eitherOf
+ * branches with fairWhen rules and conditions (backend, resume). Both Go and
+ * TypeScript derive the policy from the schema, eliminating hand-written
+ * policy tables that could drift apart.
+ */
+declare const THINKING_LEVELS: readonly ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+declare function isThinkingLevel(value: string): boolean;
+/** Accepts an empty value (backend default) or a canonical thinking level. */
+declare function validateThinking(value: unknown): void;
+type ThinkingOutcome = 'ok' | 'unsupportedCapability' | 'unsupportedValue' | 'startOnly';
+/** Evaluates the schema-derived backend policy for a (backend, value, resume) combination. */
+declare function evaluateThinkingPolicy(backend: string, value: string, resume?: boolean): ThinkingOutcome;
+/** Accepts a value iff it is valid under the static backend policy (start). */
+declare function validateThinkingForBackend(backend: string, value: unknown): void;
+/** Accepts a value iff it is valid on an explicit resume for the backend. */
+declare function validateThinkingForBackendResume(backend: string, value: unknown): void;
+//#endregion
 //#region src/client.d.ts
 interface Event {
   event: string;
@@ -24,7 +52,6 @@ interface HistoryResult<TEvent = Event> {
   events: TEvent[];
   latest_seq?: number;
 }
-type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh' | 'max';
 interface SpawnParams {
   agent?: string;
   prompt_file?: string;
@@ -41,6 +68,10 @@ interface SpawnParams {
   server_url?: string;
   session_id?: string;
   sentinel_file?: string;
+  workflow_id?: string;
+  node_id?: string;
+  activation_id?: string;
+  attempt_id?: string;
   on_event?: string;
   auto_approve?: boolean;
   [key: string]: unknown;
@@ -63,6 +94,52 @@ interface SpawnResult {
   effective_backend?: string;
   [key: string]: unknown;
 }
+interface ExecutionIdentity {
+  supervisor_id?: string;
+  workflow_id?: string;
+  node_id?: string;
+  activation_id?: string;
+  attempt_id?: string;
+  run_id?: string;
+  runtime_id?: string;
+  session_id?: string;
+}
+type WorkflowGateOperation = 'satisfy' | 'reject' | 'waive' | 'external_result';
+interface WorkflowCompleteParams {
+  workflow_id: string;
+  node_id: string;
+  activation_id: string;
+  attempt_id: string;
+  lease_id: string;
+  owner_token: string;
+  outcome: string;
+  outputs?: unknown;
+  artifacts?: unknown;
+}
+interface WorkflowGateParams {
+  workflow_id: string;
+  node_id: string;
+  gate_id: string;
+  activation_id: string;
+  operation: WorkflowGateOperation;
+  actor?: string;
+  reason?: string;
+  outcome?: string;
+  subject?: unknown;
+  poll_id?: string;
+  source?: string;
+  result?: string;
+  response_hash?: string;
+  observed_at?: string;
+  evidence_ids?: string[];
+}
+interface WorkflowHeartbeatParams {
+  workflow_id: string;
+  node_id: string;
+  activation_id?: string;
+  lease_id: string;
+  owner_token: string;
+}
 declare class Client {
   private socket;
   private rl;
@@ -95,6 +172,28 @@ declare class Client {
   prompt(runtimeId: string, text: string): Promise<void>;
   interruptAndPrompt(runtimeId: string, text: string, keepQueue?: boolean): Promise<void>;
   cancel(runtimeId?: string): Promise<void>;
+  workflowStatus(workflowId: string): Promise<Record<string, unknown>>;
+  workflowWait(workflowId: string, timeoutMs?: number): Promise<Record<string, unknown>>;
+  workflowInspect(workflowId: string): Promise<Record<string, unknown>>;
+  workflowEvents(workflowId: string, opts?: {
+    afterSeq?: number;
+    limit?: number;
+  }): Promise<Record<string, unknown>>;
+  workflowCommand(workflowId: string, command: unknown): Promise<Record<string, unknown>>;
+  workflowComplete(params: WorkflowCompleteParams): Promise<Record<string, unknown>>;
+  workflowGate(params: WorkflowGateParams): Promise<Record<string, unknown>>;
+  workflowHeartbeat(params: WorkflowHeartbeatParams): Promise<Record<string, unknown>>;
+  brokerSend(fromRunId: string, toRunId: string, message: string, role?: string): Promise<void>;
+  brokerAsk(toRunId: string, message: string, role?: string): Promise<Record<string, unknown>>;
+  brokerPeers(): Promise<Array<Record<string, unknown>>>;
+  brokerCancel(messageId: string): Promise<void>;
+  brokerReceive(): Promise<Array<{
+    from_run_id: string;
+    message_id: string;
+    message: string;
+    role?: string;
+  }>>;
+  brokerReply(toRunId: string, replyTo: string, message: string): Promise<void>;
   isClosed(): boolean;
   close(): void;
 }
@@ -320,6 +419,14 @@ declare class Supervisor {
 //#region src/paths.d.ts
 declare function socketsRoot(): string;
 //#endregion
+//#region src/tools/get-supervisor-client.d.ts
+declare function getSupervisorClient(supervisorId: string): Promise<{
+  client: Client;
+  isSingleton: boolean;
+  sup: Supervisor | null;
+  supervisorId: string;
+}>;
+//#endregion
 //#region src/tools/spawn.d.ts
 interface SpawnToolArgs {
   agent?: string;
@@ -504,4 +611,128 @@ declare function shutdownTool(args: {
   cleaned_up: string[];
 }>;
 //#endregion
-export { type Client, DEFAULT_RUN_REDUCER_LIMITS, type Event, type FollowUpToolArgs, type FollowUpToolResult, type HistoryOptions, type HistoryResult, type InspectResult, type NormalizedRunEvent, type ObserveRunOptions, type ResultResult, type ResultToolArgs, 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 StatusResult, type StatusToolArgs, type StatusView, type SubscribeOptions, Supervisor, type SupervisorOptions, type ThinkingLevel, answerPermissionTool, createRunSnapshot, dial, eventsTool, extractEventText, findAvenorBinary, followUpTool, getInstallDir, getVersion, inspectTool, installerBinaryPath, normalizeRunEvent, observeRun, reduceRunSnapshot, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection };
+//#region src/tools/ask.d.ts
+interface AskToolArgs {
+  toRunId: string;
+  message: string;
+  supervisorId?: string;
+}
+interface AskResult {
+  reply: string;
+  from_run_id: string;
+}
+declare const askTool: (args: AskToolArgs) => Promise<AskResult>;
+//#endregion
+//#region src/tools/peers.d.ts
+interface PeersToolArgs {
+  supervisorId?: string;
+}
+interface PeerEntry {
+  run_id: string;
+  label?: string;
+  status?: string;
+  backend?: string;
+  model?: string;
+  dir?: string;
+}
+interface PeersResult {
+  peers: PeerEntry[];
+}
+declare const peersTool: (args: PeersToolArgs) => Promise<PeersResult>;
+//#endregion
+//#region src/tools/cancel.d.ts
+interface CancelToolArgs {
+  messageId: string;
+  supervisorId?: string;
+}
+interface CancelResult {
+  cancelled: boolean;
+}
+declare const cancelTool: (args: CancelToolArgs) => Promise<CancelResult>;
+//#endregion
+//#region src/tools/broker-receive.d.ts
+interface BrokerReceiveArgs {
+  supervisorId?: string;
+}
+interface InboundAsk {
+  from_run_id: string;
+  message_id: string;
+  message: string;
+  role?: string;
+}
+interface BrokerReceiveResult {
+  asks: InboundAsk[];
+}
+declare const brokerReceiveTool: (args: BrokerReceiveArgs) => Promise<BrokerReceiveResult>;
+//#endregion
+//#region src/tools/broker-reply.d.ts
+interface BrokerReplyArgs {
+  toRunId: string;
+  replyTo: string;
+  message: string;
+  supervisorId?: string;
+}
+interface BrokerReplyResult {
+  ok: true;
+}
+declare const brokerReplyTool: (args: BrokerReplyArgs) => Promise<BrokerReplyResult>;
+//#endregion
+//#region src/tools/workflow-client.d.ts
+type GetSupervisorClient = typeof getSupervisorClient;
+//#endregion
+//#region src/tools/workflow-status.d.ts
+interface WorkflowStatusToolArgs {
+  workflowId: string;
+  supervisorId?: string;
+}
+type WorkflowStatusResult = Record<string, unknown>;
+declare function createWorkflowStatusTool(getSupervisorClient: GetSupervisorClient): (args: WorkflowStatusToolArgs) => Promise<WorkflowStatusResult>;
+declare const workflowStatusTool: (args: WorkflowStatusToolArgs) => Promise<WorkflowStatusResult>;
+//#endregion
+//#region src/tools/workflow-wait.d.ts
+interface WorkflowWaitToolArgs {
+  workflowId: string;
+  timeout?: string;
+  supervisorId?: string;
+}
+type WorkflowWaitResult = Record<string, unknown>;
+declare function createWorkflowWaitTool(getSupervisorClient: GetSupervisorClient): (args: WorkflowWaitToolArgs) => Promise<WorkflowWaitResult>;
+declare const workflowWaitTool: (args: WorkflowWaitToolArgs) => Promise<WorkflowWaitResult>;
+//#endregion
+//#region src/tools/workflow-inspect.d.ts
+interface WorkflowInspectToolArgs {
+  workflowId: string;
+  supervisorId?: string;
+}
+type WorkflowInspectResult = Record<string, unknown>;
+declare function createWorkflowInspectTool(getSupervisorClient: GetSupervisorClient): (args: WorkflowInspectToolArgs) => Promise<WorkflowInspectResult>;
+declare const workflowInspectTool: (args: WorkflowInspectToolArgs) => Promise<WorkflowInspectResult>;
+//#endregion
+//#region src/tools/workflow-events.d.ts
+interface WorkflowEventsToolArgs {
+  workflowId: string;
+  afterSeq?: number;
+  limit?: number;
+  supervisorId?: string;
+}
+type WorkflowEventsResult = Record<string, unknown>;
+declare function createWorkflowEventsTool(getSupervisorClient: GetSupervisorClient): (args: WorkflowEventsToolArgs) => Promise<WorkflowEventsResult>;
+declare const workflowEventsTool: (args: WorkflowEventsToolArgs) => Promise<WorkflowEventsResult>;
+//#endregion
+//#region src/tools/workflow-complete.d.ts
+interface WorkflowCompleteToolArgs extends WorkflowCompleteParams {
+  supervisorId?: string;
+}
+type WorkflowCompleteResult = Record<string, unknown>;
+declare function createWorkflowCompleteTool(getSupervisorClient: GetSupervisorClient): (args: WorkflowCompleteToolArgs) => Promise<WorkflowCompleteResult>;
+declare const workflowCompleteTool: (args: WorkflowCompleteToolArgs) => Promise<WorkflowCompleteResult>;
+//#endregion
+//#region src/tools/workflow-gate.d.ts
+interface WorkflowGateToolArgs extends WorkflowGateParams {
+  supervisorId?: string;
+}
+type WorkflowGateResult = Record<string, unknown>;
+declare function createWorkflowGateTool(getSupervisorClient: GetSupervisorClient): (args: WorkflowGateToolArgs) => Promise<WorkflowGateResult>;
+declare const workflowGateTool: (args: WorkflowGateToolArgs) => Promise<WorkflowGateResult>;
+//#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 NormalizedRunEvent, type ObserveRunOptions, type PeerEntry, type PeersResult, type ResultResult, type ResultToolArgs, 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 StatusResult, type StatusToolArgs, type StatusView, type SubscribeOptions, Supervisor, type SupervisorOptions, THINKING_LEVELS, type ThinkingLevel, type ThinkingOutcome, type WorkflowCompleteParams, type WorkflowCompleteResult, type WorkflowCompleteToolArgs, type WorkflowEventsResult, type WorkflowEventsToolArgs, type WorkflowGateOperation, type WorkflowGateParams, type WorkflowGateResult, type WorkflowGateToolArgs, type WorkflowHeartbeatParams, type WorkflowInspectResult, type WorkflowInspectToolArgs, type WorkflowStatusResult, type WorkflowStatusToolArgs, type WorkflowWaitResult, type WorkflowWaitToolArgs, answerPermissionTool, askTool, brokerReceiveTool, brokerReplyTool, cancelTool, createRunSnapshot, createWorkflowCompleteTool, createWorkflowEventsTool, createWorkflowGateTool, createWorkflowInspectTool, createWorkflowStatusTool, createWorkflowWaitTool, dial, evaluateThinkingPolicy, eventsTool, extractEventText, findAvenorBinary, followUpTool, getInstallDir, getVersion, inspectTool, installerBinaryPath, isThinkingLevel, normalizeRunEvent, observeRun, peersTool, reduceRunSnapshot, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, validateThinking, validateThinkingForBackend, validateThinkingForBackendResume, workflowCompleteTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowStatusTool, workflowWaitTool };

package/dist/index.js

@@ -282,6 +282,107 @@ var Client = class {
 		const params = runtimeId ? { runtime_id: runtimeId } : void 0;
 		await this.call("cancel", params);
 	}
+	async workflowStatus(workflowId) {
+		return this.call("workflow.status", { workflow_id: workflowId });
+	}
+	async workflowWait(workflowId, timeoutMs) {
+		const params = { workflow_id: workflowId };
+		if (timeoutMs !== void 0) params.timeout_ms = timeoutMs;
+		return this.call("workflow.wait", params);
+	}
+	async workflowInspect(workflowId) {
+		return this.call("workflow.inspect", { workflow_id: workflowId });
+	}
+	async workflowEvents(workflowId, opts) {
+		const params = { workflow_id: workflowId };
+		if (opts?.afterSeq !== void 0) params.after_seq = opts.afterSeq;
+		if (opts?.limit !== void 0) params.limit = opts.limit;
+		return this.call("workflow.events", params);
+	}
+	async workflowCommand(workflowId, command) {
+		return this.call("workflow.command", {
+			workflow_id: workflowId,
+			command
+		});
+	}
+	async workflowComplete(params) {
+		const command = {
+			op: "complete",
+			node_id: params.node_id,
+			activation_id: params.activation_id,
+			attempt_id: params.attempt_id,
+			lease_id: params.lease_id,
+			owner_token: params.owner_token,
+			outcome: params.outcome
+		};
+		if (params.outputs !== void 0) command.outputs = params.outputs;
+		if (params.artifacts !== void 0) command.artifacts = params.artifacts;
+		return this.workflowCommand(params.workflow_id, command);
+	}
+	async workflowGate(params) {
+		const command = {
+			op: "gate",
+			node_id: params.node_id,
+			activation_id: params.activation_id,
+			gate_id: params.gate_id,
+			operation: params.operation
+		};
+		const optional = [
+			["actor", params.actor],
+			["reason", params.reason],
+			["outcome", params.outcome],
+			["subject", params.subject],
+			["poll_id", params.poll_id],
+			["source", params.source],
+			["result", params.result],
+			["response_hash", params.response_hash],
+			["observed_at", params.observed_at],
+			["evidence_ids", params.evidence_ids]
+		];
+		for (const [key, value] of optional) if (value !== void 0) command[key] = value;
+		return this.workflowCommand(params.workflow_id, command);
+	}
+	async workflowHeartbeat(params) {
+		const command = {
+			op: "heartbeat",
+			node_id: params.node_id,
+			lease_id: params.lease_id,
+			owner_token: params.owner_token
+		};
+		if (params.activation_id !== void 0) command.activation_id = params.activation_id;
+		return this.workflowCommand(params.workflow_id, command);
+	}
+	async brokerSend(fromRunId, toRunId, message, role) {
+		await this.call("broker_send", {
+			from_run_id: fromRunId,
+			to_run_id: toRunId,
+			message,
+			role: role ?? "agent"
+		});
+	}
+	async brokerAsk(toRunId, message, role) {
+		return await this.call("broker_ask", {
+			to_run_id: toRunId,
+			message,
+			role: role ?? "agent"
+		});
+	}
+	async brokerPeers() {
+		return (await this.call("broker_peers")).sessions ?? [];
+	}
+	async brokerCancel(messageId) {
+		await this.call("broker_cancel", { message_id: messageId });
+	}
+	async brokerReceive() {
+		return await this.call("broker_receive");
+	}
+	async brokerReply(toRunId, replyTo, message) {
+		await this.call("broker_reply", {
+			to_run_id: toRunId,
+			reply_to: replyTo,
+			message
+		});
+	}
 	isClosed() {
 		return this.closed || this.socket.destroyed || this.socket.writableEnded;
 	}
@@ -1534,6 +1635,9 @@ function validateSupervisorSocketPath(supervisorId) {
 	if (parent !== root || !/^avenor-mcp-[^/\\]+\.sock$/.test(basename)) throw new Error(`invalid supervisorId: ${supervisorId}`);
 	return path.join(parent, basename);
 }
+function validateObservedAt(observedAt) {
+	if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(observedAt)) throw new Error("observed_at must be an RFC3339 timestamp");
+}
 //#endregion
 //#region src/tools/get-supervisor-client.ts
 async function getSupervisorClient(supervisorId) {
@@ -1763,6 +1867,232 @@ function createSpawnTool(getSupervisorClient) {
 }
 const spawnTool = createSpawnTool(getSupervisorClient);
 //#endregion
+//#region ../../schemas/thinking_policy.umpire.json
+var thinking_policy_umpire_default = {
+	version: 1,
+	conditions: {
+		"backend": {
+			"type": "string",
+			"description": "Backend identifier (e.g. codex-app-server, pi, claude)."
+		},
+		"resume": {
+			"type": "boolean",
+			"description": "Whether the value is being applied on an explicit resume rather than a fresh start."
+		}
+	},
+	fields: { "thinking": {
+		"isEmpty": "string",
+		"description": "Canonical thinking level, or empty to use the backend default."
+	} },
+	rules: [{
+		"type": "check",
+		"field": "thinking",
+		"check": {
+			"op": "in",
+			"field": "thinking",
+			"value": [
+				"off",
+				"minimal",
+				"low",
+				"medium",
+				"high",
+				"xhigh",
+				"max"
+			]
+		},
+		"reason": "not a canonical thinking value (off, minimal, low, medium, high, xhigh, max)"
+	}, {
+		"type": "eitherOf",
+		"group": "thinkingPolicy",
+		"field": "thinking",
+		"branches": {
+			"empty": [{
+				"type": "fairWhen",
+				"field": "thinking",
+				"when": {
+					"op": "absent",
+					"field": "thinking"
+				},
+				"reason": "thinking is empty (backend default)"
+			}],
+			"fullSupport": [{
+				"type": "fairWhen",
+				"field": "thinking",
+				"when": {
+					"op": "and",
+					"exprs": [{
+						"op": "condIn",
+						"condition": "backend",
+						"values": ["codex-app-server", "pi"]
+					}, {
+						"op": "in",
+						"field": "thinking",
+						"values": [
+							"off",
+							"minimal",
+							"low",
+							"medium",
+							"high",
+							"xhigh",
+							"max"
+						]
+					}]
+				},
+				"reason": "codex-app-server and pi support all canonical thinking values on start and resume"
+			}],
+			"claudeStart": [{
+				"type": "fairWhen",
+				"field": "thinking",
+				"when": {
+					"op": "and",
+					"exprs": [
+						{
+							"op": "condIn",
+							"condition": "backend",
+							"values": ["claude", "claude-channel"]
+						},
+						{
+							"op": "condEq",
+							"condition": "resume",
+							"value": false
+						},
+						{
+							"op": "in",
+							"field": "thinking",
+							"values": [
+								"low",
+								"medium",
+								"high",
+								"xhigh",
+								"max"
+							]
+						}
+					]
+				},
+				"reason": "claude and claude-channel support low through max only on a new session"
+			}]
+		}
+	}]
+};
+//#endregion
+//#region src/thinking-policy.ts
+/**
+* Portable thinking-policy contract.
+*
+* THINKING_LEVELS is the single TypeScript source for the canonical tuple and
+* is exported for hosts (MCP, OpenCode, Pi) to derive their enums from. It is
+* verified against schemas/thinking_policy.umpire.json and the Go tuple by
+* introspection and conformance tests so all languages agree.
+*
+* The backend policy (which canonical values each backend supports, on start
+* vs. explicit resume) is modelled directly in the Umpire schema's eitherOf
+* branches with fairWhen rules and conditions (backend, resume). Both Go and
+* TypeScript derive the policy from the schema, eliminating hand-written
+* policy tables that could drift apart.
+*/
+const THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max"
+];
+function isThinkingLevel(value) {
+	return THINKING_LEVELS.includes(value);
+}
+/** Accepts an empty value (backend default) or a canonical thinking level. */
+function validateThinking(value) {
+	if (value === void 0 || value === "") return;
+	if (typeof value !== "string" || !isThinkingLevel(value)) throw new Error(`invalid thinking value ${JSON.stringify(value)} (allowed: ${THINKING_LEVELS.join(", ")})`);
+}
+const thinkingSchema = thinking_policy_umpire_default;
+thinkingSchema.rules.find((r) => r.check?.op === "in")?.check?.value;
+const policyBranches = (() => {
+	const eitherOf = thinkingSchema.rules.find((r) => r.type === "eitherOf");
+	if (!eitherOf?.branches) return [];
+	const branches = [];
+	for (const branchRules of Object.values(eitherOf.branches)) for (const rule of branchRules) if (rule.type === "fairWhen") branches.push({
+		when: rule.when,
+		reason: rule.reason
+	});
+	return branches;
+})();
+const supportedBackends = (() => {
+	const backends = /* @__PURE__ */ new Set();
+	for (const branch of policyBranches) collectBackends(branch.when, backends);
+	return backends;
+})();
+function collectBackends(expr, backends) {
+	if (expr.op === "condIn" && expr.condition === "backend") {
+		for (const v of expr.values) backends.add(v);
+		return;
+	}
+	if (expr.op === "and" || expr.op === "or") for (const sub of expr.exprs) collectBackends(sub, backends);
+}
+function evalExpr(expr, value, backend, resume) {
+	switch (expr.op) {
+		case "absent": return value === "";
+		case "in": return expr.values.includes(value);
+		case "condIn": return expr.condition === "backend" && expr.values.includes(backend);
+		case "condEq":
+			if (expr.condition === "backend") return backend === expr.value;
+			if (expr.condition === "resume") return resume === expr.value;
+			return false;
+		case "and": return expr.exprs.every((e) => evalExpr(e, value, backend, resume));
+		case "or": return expr.exprs.some((e) => evalExpr(e, value, backend, resume));
+		default: return false;
+	}
+}
+/** Evaluates the schema-derived backend policy for a (backend, value, resume) combination. */
+function evaluateThinkingPolicy(backend, value, resume = false) {
+	if (value === "") return "ok";
+	if (policyBranches.some((b) => evalExpr(b.when, value, backend, resume))) return "ok";
+	if (!supportedBackends.has(backend)) return "unsupportedCapability";
+	if (resume) {
+		if (policyBranches.some((b) => evalExpr(b.when, value, backend, false))) return "startOnly";
+	}
+	return "unsupportedValue";
+}
+/** Returns the canonical values supported by backend on a fresh start. */
+function startValues(backend) {
+	if (!supportedBackends.has(backend)) return [];
+	return THINKING_LEVELS.filter((v) => policyBranches.some((b) => evalExpr(b.when, v, backend, false)));
+}
+/** Returns the canonical values supported by backend on an explicit resume. */
+function resumeValues(backend) {
+	if (!supportedBackends.has(backend)) return [];
+	return THINKING_LEVELS.filter((v) => policyBranches.some((b) => evalExpr(b.when, v, backend, true)));
+}
+/** Accepts a value iff it is valid under the static backend policy (start). */
+function validateThinkingForBackend(backend, value) {
+	validateThinking(value);
+	const v = value === void 0 ? "" : String(value);
+	if (v === "") return;
+	const outcome = evaluateThinkingPolicy(backend, v, false);
+	if (outcome === "ok") return;
+	if (outcome === "unsupportedValue") {
+		const allowed = startValues(backend).join(", ");
+		throw new Error(`backend ${JSON.stringify(backend)} does not support thinking value ${JSON.stringify(v)} (allowed: ${allowed})`);
+	}
+	throw new Error(`backend ${JSON.stringify(backend)} does not support parameter "thinking"`);
+}
+/** Accepts a value iff it is valid on an explicit resume for the backend. */
+function validateThinkingForBackendResume(backend, value) {
+	validateThinking(value);
+	const v = value === void 0 ? "" : String(value);
+	if (v === "") return;
+	const outcome = evaluateThinkingPolicy(backend, v, true);
+	if (outcome === "ok") return;
+	if (outcome === "startOnly") throw new Error(`backend ${JSON.stringify(backend)} supports parameter "thinking" only when starting a session`);
+	if (outcome === "unsupportedValue") {
+		const allowed = resumeValues(backend).join(", ");
+		throw new Error(`backend ${JSON.stringify(backend)} does not support thinking value ${JSON.stringify(v)} (allowed: ${allowed})`);
+	}
+	throw new Error(`backend ${JSON.stringify(backend)} does not support parameter "thinking"`);
+}
+//#endregion
 //#region src/tools/run-resolution.ts
 /** Resolve a local public run ID before considering a label alias. */
 function findLocalRunByReference(sup, reference) {
@@ -2674,4 +3004,184 @@ async function shutdownTool(args) {
 	};
 }
 //#endregion
-export { DEFAULT_RUN_REDUCER_LIMITS, RunReducer, Supervisor, answerPermissionTool, createRunSnapshot, dial, eventsTool, extractEventText, findAvenorBinary, followUpTool, getInstallDir, getVersion, inspectTool, installerBinaryPath, normalizeRunEvent, observeRun, reduceRunSnapshot, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection };
+//#region src/tools/ask.ts
+function extractReplyMessage(result) {
+	if (result.timeout === true) return "(timeout: no reply received)";
+	if (result.cancelled === true) return "(cancelled)";
+	const payload = result.payload;
+	if (payload && typeof payload === "object") {
+		const msg = payload.message;
+		if (typeof msg === "string" && msg) return msg;
+	}
+	return JSON.stringify(result);
+}
+async function executeAskTool(args, getSupervisorClient) {
+	const { client, isSingleton } = await getSupervisorClient(args.supervisorId);
+	try {
+		const result = await client.brokerAsk(args.toRunId, args.message);
+		return {
+			reply: extractReplyMessage(result),
+			from_run_id: result.from_run_id ?? ""
+		};
+	} finally {
+		if (!isSingleton) client.close();
+	}
+}
+function createAskTool(getSupervisorClient) {
+	return (args) => executeAskTool(args, getSupervisorClient);
+}
+const askTool = createAskTool(getSupervisorClient);
+//#endregion
+//#region src/tools/peers.ts
+async function executePeersTool(args, getSupervisorClient) {
+	const { client, isSingleton } = await getSupervisorClient(args.supervisorId);
+	try {
+		return { peers: await client.brokerPeers() };
+	} finally {
+		if (!isSingleton) client.close();
+	}
+}
+function createPeersTool(getSupervisorClient) {
+	return (args) => executePeersTool(args, getSupervisorClient);
+}
+const peersTool = createPeersTool(getSupervisorClient);
+//#endregion
+//#region src/tools/cancel.ts
+async function executeCancelTool(args, getSupervisorClient) {
+	const { client, isSingleton } = await getSupervisorClient(args.supervisorId);
+	try {
+		await client.brokerCancel(args.messageId);
+		return { cancelled: true };
+	} finally {
+		if (!isSingleton) client.close();
+	}
+}
+function createCancelTool(getSupervisorClient) {
+	return (args) => executeCancelTool(args, getSupervisorClient);
+}
+const cancelTool = createCancelTool(getSupervisorClient);
+//#endregion
+//#region src/tools/broker-receive.ts
+async function executeBrokerReceive(args, getSupervisorClient) {
+	const { client, isSingleton } = await getSupervisorClient(args.supervisorId);
+	try {
+		return { asks: await client.brokerReceive() };
+	} finally {
+		if (!isSingleton) client.close();
+	}
+}
+function createBrokerReceiveTool(getSupervisorClient) {
+	return (args) => executeBrokerReceive(args, getSupervisorClient);
+}
+const brokerReceiveTool = createBrokerReceiveTool(getSupervisorClient);
+//#endregion
+//#region src/tools/broker-reply.ts
+async function executeBrokerReply(args, getSupervisorClient) {
+	const { client, isSingleton } = await getSupervisorClient(args.supervisorId);
+	try {
+		await client.brokerReply(args.toRunId, args.replyTo, args.message);
+		return { ok: true };
+	} finally {
+		if (!isSingleton) client.close();
+	}
+}
+function createBrokerReplyTool(getSupervisorClient) {
+	return (args) => executeBrokerReply(args, getSupervisorClient);
+}
+const brokerReplyTool = createBrokerReplyTool(getSupervisorClient);
+//#endregion
+//#region src/tools/workflow-client.ts
+/**
+* Run `work` against the client for the given supervisor, or the singleton when none is
+* supplied. External supervisors are dialed on demand and closed again; the singleton client is
+* reused. Workflow host tools correlate by supervisor ID so runtime ids (e.g. rt_1) that collide
+* across supervisors never route to the wrong host.
+*/
+async function withWorkflowClient(supervisorId, work, getSupervisorClient$1 = getSupervisorClient) {
+	if (supervisorId) {
+		const { client, isSingleton } = await getSupervisorClient$1(supervisorId);
+		try {
+			return await work(client);
+		} finally {
+			if (!isSingleton) client.close();
+		}
+	}
+	return work((await Supervisor.get()).getClient());
+}
+//#endregion
+//#region src/tools/workflow-status.ts
+function createWorkflowStatusTool(getSupervisorClient) {
+	return async (args) => {
+		if (!args.workflowId) throw new Error("workflowId is required");
+		return withWorkflowClient(args.supervisorId, (client) => client.workflowStatus(args.workflowId), getSupervisorClient);
+	};
+}
+const workflowStatusTool = createWorkflowStatusTool(getSupervisorClient);
+//#endregion
+//#region src/tools/workflow-wait.ts
+function createWorkflowWaitTool(getSupervisorClient) {
+	return async (args) => {
+		if (!args.workflowId) throw new Error("workflowId is required");
+		const timeoutMs = args.timeout ? validateTimeout(args.timeout) * 1e3 : 3e4;
+		return withWorkflowClient(args.supervisorId, (client) => client.workflowWait(args.workflowId, timeoutMs), getSupervisorClient);
+	};
+}
+const workflowWaitTool = createWorkflowWaitTool(getSupervisorClient);
+//#endregion
+//#region src/tools/workflow-inspect.ts
+function createWorkflowInspectTool(getSupervisorClient) {
+	return async (args) => {
+		if (!args.workflowId) throw new Error("workflowId is required");
+		return withWorkflowClient(args.supervisorId, (client) => client.workflowInspect(args.workflowId), getSupervisorClient);
+	};
+}
+const workflowInspectTool = createWorkflowInspectTool(getSupervisorClient);
+//#endregion
+//#region src/tools/workflow-events.ts
+function createWorkflowEventsTool(getSupervisorClient) {
+	return async (args) => {
+		if (!args.workflowId) throw new Error("workflowId is required");
+		return withWorkflowClient(args.supervisorId, (client) => client.workflowEvents(args.workflowId, {
+			afterSeq: args.afterSeq,
+			limit: args.limit
+		}), getSupervisorClient);
+	};
+}
+const workflowEventsTool = createWorkflowEventsTool(getSupervisorClient);
+//#endregion
+//#region src/tools/workflow-complete.ts
+function createWorkflowCompleteTool(getSupervisorClient) {
+	return async (args) => {
+		if (!args.workflow_id) throw new Error("workflow_id is required");
+		if (!args.node_id) throw new Error("node_id is required");
+		if (!args.activation_id) throw new Error("activation_id is required");
+		if (!args.attempt_id) throw new Error("attempt_id is required");
+		if (!args.lease_id) throw new Error("lease_id is required");
+		if (!args.owner_token) throw new Error("owner_token is required");
+		if (!args.outcome) throw new Error("outcome is required");
+		return withWorkflowClient(args.supervisorId, (client) => client.workflowComplete(args), getSupervisorClient);
+	};
+}
+const workflowCompleteTool = createWorkflowCompleteTool(getSupervisorClient);
+//#endregion
+//#region src/tools/workflow-gate.ts
+function createWorkflowGateTool(getSupervisorClient) {
+	return async (args) => {
+		if (!args.workflow_id) throw new Error("workflow_id is required");
+		if (!args.node_id) throw new Error("node_id is required");
+		if (!args.gate_id) throw new Error("gate_id is required");
+		if (!args.activation_id) throw new Error("activation_id is required");
+		if (!args.operation) throw new Error("operation is required");
+		if (![
+			"satisfy",
+			"reject",
+			"waive",
+			"external_result"
+		].includes(args.operation)) throw new Error(`unknown gate operation "${args.operation}" (allowed: satisfy, reject, waive, external_result)`);
+		if (args.observed_at) validateObservedAt(args.observed_at);
+		return withWorkflowClient(args.supervisorId, (client) => client.workflowGate(args), getSupervisorClient);
+	};
+}
+const workflowGateTool = createWorkflowGateTool(getSupervisorClient);
+//#endregion
+export { DEFAULT_RUN_REDUCER_LIMITS, RunReducer, Supervisor, THINKING_LEVELS, answerPermissionTool, askTool, brokerReceiveTool, brokerReplyTool, cancelTool, createRunSnapshot, createWorkflowCompleteTool, createWorkflowEventsTool, createWorkflowGateTool, createWorkflowInspectTool, createWorkflowStatusTool, createWorkflowWaitTool, dial, evaluateThinkingPolicy, eventsTool, extractEventText, findAvenorBinary, followUpTool, getInstallDir, getVersion, inspectTool, installerBinaryPath, isThinkingLevel, normalizeRunEvent, observeRun, peersTool, reduceRunSnapshot, resultTool, shutdownTool, socketsRoot, spawnTool, statusTool, validateSpawnSelection, validateThinking, validateThinkingForBackend, validateThinkingForBackendResume, workflowCompleteTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowStatusTool, workflowWaitTool };

package/package.json

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