@kynver-app/mcp-agent-os 0.3.69 → 0.3.71

package/dist/tools/taskflow.js

@@ -1,124 +0,0 @@
-/**
- * TaskFlow MCP tools — Kynver-native managed-flow lifecycle parity for Hermes/harness.
- *
- * agent_os_taskflow_list → GET …/taskflow
- * agent_os_taskflow_get → GET …/taskflow?flowId=
- * agent_os_taskflow_mutate → POST …/taskflow (create / resume / wait / finish / fail / request_cancel)
- */
-import { z } from "zod";
-import { get, post } from "../lib/kynver-client.js";
-async function resolveAgentOsId(slug) {
-    const row = await get(`/agent-os/${encodeURIComponent(slug)}`);
-    const id = typeof row.id === "string" ? row.id.trim() : "";
-    if (!id) {
-        throw new Error(`AgentOS slug "${slug}" did not resolve to an id.`);
-    }
-    return id;
-}
-const idSchema = {
-    agentOsId: z.string().uuid().optional().describe("AgentOS workspace id"),
-    slug: z.string().optional().describe("AgentOS slug (resolved to id when agentOsId omitted)"),
-};
-export function registerTaskflowTools({ register, resolveToolSlug, jsonResult, }) {
-    register("agent_os_taskflow_list", [
-        "List Kynver-native managed TaskFlows projected to the openclaw adapter wire shape.",
-        "Defaults: scope=active, detail=compact (use scope=all|recent and detail=full for audits).",
-        "Supports limit/offset flow pagination; taskWindow.truncated signals the shared 1000-row board window was saturated.",
-        "Safe for verify_live — read-only.",
-    ].join(" "), {
-        ...idSchema,
-        scope: z
-            .enum(["active", "recent", "all"])
-            .optional()
-            .describe("Flow inventory scope (default active — non-terminal only)"),
-        detail: z
-            .enum(["compact", "full"])
-            .optional()
-            .describe("Projection detail (default compact — pruned terminal state)"),
-        limit: z
-            .number()
-            .int()
-            .positive()
-            .max(200)
-            .optional()
-            .describe("Max flows per page (default 50, max 200)"),
-        offset: z
-            .number()
-            .int()
-            .nonnegative()
-            .optional()
-            .describe("Flow page offset (default 0)"),
-    }, async (args) => {
-        const agentOsId = args.agentOsId?.trim() ||
-            (await resolveAgentOsId(args.slug ?? (await resolveToolSlug())));
-        const params = new URLSearchParams();
-        if (args.scope)
-            params.set("scope", args.scope);
-        if (args.detail)
-            params.set("detail", args.detail);
-        if (args.limit !== undefined)
-            params.set("limit", String(args.limit));
-        if (args.offset !== undefined)
-            params.set("offset", String(args.offset));
-        const qs = params.toString();
-        const data = await get(`/agent-os/by-id/${encodeURIComponent(agentOsId)}/taskflow${qs ? `?${qs}` : ""}`);
-        return jsonResult(data);
-    });
-    register("agent_os_taskflow_get", [
-        "Fetch one managed TaskFlow by flowId using the Hermes/native adapter wire shape.",
-        "Safe for verify_live — read-only.",
-    ].join(" "), {
-        ...idSchema,
-        flowId: z.string().describe("TaskFlow flowId"),
-    }, async (args) => {
-        const agentOsId = args.agentOsId?.trim() ||
-            (await resolveAgentOsId(args.slug ?? (await resolveToolSlug())));
-        const data = await get(`/agent-os/by-id/${encodeURIComponent(agentOsId)}/taskflow?flowId=${encodeURIComponent(args.flowId)}`);
-        return jsonResult(data);
-    });
-    register("agent_os_taskflow_mutate", [
-        "Create or mutate a Kynver-native managed TaskFlow (create, resume, wait, finish, fail, request_cancel).",
-        "Lifecycle actions require expectedRevision for optimistic concurrency — matches openclaw TF2 guards.",
-    ].join(" "), {
-        ...idSchema,
-        action: z
-            .enum(["create", "resume", "wait", "finish", "fail", "request_cancel"])
-            .describe("Lifecycle action"),
-        flowId: z.string().describe("TaskFlow flowId"),
-        templateId: z.string().optional().describe("Required for create"),
-        goal: z.string().optional().describe("Required for create"),
-        expectedRevision: z.number().int().nonnegative().optional(),
-        currentStep: z.string().optional(),
-        stateJson: z.record(z.unknown()).optional().describe("Managed-flow state blob (includes __taskflow cursor)"),
-        waitJson: z.record(z.unknown()).optional().describe("Wait payload when action=wait"),
-        blockedTaskId: z.string().optional(),
-        blockedSummary: z.string().optional(),
-        callbackKey: z
-            .object({
-            flowId: z.string(),
-            revision: z.number().int().nonnegative(),
-            idempotencyKey: z.string(),
-            stepGeneration: z.number().int().nonnegative().optional(),
-            childAttempt: z.number().int().nonnegative().optional(),
-        })
-            .optional()
-            .describe("TF2 callback guard key — stale/terminal/duplicate mint rejection"),
-    }, async (args) => {
-        const agentOsId = args.agentOsId?.trim() ||
-            (await resolveAgentOsId(args.slug ?? (await resolveToolSlug())));
-        const data = await post(`/agent-os/by-id/${encodeURIComponent(agentOsId)}/taskflow`, {
-            action: args.action,
-            flowId: args.flowId,
-            templateId: args.templateId,
-            goal: args.goal,
-            expectedRevision: args.expectedRevision,
-            currentStep: args.currentStep,
-            stateJson: args.stateJson,
-            waitJson: args.waitJson,
-            blockedTaskId: args.blockedTaskId,
-            blockedSummary: args.blockedSummary,
-            callbackKey: args.callbackKey,
-        });
-        return jsonResult(data);
-    });
-}

