@dougbots/avenor-mcp 0.15.0 → 0.16.1

package/README.md

@@ -6,7 +6,7 @@ MCP server that makes [avenor](https://github.com/dougbots/avenor) agent runs av
 
 ## When you need this
 
-You have `avenor` installed and you want Claude (or another MCP host) to spawn and manage agent runs — kicking off a Codex or Gemini session, checking its status, answering permission prompts, tailing event logs, and resuming completed runs with a follow-up.
+You have `avenor` installed and you want Claude (or another MCP host) to spawn and manage agent runs — kicking off a Codex or Gemini session, checking its status, answering permission prompts, tailing event logs, and resuming completed runs.
 
 This package is the MCP layer. It depends on `@dougbots/avenor-core` for all the actual wiring (supervisor lifecycle, binary discovery, socket protocol). You don't need to know the internals to use it.
 
@@ -86,9 +86,9 @@ SSE mode restricts incoming requests to `localhost` / `127.0.0.1` / `[::1]` orig
 
 ## Tools
 
-All seven tools register under the `avenor_` prefix to avoid collisions with other MCP servers.
+This surface registers tool names **without** the `avenor_` prefix — `spawn`, `status`, `result`, `answer_permission`, `message`, `peers`, `events`, `kill`, `shutdown`, and the `workflow_*` set. MCP clients namespace their own servers (Claude Code shows them as `mcp__avenor__spawn`, for example), so the prefix would only repeat itself. The `avenor` binary's own MCP server uses the same names.
 
-### `avenor_spawn`
+### `spawn`
 
 Start a new agent run.
 
@@ -125,7 +125,7 @@ Use both `roster_file` and `roster_entry` for roster mode. A roster entry requir
 
 The roster map is strict and currently supports only `backend`, `agent`, and `model` in each entry. `system` and `thinking` are not roster fields. The `thinking` argument remains run-level and is validated against the effective backend chosen by the direct request or roster entry. A resumed session cannot switch to a different backend.
 
-### `avenor_status`
+### `status`
 
 Get the status of one run, or list all runs. Use the compact `lifecycle` view for progress and pending permission checks; `full` remains the compatibility default.
 
@@ -137,7 +137,7 @@ Get the status of one run, or list all runs. Use the compact `lifecycle` view fo
 
 Returns a status object (or array) with `status` being one of `running`, `done`, `failed`, `timeout`, or `killed`. When a run is blocked on a permission request, the response includes a `pending_permission` field with the available options.
 
-### `avenor_result`
+### `result`
 
 Wait for a run to finish and return its complete final output without transcript or event details.
 
@@ -150,33 +150,50 @@ Wait for a run to finish and return its complete final output without transcript
 
 Terminal responses include `ready: true` and `output` when the backend exposed one. A pending permission returns immediately. If the result wait itself expires, the response has `ready: false` and `timed_out: true` without changing the run.
 
-### `avenor_answer_permission`
+### `answer_permission`
 
 Respond to a permission prompt that paused a run.
 
 | Parameter | Required | Description |
 |---|---|---|
 | `run_id` | yes | Run ID or label |
-| `option_id` | yes | The option to select (from the `pending_permission` shown by `avenor_status`) |
+| `option_id` | yes | The option to select (from the `pending_permission` shown by `status`) |
 | `request_id` | no | Specific permission request ID. Auto-detected from the pending request if omitted. |
+| `message` | no | Write-in response text, required only when the selected option declares `requiresMessage: true` |
 | `supervisor_id` | no | Supervisor ID for multi-supervisor setups |
 
 Returns `{ ok: true }` on success. Throws if no permission request is pending for the given run.
 
-### `avenor_follow_up`
+### `message`
 
-Resume a completed run with a new message. The agent picks up from the same session, so it retains context from the original run.
+Send a message to another run, withdraw a pending ask, resume a completed run, or deliver a control reply. Cross-variant argument rules are enforced by the shared router, so an argument outside the chosen action's field set is an error rather than a silent no-op.
 
-| Parameter | Required | Description |
+| `action` | Required fields | What it does |
 |---|---|---|
-| `run_id` | yes | Run ID or label of the *completed* run to resume |
-| `message` | yes | Follow-up prompt |
-| `label` | no | Label for the follow-up run (defaults to `<original-label>-followup`) |
-| `supervisor_id` | no | Supervisor ID for multi-supervisor setups |
+| `tell` | `target`, `message` | Deliver a message without creating an ask edge |
+| `ask` | `target`, `message`, optional `timeout_ms` | Deliver a message and wait for a reply |
+| `reply` | `reply_to`, `message` | Answer an inbound ask. This server receives no inbound delivery, so the result is always `edge-absent` and nothing is sent |
+| `resume` | `target`, `message`, optional `label`, `idempotency_key` | Resume a completed run from its persisted session |
+| `withdraw` | `message_id` | Withdraw a pending ask |
+| `control_reply` | `target`, optional `payload` | Deliver a control reply where the provider supports it |
+
+`target` is a run id, a peer label, or `"self"`. `timeout_ms` must be an integer no greater than the shared ask cap. This tool does not take `supervisor_id`; it is bound to the default supervisor. A router tool error is returned as an MCP error result carrying the contract sentence and a `code`.
+
+Every successful result is the shared contract object in snake_case (`action`, `outcome`, `text`, and `message_id`, `run_id`, `label`, `reply`, `sentinel_file`, `on_event` when the outcome carries them), returned as the structured content, with the contract sentence as the text content, exactly like the Go MCP host.
+
+### `peers`
+
+List the visible agent sessions, rename a run, or read a run's last agent message.
 
-Returns `{ run_id, label }` for the new follow-up run. Throws if the original run has no persisted session.
+| `action` | Fields | What it does |
+|---|---|---|
+| `list` (default) | — | List the visible peers |
+| `rename` | `name`, optional `session_id` | Change a display name, self by default |
+| `last` | `target` | Read the target's last agent message with its stop reason |
+
+`last` is read-only. This surface never publishes a turn of its own, so `last` of the server's own session returns the shared empty result. This tool does not take `supervisor_id`; it is bound to the default supervisor. The structured result is `{peers}`, `{renamed}` or `{last}` in snake_case, the same object the Go MCP host returns.
 
-### `avenor_events`
+### `events`
 
 Fetch the event log for a run. Useful for inspecting what an agent did.
 
@@ -189,7 +206,16 @@ Fetch the event log for a run. Useful for inspecting what an agent did.
 
 Returns an array of event objects (`{ type, ts, ... }`) in chronological order.
 
-### `avenor_shutdown`
+### `kill`
+
+Terminate a run without shutting down the supervisor. Other runs and the supervisor itself keep running.
+
+| Parameter | Required | Description |
+|---|---|---|
+| `run_id` | yes | Run ID or label of the run to terminate |
+| `supervisor_id` | no | Supervisor ID for multi-supervisor setups |
+
+### `shutdown`
 
 Stop the avenor supervisor and clean up sentinel files.
 
@@ -200,15 +226,40 @@ Stop the avenor supervisor and clean up sentinel files.
 
 Returns `{ ok: true, cleaned_up: [...] }`. Use this when you're done with avenor in your session or when the supervisor crashes and needs to be restarted.
 
+### `workflow_cancel`
+
+Cancel a workflow instance. Both `actor` and `reason` are required; the manager rejects a missing actor before it looks at the reason.
+
+| Parameter | Required | Description |
+|---|---|---|
+| `workflow_id` | yes | Workflow ID |
+| `actor` | yes | Who is cancelling |
+| `reason` | yes | Why the workflow is being cancelled |
+| `supervisor_id` | no | Supervisor ID for multi-supervisor setups |
+
+### Workflow tools
+
+The remaining workflow tools read or drive workflow instances. Their argument lists are in [`docs/control-protocol.md`](../../docs/control-protocol.md).
+
+| Tool | Purpose |
+|---|---|
+| `workflow_status` | Lightweight instance status |
+| `workflow_wait` | Wait for a terminal state or a timeout |
+| `workflow_inspect` | Full instance detail |
+| `workflow_events` | The instance's log events |
+| `workflow_complete` | Complete a machine/external handoff activation |
+| `workflow_gate` | Record a gate decision on a parked awaiting_gate activation |
+| `workflow_controller_status` | Controller status, with summary state |
+
 ## Typical workflow
 
-1. **Spawn a run:** `avenor_spawn(agent: "codex", repo_dir: "/path/to/project", prompt: "audit the API routes for auth gaps")`
-2. **Check lifecycle when needed:** `avenor_status(run_id: "<id>", view: "lifecycle")` for progress or pending permissions.
-3. **If permission requested:** run `avenor_answer_permission` with the offered option.
-4. **Retrieve the result:** `avenor_result(run_id: "<id>")` waits and returns the complete final output.
-5. **Inspect history when needed:** `avenor_events(run_id: "<id>")` returns raw recent events.
-6. **Optional follow-up:** `avenor_follow_up(run_id: "<id>", message: "now write tests for that")`
-7. **Clean up:** `avenor_shutdown()` when you're finished.
+1. **Spawn a run:** `spawn(agent: "codex", repo_dir: "/path/to/project", prompt: "audit the API routes for auth gaps")`
+2. **Check lifecycle when needed:** `status(run_id: "<id>", view: "lifecycle")` for progress or pending permissions.
+3. **If permission requested:** run `answer_permission` with the offered option.
+4. **Retrieve the result:** `result(run_id: "<id>")` waits and returns the complete final output.
+5. **Inspect history when needed:** `events(run_id: "<id>")` returns raw recent events.
+6. **Iterate:** `message(action: "resume", target: "<id>", message: "now write tests for that")`
+7. **Clean up:** `shutdown()` when you're finished.
 
 ## Package structure
 

package/dist/index.js

@@ -4,7 +4,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { Hono } from "hono";
 import { z } from "zod";
-import { THINKING_LEVELS, answerPermissionTool, eventsTool, followUpTool, killTool, resultTool, shutdownTool, spawnTool, statusTool, validateSpawnSelection, workflowCompleteTool, workflowControllerStatusTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowStatusTool, workflowWaitTool } from "@dougbots/avenor-core";
+import { THINKING_LEVELS, ToolError, answerPermissionTool, createHostMessageProvider, eventsTool, getSupervisorClient, isGenerationMismatchError, killTool, messageTool, peersDetails, peersTool, renderPeerList, resultOutput, resultTool, shutdownTool, spawnTool, statusTool, validateSpawnSelection, workflowCancelTool, workflowCompleteTool, workflowControllerStatusTool, workflowEventsTool, workflowGateTool, workflowInspectTool, workflowStatusTool, workflowWaitTool } from "@dougbots/avenor-core";
 //#region src/spawn-schema.ts
 const spawnInputShape = {
 	agent: z.string().optional().describe("Optional agent name; omission uses the supplied model or runtime defaults"),
@@ -22,6 +22,137 @@ const spawnInputShape = {
 	supervisor_id: z.string().optional().describe("Supervisor ID for multi-supervisor mode")
 };
 //#endregion
+//#region src/router-schema.ts
+/**
+* The tool input schema for a tool whose admission belongs to the shared
+* router.
+*
+* The MCP SDK parses every `tools/call` argument object against the schema the
+* tool publishes before the handler runs, and answers a failure in its own
+* error shape. The published shape is not what the router admits either: the
+* router refuses a wrong type, a missing field and an unknown action with the
+* contract's own sentence. This schema therefore publishes the supplied JSON
+* Schema (through zod's `toJSONSchema` override) while admitting every argument
+* object unchanged, including the `undefined` a call that omits `arguments`
+* produces and an explicit `null`, so the router answers first wherever the
+* argument object reaches this schema. A `null` delivered over the protocol does
+* not: the SDK's own `CallToolRequestSchema` types `arguments` as a record and
+* refuses it there, one layer above this coercion.
+*
+* Both behaviours ride on zod internals, so construction checks they are there:
+* a zod release that drops them would otherwise leave this surface publishing
+* the loose object and refusing the router's own sentences per call.
+*/
+function routerAdmittedSchema(published) {
+	const schema = z.looseObject({});
+	const internals = schema._zod;
+	if (!internals || typeof internals.run !== "function") throw new Error("routerAdmittedSchema needs the zod internals `_zod.run` and `_zod.toJSONSchema`; this zod version does not expose them, so the router admission pass-through and the published input schema would stop working");
+	const run = internals.run.bind(internals);
+	internals.run = (payload, ctx) => run(payload.value == null ? {
+		...payload,
+		value: {}
+	} : payload, ctx);
+	internals.toJSONSchema = () => structuredClone(published);
+	return schema;
+}
+//#endregion
+//#region ../../schemas/message.input.flat.json
+var message_input_flat_default = {
+	$id: "https://avenor.dev/schemas/message.input.flat.json",
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	additionalProperties: false,
+	description: "Flat input schema for the avenor_message tool, compiled from schemas/message.input.json's per-action union so an MCP client publishes one object whose property types survive: an integer stays an integer and an object stays an object. Every action's properties appear here, so a field belonging to another action is not a schema error. Per-action admission (required fields, unknown properties, types and limits) belongs to the router, which answers a mismatch at once with the contract's typed invalid_request and its repair text. Generated by internal/messaging/cmd/genschema; do not edit.",
+	properties: {
+		"action": {
+			"description": "Action to perform: tell — Deliver a message without creating a reply edge; ask — Deliver a message and wait for one reply; reply — Answer an ask this surface received; resume — Continue a finished run in a new run; withdraw — Retract an ask this caller sent; control_reply — Answer a claude-channel control request; registered only on the claude-channel backend.",
+			"enum": [
+				"tell",
+				"ask",
+				"reply",
+				"resume",
+				"withdraw",
+				"control_reply"
+			],
+			"type": "string"
+		},
+		"idempotency_key": {
+			"description": "Caller-chosen key that makes a repeated resume replay the first result.",
+			"type": "string"
+		},
+		"label": {
+			"description": "Display name for the new run; defaults to the prior run's label.",
+			"type": "string"
+		},
+		"message": {
+			"description": "Text the recipient reads. Question the recipient answers. Reply text the asker reads. Instruction the resumed run receives.",
+			"type": "string"
+		},
+		"message_id": {
+			"description": "Message id of the ask to withdraw.",
+			"type": "string"
+		},
+		"payload": {
+			"description": "JSON payload the control channel receives; absent sends an empty object.",
+			"type": "object"
+		},
+		"reply_to": {
+			"description": "Message id of the inbound ask, as an opaque handle.",
+			"type": "string"
+		},
+		"target": {
+			"description": "Recipient: a reserved self alias, a broker/runtime id, a host-surface public run id, or a peer label. Prior run: a reserved self alias, a broker/runtime id, a host-surface public run id, or a peer label. Opaque claude-channel control message id, passed through unchanged.",
+			"type": "string"
+		},
+		"timeout_ms": {
+			"description": "Bounded wait in whole milliseconds, at least zero and at most the shared wait cap (600000); absent or zero uses the shared wait cap.",
+			"maximum": 6e5,
+			"minimum": 0,
+			"type": "integer"
+		}
+	},
+	required: ["action"],
+	title: "avenor_message flat input",
+	type: "object"
+};
+//#endregion
+//#region ../../schemas/peers.input.flat.json
+var peers_input_flat_default = {
+	$id: "https://avenor.dev/schemas/peers.input.flat.json",
+	$schema: "https://json-schema.org/draft/2020-12/schema",
+	additionalProperties: false,
+	description: "Flat input schema for the avenor_peers tool, compiled from schemas/peers.input.json's per-action union so an MCP client publishes one object whose property types survive. Every action's properties appear here, so a field belonging to another action is not a schema error. Per-action admission belongs to the router, which answers a mismatch at once with the contract's typed error and its repair text. Generated by internal/messaging/cmd/genschema; do not edit.",
+	properties: {
+		"action": {
+			"default": "list",
+			"description": "Action to perform: list — List the sessions visible to the caller (the default); rename — Rename a run's display name; last — Read a peer's last agent message, the final text of its latest turn.",
+			"enum": [
+				"list",
+				"rename",
+				"last"
+			],
+			"type": "string"
+		},
+		"name": {
+			"description": "New display name, 1-64 characters with no control or formatting characters (including bidi overrides and zero-width characters, so a label cannot be rendered to look like another peer's). Length is counted in Unicode code points, as JSON Schema maxLength counts it; the rename authority applies the same rune rule as a second check.",
+			"maxLength": 64,
+			"minLength": 1,
+			"pattern": "^[^\\p{Cc}\\p{Cf}\\p{Zl}\\p{Zp}]+$",
+			"type": "string"
+		},
+		"session_id": {
+			"description": "Run to rename. Omitted renames the caller's own run for a broker caller and the supervisor session for the owner.",
+			"type": "string"
+		},
+		"target": {
+			"description": "Peer: a reserved self alias, a broker/runtime id, a host-surface public run id, or a peer label.",
+			"type": "string"
+		}
+	},
+	required: [],
+	title: "avenor_peers flat input",
+	type: "object"
+};
+//#endregion
 //#region src/mcp.ts
 const LOCALHOST_ORIGINS = new Set([
 	"localhost",
@@ -62,7 +193,7 @@ const server = new McpServer({
 	name: "avenor",
 	version: "0.1.0"
 });
-server.registerTool("avenor_spawn", {
+server.registerTool("spawn", {
 	description: "Spawn a new agent run with an optional canonical thinking level; unsupported backends reject explicit values",
 	inputSchema: spawnInputShape
 }, async ({ repo_dir, agent, prompt, prompt_file, label, timeout, model, thinking, backend, roster_file, roster_entry, server_url, supervisor_id }) => {
@@ -89,7 +220,7 @@ server.registerTool("avenor_spawn", {
 		supervisorId: supervisor_id
 	});
 });
-server.registerTool("avenor_status", {
+server.registerTool("status", {
 	description: "Get lifecycle status of one or all runs. Use lifecycle view for compact polling. Without run_id, returns an object with runs (array of status objects) and count.",
 	inputSchema: {
 		run_id: z.string().optional().describe("Run ID or label to query"),
@@ -103,7 +234,7 @@ server.registerTool("avenor_status", {
 		view
 	});
 });
-server.registerTool("avenor_result", {
+server.registerTool("result", {
 	description: "Retrieve the complete final output of a run without transcript or event details. Waits by default; set wait=false to retrieve an already-completed run without blocking",
 	inputSchema: {
 		run_id: z.string().describe("Run ID or label"),
@@ -119,7 +250,7 @@ server.registerTool("avenor_result", {
 		timeout
 	});
 });
-server.registerTool("avenor_answer_permission", {
+server.registerTool("answer_permission", {
 	description: "Answer a pending permission request",
 	inputSchema: {
 		run_id: z.string().describe("Run ID or label"),
@@ -137,23 +268,126 @@ server.registerTool("avenor_answer_permission", {
 		message
 	});
 });
-server.registerTool("avenor_follow_up", {
-	description: "Resume a completed run with a follow-up message",
+/**
+* The message and peers tools publish the flat schema compiled from the
+* shared contract's per-action union, but admit through the shared router:
+* admission belongs to the router on every surface, so the SDK's own validation
+* must not answer first. The union itself is not published here because a
+* `oneOf` input schema loses an integer's and an object's type in at least one
+* real MCP client.
+*/
+const messageInputSchema = routerAdmittedSchema(message_input_flat_default);
+const peersInputSchema = routerAdmittedSchema(peers_input_flat_default);
+/**
+* The bound host provider: one supervisor and one generation at a time. It is
+* rebuilt when the supervisor's client changes (a shutdown followed by a fresh
+* singleton), so a revoked generation is never reused. This surface never
+* publishes a turn of its own, so the provider has no `recordLastTurn` caller.
+*/
+let hostProvider;
+async function messageProvider() {
+	const { client, supervisorId } = await getSupervisorClient(void 0, { owner: true });
+	if (hostProvider && hostProvider.client === client) return hostProvider.provider;
+	const provider = createHostMessageProvider({
+		surface: "mcp-ts",
+		supervisorId,
+		generation: (await client.messagePreflight()).generation,
+		client
+	});
+	hostProvider = {
+		client,
+		provider
+	};
+	return provider;
+}
+/**
+* Run one call through the bound provider, retrying once after a re-preflight
+* when the supervisor says the cached generation is stale. This is the policy
+* the Go host already applies inside a single call, so a restarted supervisor
+* does not fail the call that discovers it.
+*/
+async function withProvider(run) {
+	try {
+		return await run(await messageProvider());
+	} catch (error) {
+		if (!isGenerationMismatchError(error)) throw error;
+		hostProvider = void 0;
+		return run(await messageProvider());
+	}
+}
+/** A router tool error is a failure result on every surface; anything else is the transport's to report. */
+function toolFailure(error) {
+	if (!(error instanceof ToolError)) throw error;
+	const text = error.message;
+	return {
+		content: [{
+			type: "text",
+			text
+		}],
+		structuredContent: {
+			code: error.code,
+			text
+		},
+		isError: true
+	};
+}
+async function messageCall(args) {
+	try {
+		const result = await withProvider((provider) => messageTool(args, provider));
+		const output = resultOutput(result);
+		return {
+			content: [{
+				type: "text",
+				text: result.text ?? ""
+			}],
+			structuredContent: output
+		};
+	} catch (error) {
+		return toolFailure(error);
+	}
+}
+function peersText(result) {
+	return result.action === "list" ? [result.text, renderPeerList(result.peers)].filter((part) => part !== "").join("\n\n") : result.text;
+}
+async function peersCall(args) {
+	try {
+		const result = await withProvider((provider) => peersTool(args, provider));
+		return {
+			content: [{
+				type: "text",
+				text: peersText(result)
+			}],
+			structuredContent: peersDetails(result)
+		};
+	} catch (error) {
+		return toolFailure(error);
+	}
+}
+server.registerTool("message", {
+	description: "Send a message to another agent run, withdraw a pending ask, resume a completed run, or deliver a control reply. Every action is explicit and the result states whether a failed ask can still be withdrawn. `reply` always reports edge-absent here: this server receives no inbound asks, so nothing is sent. This tool is bound to the default supervisor and takes no `supervisor_id`.",
+	inputSchema: messageInputSchema
+}, async (args) => messageCall(args));
+server.registerTool("peers", {
+	description: "List the visible agent sessions, rename a run, or read a run's last agent message. `last` returns the target's final text with its stop reason, or an empty result when the target has no completed turn yet. This tool is bound to the default supervisor and takes no `supervisor_id`.",
+	inputSchema: peersInputSchema
+}, async (args) => peersCall(args));
+server.registerTool("workflow_cancel", {
+	description: "Cancel a workflow instance. The actor and reason are required.",
 	inputSchema: {
-		run_id: z.string().describe("Run ID or label to follow up on"),
-		message: z.string().describe("Follow-up message"),
-		label: z.string().optional().describe("Label for the follow-up run"),
+		workflow_id: z.string().describe("Workflow ID"),
+		actor: z.string().describe("Who is cancelling"),
+		reason: z.string().describe("Why the workflow is being cancelled"),
 		supervisor_id: z.string().optional().describe("Supervisor ID for multi-supervisor mode")
 	}
-}, async ({ run_id, message, label, supervisor_id }) => {
-	return followUpTool({
-		runId: run_id,
-		message,
-		label,
+}, async ({ workflow_id, actor, reason, supervisor_id }) => {
+	return workflowCancelTool({
+		workflow_id,
+		actor,
+		reason,
 		supervisorId: supervisor_id
 	});
 });
-server.registerTool("avenor_events", {
+server.registerTool("events", {
 	description: "Get event log for a run",
 	inputSchema: {
 		run_id: z.string().describe("Run ID or label"),
@@ -169,7 +403,7 @@ server.registerTool("avenor_events", {
 		supervisorId: supervisor_id
 	});
 });
-server.registerTool("avenor_kill", {
+server.registerTool("kill", {
 	description: "Terminate a run without shutting down the supervisor. Other runs and the supervisor itself keep running.",
 	inputSchema: {
 		run_id: z.string().min(1).describe("Run ID or label"),
@@ -181,7 +415,7 @@ server.registerTool("avenor_kill", {
 		supervisorId: supervisor_id
 	});
 });
-server.registerTool("avenor_shutdown", {
+server.registerTool("shutdown", {
 	description: "Shut down the supervisor",
 	inputSchema: {
 		supervisor_id: z.string().optional().describe("Supervisor ID for multi-supervisor mode"),
@@ -193,7 +427,7 @@ server.registerTool("avenor_shutdown", {
 		force
 	});
 });
-server.registerTool("avenor_workflow_status", {
+server.registerTool("workflow_status", {
 	description: "Get lightweight status for a workflow instance",
 	inputSchema: {
 		workflow_id: z.string().describe("Workflow ID"),
@@ -205,7 +439,7 @@ server.registerTool("avenor_workflow_status", {
 		supervisorId: supervisor_id
 	});
 });
-server.registerTool("avenor_workflow_wait", {
+server.registerTool("workflow_wait", {
 	description: "Wait for a workflow to reach a terminal state or until timeout",
 	inputSchema: {
 		workflow_id: z.string().describe("Workflow ID"),
@@ -219,7 +453,7 @@ server.registerTool("avenor_workflow_wait", {
 		supervisorId: supervisor_id
 	});
 });
-server.registerTool("avenor_workflow_inspect", {
+server.registerTool("workflow_inspect", {
 	description: "Return the full instance detail for a workflow",
 	inputSchema: {
 		workflow_id: z.string().describe("Workflow ID"),
@@ -231,7 +465,7 @@ server.registerTool("avenor_workflow_inspect", {
 		supervisorId: supervisor_id
 	});
 });
-server.registerTool("avenor_workflow_events", {
+server.registerTool("workflow_events", {
 	description: "Read log events from a workflow instance's event log",
 	inputSchema: {
 		workflow_id: z.string().describe("Workflow ID"),
@@ -247,7 +481,7 @@ server.registerTool("avenor_workflow_events", {
 		supervisorId: supervisor_id
 	});
 });
-server.registerTool("avenor_workflow_complete", {
+server.registerTool("workflow_complete", {
 	description: "Atomically complete a machine/external handoff activation",
 	inputSchema: {
 		workflow_id: z.string().describe("Workflow ID"),
@@ -268,7 +502,7 @@ server.registerTool("avenor_workflow_complete", {
 		supervisorId: supervisor_id
 	});
 });
-server.registerTool("avenor_workflow_gate", {
+server.registerTool("workflow_gate", {
 	description: "Record a gate decision on a parked awaiting_gate activation",
 	inputSchema: {
 		workflow_id: z.string().describe("Workflow ID"),
@@ -300,7 +534,7 @@ server.registerTool("avenor_workflow_gate", {
 		supervisorId: supervisor_id
 	});
 });
-server.registerTool("avenor_workflow_controller_status", {
+server.registerTool("workflow_controller_status", {
 	description: "Show workflow controller status. With controller_id, returns that controller's full status; without it, lists all controllers with summary state. Create, enable, and disable are CLI-only (avenor workflow controller ...).",
 	inputSchema: {
 		controller_id: z.string().optional().describe("Controller ID; omit to list all controllers"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dougbots/avenor-mcp",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "type": "module",
   "repository": {
     "type": "git",
@@ -30,7 +30,7 @@
     "dev": "tsdown --watch"
   },
   "dependencies": {
-    "@dougbots/avenor-core": "^0.15.0",
+    "@dougbots/avenor-core": "^0.16.1",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "hono": "^4.12.19",
     "zod": "^4.4.3"