package/dist/tools/tasks.d.ts

@@ -1,26 +0,0 @@
-/**
- * AgentTask board MCP tools — batch 1 (Ghost-facing CRUD) and batch 1.5
- * (steering / lease). Each tool proxies to `/api/agent-os/{slug}/tasks/*`.
- *
- * Kept in its own module so server.ts does not grow monolithic. server.ts
- * calls `registerTaskTools` with the helpers it already has in scope.
- */
-type ToolResult = {
-    content: {
-        type: "text";
-        text: string;
-    }[];
-    structuredContent?: unknown;
-};
-export interface TaskToolDeps {
-    /** server.ts's thin wrapper over `server.registerTool`. */
-    register: (name: string, description: string, inputSchema: Record<string, unknown>, cb: (args: any) => any) => void;
-    /** Resolve the effective AgentOS slug (explicit arg → env → discovered primary). */
-    resolveToolSlug: (explicitSlug?: string) => Promise<string>;
-    /** Wrap a value as an MCP text + structuredContent result. */
-    jsonResult: (data: unknown) => ToolResult;
-    /** Drop `undefined` entries from an object. */
-    compact: (source: Record<string, unknown>) => Record<string, unknown>;
-}
-export declare function registerTaskTools({ register, resolveToolSlug, jsonResult, compact, }: TaskToolDeps): void;
-export {};

package/dist/tools/tasks.js

@@ -1,251 +0,0 @@
-/**
- * AgentTask board MCP tools — batch 1 (Ghost-facing CRUD) and batch 1.5
- * (steering / lease). Each tool proxies to `/api/agent-os/{slug}/tasks/*`.
- *
- * Kept in its own module so server.ts does not grow monolithic. server.ts
- * calls `registerTaskTools` with the helpers it already has in scope.
- */
-import { z } from "zod";
-import { get, post, patch } from "../lib/kynver-client.js";
-const taskStatus = z
-    .enum([
-    "ready",
-    "running",
-    "waiting",
-    "scheduled",
-    "blocked",
-    "needs_input",
-    "awaiting_review",
-    "done",
-    "failed",
-    "cancelled",
-])
-    .describe("Work-state lifecycle. `ready` = admitted, can start now. " +
-    "`running` = an executor holds a live lease. `waiting` = gated on upstream tasks (set dependsOnTaskIds; auto-promotes " +
-    "to ready when they're all done). `scheduled` = deferred to a time (set scheduledFor; auto-promotes to ready when it " +
-    "passes). `blocked`/`needs_input` = a human must resolve. `awaiting_review` = review gate open. Don't hand-set " +
-    "ready→running; the dispatcher/executor lease owns that.");
-const taskPriority = z
-    .enum(["low", "normal", "high", "critical"])
-    .describe("Priority is a worker-capacity queue signal, not importance. Default 'normal' (cleanup 'low'). " +
-    "Do NOT inherit plan/goal priority. Use 'high' only when harness workers are saturated and ready work waits for slots. " +
-    "Use 'critical' only for live production/security incidents — pass priorityEscalationReason or cite in title/description. " +
-    "When slots are free, omit priority and dispatch at normal. The API downgrades importance-style high/critical.");
-const priorityEscalationReason = z
-    .string()
-    .optional()
-    .describe("Required for critical: quote the requesting user or name the live production/security incident. " +
-    "High does not use this field — high requires worker-capacity contention at create time.");
-const taskExecutor = z.enum(["inline", "harness", "acp", "manual"]);
-const taskEventType = z.enum([
-    "created",
-    "started",
-    "worker_update",
-    "blocked",
-    "steer",
-    "artifact",
-    "review",
-    "done",
-    "failed",
-]);
-const artifactVisibility = z.enum(["internal", "telegram_safe", "public_pr_safe"]);
-const personaSlug = z
-    .string()
-    .nullable()
-    .optional()
-    .describe("Lane-expert worker slug to attribute the task to, or null to clear/filter unassigned tasks.");
-const scheduledFor = z
-    .string()
-    .nullable()
-    .optional()
-    .describe("ISO-8601 timestamp to defer the task to. A future time creates the task as `scheduled`; the operator loop " +
-    "auto-promotes it to `ready` once the time passes. null clears the schedule.");
-const dependsOnTaskIds = z
-    .array(z.string())
-    .optional()
-    .describe("Upstream task ids this task waits on. Creates the task as `waiting`; the operator loop auto-promotes it to " +
-    "`ready` once every listed task is `done` (a failed/cancelled upstream keeps it waiting).");
-export function registerTaskTools({ register, resolveToolSlug, jsonResult, compact, }) {
-    const slugField = z
-        .string()
-        .optional()
-        .describe("AgentOS slug. Omit to use env or the server-discovered primary.");
-    register("agent_os_task_create", "Create an AgentTask on the board. New tasks start `ready` (dispatchable now) unless you defer them: pass scheduledFor for a timed start (→ `scheduled`) or dependsOnTaskIds to gate on upstream work (→ `waiting`); both auto-promote to `ready` when their gate clears. Idempotent within the AgentOS: pass idempotencyKey (or requestId) from the foreground turn so a Telegram retry or Ghost restart returns the existing task instead of spawning a duplicate. Response includes `created` (false = an existing task was returned). Do NOT create closeout-only bookkeeping tasks whose purpose is merely to close/reconcile/clean up another task — complete/update/block/cancel the existing task (or spawn a child only for genuine unresolved implementation work).", {
-        title: z
-            .string()
-            .describe("Short task title (required). Never a closeout-only sweep — mutate/close the existing task instead."),
-        description: z.string().optional(),
-        priority: taskPriority.optional(),
-        priorityEscalationReason,
-        executor: taskExecutor.optional().describe("How the task runs: inline | harness | acp | manual."),
-        executorRef: z.string().optional().describe("Opaque ref to the executor process / unit."),
-        parentTaskId: z.string().optional().describe("Parent task id when this is one of 2+ coordinated workers."),
-        goalId: z.string().optional(),
-        projectId: z.string().optional(),
-        planId: z
-            .string()
-            .optional()
-            .describe("AgentPlan id to link this task to; required for plan-scoped harness work."),
-        planStageId: z.string().optional().describe("Optional AgentPlan stage id for finer plan lineage."),
-        personaSlug,
-        scheduledFor,
-        dependsOnTaskIds,
-        standaloneReason: z
-            .string()
-            .optional()
-            .describe("Required when intentionally creating an unscoped harness task without parentTaskId or planId; explain why it is standalone."),
-        idempotencyKey: z.string().optional().describe("Dedupe key from the foreground turn. Strongly recommended."),
-        requestId: z.string().optional().describe("Raw foreground request id; used as the dedupe key if idempotencyKey is absent."),
-        slug: slugField,
-    }, async (args) => {
-        const { slug, ...body } = args;
-        const s = await resolveToolSlug(slug);
-        return jsonResult(await post(`/agent-os/${s}/tasks`, compact(body)));
-    });
-    register("agent_os_task_get", "Fetch one AgentTask by id, including lease, artifact, and steer-cursor fields.", { taskId: z.string(), slug: slugField }, async (args) => {
-        const s = await resolveToolSlug(args.slug);
-        return jsonResult(await get(`/agent-os/${s}/tasks/${args.taskId}`));
-    });
-    register("agent_os_task_list", "List AgentTasks on the board, optionally filtered by status, executor, or parent task.", {
-        status: taskStatus.optional(),
-        executor: taskExecutor.optional(),
-        parentTaskId: z.string().optional(),
-        personaSlug,
-        limit: z.number().optional().describe("Max rows (default 50, max 200)."),
-        slug: slugField,
-    }, async (args) => {
-        const params = new URLSearchParams();
-        if (args.status)
-            params.set("status", args.status);
-        if (args.executor)
-            params.set("executor", args.executor);
-        if (args.parentTaskId)
-            params.set("parentTaskId", args.parentTaskId);
-        if (args.personaSlug !== undefined)
-            params.set("personaSlug", args.personaSlug ?? "");
-        if (args.limit)
-            params.set("limit", String(args.limit));
-        const qs = params.toString();
-        const s = await resolveToolSlug(args.slug);
-        return jsonResult(await get(`/agent-os/${s}/tasks${qs ? `?${qs}` : ""}`));
-    });
-    register("agent_os_task_update", "Patch an AgentTask: status, priority, executor, links, schedule (scheduledFor), dependencies (dependsOnTaskIds), progress summary, blocker, or first-class artifact refs (branch/worktreePath/prUrl/headCommit). Does not touch lease fields — use claim/renew for those.", {
-        taskId: z.string(),
-        title: z.string().optional(),
-        description: z.string().optional(),
-        status: taskStatus.optional(),
-        priority: taskPriority.optional(),
-        priorityEscalationReason,
-        executor: taskExecutor.optional(),
-        executorRef: z.string().optional(),
-        parentTaskId: z.string().optional(),
-        goalId: z.string().optional(),
-        projectId: z.string().optional(),
-        planId: z.string().nullable().optional(),
-        planStageId: z.string().nullable().optional(),
-        personaSlug,
-        scheduledFor,
-        dependsOnTaskIds,
-        lastSummary: z.string().optional().describe("Latest progress summary."),
-        blocker: z.string().nullable().optional().describe("Blocker text, or null to clear it."),
-        branch: z.string().optional(),
-        worktreePath: z.string().optional(),
-        prUrl: z.string().optional(),
-        headCommit: z.string().optional(),
-        slug: slugField,
-    }, async (args) => {
-        const { slug, taskId, ...body } = args;
-        const s = await resolveToolSlug(slug);
-        return jsonResult(await patch(`/agent-os/${s}/tasks/${taskId}`, compact(body)));
-    });
-    register("agent_os_task_log_event", "Append one event to a task's append-only journal: worker_update, blocked, artifact, review, etc. For artifact events set artifactVisibility (internal | telegram_safe | public_pr_safe) and put branch/prUrl/headCommit/worktreePath in payload — they are promoted to the task. Pass a stable eventKey so a board-down spool can replay without duplicates.", {
-        taskId: z.string(),
-        type: taskEventType.describe("Event type."),
-        payload: z.record(z.string(), z.unknown()).optional().describe("Structured event detail."),
-        artifactVisibility: artifactVisibility
-            .optional()
-            .describe("Required mental model for artifact events; defaults to internal (most conservative)."),
-        eventKey: z.string().optional().describe("Stable idempotency key for spool replay."),
-        slug: slugField,
-    }, async (args) => {
-        const { slug, taskId, ...body } = args;
-        const s = await resolveToolSlug(slug);
-        return jsonResult(await post(`/agent-os/${s}/tasks/${taskId}/events`, compact(body)));
-    });
-    register("agent_os_task_close", "Close a task into a terminal status (done | failed | cancelled, default done). Stamps closedAt, releases the lease, records the summary, and appends a terminal journal event.", {
-        taskId: z.string(),
-        status: z.enum(["done", "failed", "cancelled"]).optional(),
-        summary: z.string().optional().describe("Closing summary."),
-        slug: slugField,
-    }, async (args) => {
-        const { slug, taskId, ...body } = args;
-        const s = await resolveToolSlug(slug);
-        return jsonResult(await post(`/agent-os/${s}/tasks/${taskId}/close`, compact(body)));
-    });
-    register("agent_os_task_steer", "Append a steer event to a task. Steers are an ordered log — two concurrent steers never overwrite each other; the task's lastSteerEventId tracks the newest. The executor reads steers between its cursor and lastSteerEventId.", {
-        taskId: z.string(),
-        message: z.string().describe("The steering instruction."),
-        detail: z.record(z.string(), z.unknown()).optional(),
-        eventKey: z.string().optional().describe("Stable idempotency key for spool replay."),
-        slug: slugField,
-    }, async (args) => {
-        const { slug, taskId, ...body } = args;
-        const s = await resolveToolSlug(slug);
-        return jsonResult(await post(`/agent-os/${s}/tasks/${taskId}/steer`, compact(body)));
-    });
-    register("agent_os_task_abort", "Hard-abort a task: marks it cancelled and stamps a closing event. Local executor / worktree teardown is the executor's job — this only updates durable board state.", {
-        taskId: z.string(),
-        reason: z.string().optional(),
-        slug: slugField,
-    }, async (args) => {
-        const { slug, taskId, ...body } = args;
-        const s = await resolveToolSlug(slug);
-        return jsonResult(await post(`/agent-os/${s}/tasks/${taskId}/abort`, compact(body)));
-    });
-    register("agent_os_task_claim", "Atomically claim a task lease. Succeeds only when the task is non-terminal and its lease is free (never set or expired). The same conditional update increments `attempt` and flips the task to running. A failed claim returns ok=false with a reason (lease_held | terminal | not_found).", {
-        taskId: z.string(),
-        leaseOwner: z.string().describe("Unique id of the claiming executor."),
-        leaseDurationMs: z.number().optional().describe("Lease duration in ms (default 300000)."),
-        slug: slugField,
-    }, async (args) => {
-        const { slug, taskId, ...body } = args;
-        const s = await resolveToolSlug(slug);
-        return jsonResult(await post(`/agent-os/${s}/tasks/${taskId}/claim`, compact(body)));
-    });
-    register("agent_os_task_renew_lease", "Renew a lease the caller already owns — call periodically while the executor is alive. Succeeds only when leaseOwner matches and the lease has not expired. A failed renew returns ok=false with reason owner_mismatch or lease_expired; the caller must re-claim.", {
-        taskId: z.string(),
-        leaseOwner: z.string().describe("Must match the current lease owner."),
-        leaseDurationMs: z.number().optional().describe("New lease duration in ms (default 300000)."),
-        slug: slugField,
-    }, async (args) => {
-        const { slug, taskId, ...body } = args;
-        const s = await resolveToolSlug(slug);
-        return jsonResult(await post(`/agent-os/${s}/tasks/${taskId}/renew-lease`, compact(body)));
-    });
-    const operatorPriorityLevel = z
-        .enum(["high", "critical"])
-        .optional()
-        .describe("Override dispatch level when expediting (default high). Separate from stored task priority — " +
-        "uses audited operatorPriority* fields, not priority inflation.");
-    register("agent_os_task_operator_priority", "Expedite a ready task to the front of the operator dispatch queue, or clear the override. " +
-        "Requires tasks:write. Set action=set with reason (12+ chars); action=clear to demote. " +
-        "Does not bypass blockers, dependencies, scheduledFor, Will/security gates, or lane filters — " +
-        "only reorders eligible dispatch candidates.", {
-        taskId: z.string(),
-        action: z
-            .enum(["set", "clear"])
-            .optional()
-            .describe("set = front-of-queue override (default). clear = remove override."),
-        reason: z
-            .string()
-            .optional()
-            .describe("Required for set — operator-authored reason (min 12 chars)."),
-        level: operatorPriorityLevel,
-        clearNote: z.string().optional().describe("Optional note when clearing the override."),
-        slug: slugField,
-    }, async (args) => {
-        const { slug, taskId, ...body } = args;
-        const s = await resolveToolSlug(slug);
-        return jsonResult(await post(`/agent-os/${s}/tasks/${taskId}/operator-priority`, compact(body)));
-    });
-}

package/dist/tools/workbench.d.ts

@@ -1,17 +0,0 @@
-/**
- * Workbench control MCP tools (M1) — steer the whole Command Center view.
- */
-type ToolResult = {
-    content: {
-        type: "text";
-        text: string;
-    }[];
-    structuredContent?: unknown;
-};
-export interface WorkbenchToolDeps {
-    register: (name: string, description: string, inputSchema: Record<string, unknown>, cb: (args: any) => any) => void;
-    resolveToolSlug: (explicitSlug?: string) => Promise<string>;
-    jsonResult: (data: unknown) => ToolResult;
-}
-export declare function registerWorkbenchTools({ register, resolveToolSlug, jsonResult, }: WorkbenchToolDeps): void;
-export {};

package/dist/tools/workbench.js

@@ -1,178 +0,0 @@
-/**
- * Workbench control MCP tools (M1) — steer the whole Command Center view.
- */
-import { z } from "zod";
-import { get, post } from "../lib/kynver-client.js";
-const commandKind = z.enum([
-    "navigate",
-    "focus",
-    "drill",
-    "drill_pop",
-    "open_panel",
-    "open_report",
-    "open_pr_history",
-    "highlight",
-    "annotate",
-    "filter",
-    "graph",
-    "reset",
-    "yield",
-    "take",
-]);
-/** Keep in sync with COMMAND_CENTER_VIEW_MODES in command-center-url-state.ts */
-const workbenchView = z.enum([
-    "overview",
-    "flow",
-    "marketing",
-    "projects",
-    "tasks",
-    "goals",
-    "dq",
-    "web",
-    "review",
-    "system",
-    "health",
-]);
-export function registerWorkbenchTools({ register, resolveToolSlug, jsonResult, }) {
-    register("agent_os_workbench_query", [
-        "Read the operator's current workbench focus (view mode, drilldown stack, focused entity)",
-        "plus a compact rollup digest. Use before steering so you and the operator share context.",
-        "Read-only.",
-    ].join(" "), {
-        slug: z.string().optional().describe("AgentOS slug. Defaults to env/primary."),
-    }, async (args) => {
-        const slug = await resolveToolSlug(args.slug);
-        return jsonResult(await get(`/agent-os/${slug}/workbench/focus`));
-    });
-    register("agent_os_workbench_view", [
-        "Steer the Command Center workbench (navigate, focus, drill, open panels, filter, reset).",
-        "View-control only — does not mutate tasks/plans. Delivered over SSE to open surfaces.",
-        "For 3D graph camera commands, use kind=graph or agent_os_graph_view.",
-    ].join(" "), {
-        slug: z.string().optional(),
-        kind: commandKind,
-        view: workbenchView.optional(),
-        target: z.string().optional().describe("EntityRef e.g. task:<id>, plan:<id>"),
-        push: z.boolean().optional().describe("For drill: push onto stack (default true)"),
-        panel: z
-            .string()
-            .optional()
-            .describe("For open_panel: plan-detail | task-detail | goal-detail | project-detail | dq | lane-experts | graph-rail | system-console | system-group:<groupId> | system:<panelId>"),
-        tab: z.string().optional(),
-        personaSlug: z.string().optional(),
-        planId: z.string().optional(),
-        prUrl: z.string().optional(),
-        refs: z
-            .array(z.string())
-            .optional()
-            .describe("For highlight: EntityRefs to point at (max 20) — renders a visible callout"),
-        ttlMs: z
-            .number()
-            .optional()
-            .describe("For highlight: callout duration ms (2000–120000, default 12000)"),
-        note: z.string().optional().describe("For annotate: note text (≤500 chars) shown with target"),
-        chip: z.string().optional(),
-        review: z.string().optional(),
-        q: z.string().optional(),
-        sessionId: z.string().optional(),
-        nodeId: z.string().optional().describe("For kind=graph: graph node id"),
-        graphKind: z.enum(["focus", "filter", "reset", "highlight"]).optional(),
-    }, async (args) => {
-        const slug = await resolveToolSlug(args.slug);
-        const body = {
-            kind: args.kind,
-            source: "agent",
-            sessionId: args.sessionId,
-            personaSlug: args.personaSlug,
-        };
-        switch (args.kind) {
-            case "navigate":
-                body.navigate = { view: args.view };
-                break;
-            case "focus":
-                body.focus = { target: args.target };
-                break;
-            case "drill":
-                body.drill = { target: args.target, push: args.push };
-                break;
-            case "drill_pop":
-                body.drill_pop = {};
-                break;
-            case "open_panel":
-                body.open_panel = { panel: args.panel, tab: args.tab };
-                break;
-            case "open_report":
-                body.open_report = { personaSlug: args.personaSlug };
-                break;
-            case "open_pr_history":
-                body.open_pr_history = { planId: args.planId, prUrl: args.prUrl };
-                break;
-            case "highlight":
-                body.highlight = { refs: args.refs, ttlMs: args.ttlMs };
-                break;
-            case "annotate":
-                body.annotate = { target: args.target, note: args.note };
-                break;
-            case "filter":
-                body.filter = { chip: args.chip, review: args.review, q: args.q };
-                break;
-            case "graph":
-                body.graph = {
-                    command: {
-                        kind: args.graphKind ?? "focus",
-                        nodeId: args.nodeId,
-                        source: "agent",
-                    },
-                };
-                break;
-            default:
-                break;
-        }
-        return jsonResult(await post(`/agent-os/${slug}/workbench/command`, body));
-    });
-    register("agent_os_workbench_present", [
-        "Present a full-screen slideshow on the operator's open Command Center — walk the user",
-        "through points/status/reviews as large-type slides while you narrate in chat.",
-        "action=start with your own slides, OR compose=\"working_on\" to auto-build a",
-        "'What we're working on' deck from the live rollup server-side. Drive with",
-        "action=next/prev/goto/close. Slides may carry an EntityRef (task:<id>, plan:<id>)",
-        "for a 'Show in Command Center' button. View-control only; user can dismiss (Esc).",
-    ].join(" "), {
-        slug: z.string().optional(),
-        action: z.enum(["start", "next", "prev", "goto", "close"]).optional()
-            .describe("Default start."),
-        compose: z.enum(["working_on"]).optional()
-            .describe("Auto-compose the deck from the live rollup (ignores slides)."),
-        title: z.string().optional().describe("Deck headline (start)."),
-        slides: z
-            .array(z.object({
-            title: z.string(),
-            body: z.string().optional(),
-            bullets: z.array(z.string()).optional(),
-            metric: z.object({ value: z.string(), label: z.string() }).optional(),
-            ref: z.string().optional().describe("EntityRef e.g. task:<id>, plan:<id>"),
-            tone: z.enum(["info", "good", "warn", "risk"]).optional(),
-        }))
-            .optional()
-            .describe("Slides for action=start (max 16)."),
-        index: z.number().optional().describe("Target slide for action=goto (0-based)."),
-        autoAdvanceMs: z.number().optional().describe("Optional auto-advance (3000–120000 ms)."),
-        sessionId: z.string().optional(),
-    }, async (args) => {
-        const slug = await resolveToolSlug(args.slug);
-        const body = {
-            kind: "present",
-            source: "agent",
-            sessionId: args.sessionId,
-            compose: args.compose,
-            present: {
-                action: args.action ?? "start",
-                title: args.title,
-                slides: args.slides,
-                index: args.index,
-                autoAdvanceMs: args.autoAdvanceMs,
-            },
-        };
-        return jsonResult(await post(`/agent-os/${slug}/workbench/command`, body));
-    });
-}