zerno-mcp 0.1.0

package/dist/index.js

@@ -0,0 +1,847 @@
+#!/usr/bin/env node
+/**
+ * ZERNO MCP Server
+ *
+ * Connects OpenCode (or any MCP-compatible agent) to the ZERNO cloud product
+ * brain. Exposes tasks, stage checklist, execution policy, and upload tools.
+ *
+ * Required env vars (set in opencode.jsonc → mcp.zerno.environment):
+ *   ZERNO_API_URL      — e.g. https://app.zerno.one
+ *   ZERNO_API_TOKEN    — project-scoped token from ZERNO Settings → OpenCode
+ *   ZERNO_PROJECT_ID   — UUID of the ZERNO project
+ *   ZERNO_CONNECTION_ID — UUID of OpenCodeConnection bound to the local repo
+ */
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import * as client from "./zerno-client.js";
+import { renderTaskCardHTML, renderTaskListHTML, renderBacklogHealthHTML, renderTaskCardMarkdown, renderTaskListMarkdown, renderBacklogHealthMarkdown, } from "./ui/widgets.js";
+import { renderStrategyBriefHTML, renderStrategyBriefMarkdown, renderAlignmentHTML, renderAlignmentMarkdown, renderProductHealthHTML, renderProductHealthMarkdown, renderWeeklyReviewHTML, renderWeeklyReviewMarkdown, } from "./ui/brain.js";
+const server = new Server({ name: "zerno-mcp", version: "0.1.0" }, { capabilities: { tools: {} } });
+function asRecord(value) {
+    if (value && typeof value === "object") {
+        return value;
+    }
+    return {};
+}
+function asString(value) {
+    return typeof value === "string" ? value : "";
+}
+function asTaskLike(value) {
+    return asRecord(value);
+}
+function asTaskList(value) {
+    if (Array.isArray(value))
+        return value;
+    const rec = asRecord(value);
+    const items = rec.tasks ?? rec.items ?? rec.results;
+    return Array.isArray(items) ? items : [];
+}
+function renderForTool(name, args, result) {
+    switch (name) {
+        case "zerno_get_task":
+        case "zerno_update_task":
+        case "zerno_update_task_status":
+        case "zerno_upload_plan":
+        case "zerno_upload_report":
+        case "zerno_create_agent_intake_task":
+        case "zerno_merge_tasks": {
+            const task = asTaskLike(result);
+            return {
+                markdown: renderTaskCardMarkdown(task),
+                html: {
+                    uri: `ui://zerno/task/${asString(task.id) || "result"}`,
+                    html: renderTaskCardHTML(task),
+                },
+            };
+        }
+        case "zerno_list_tasks":
+        case "zerno_list_ready_tasks": {
+            const tasks = asTaskList(result);
+            const heading = name === "zerno_list_ready_tasks" ? "Ready tasks" : "Backlog";
+            const args0 = args || {};
+            const headingFull = args0.order_by ? `${heading} · ${asString(args0.order_by)}` : heading;
+            return {
+                markdown: renderTaskListMarkdown(tasks, headingFull),
+                html: {
+                    uri: `ui://zerno/task-list/${name}`,
+                    html: renderTaskListHTML(tasks, headingFull),
+                },
+            };
+        }
+        case "zerno_bulk_score_backlog": {
+            const tasks = asTaskList(result);
+            return {
+                markdown: renderTaskListMarkdown(tasks, "Scored"),
+                html: {
+                    uri: `ui://zerno/task-list/scored`,
+                    html: renderTaskListHTML(tasks, "Scored tasks"),
+                },
+            };
+        }
+        case "zerno_get_backlog_health": {
+            const data = asRecord(result);
+            return {
+                markdown: renderBacklogHealthMarkdown(data),
+                html: {
+                    uri: `ui://zerno/backlog-health`,
+                    html: renderBacklogHealthHTML(data),
+                },
+            };
+        }
+        case "zerno_strategy_brief": {
+            const data = asRecord(result);
+            return {
+                markdown: renderStrategyBriefMarkdown(data),
+                html: { uri: `ui://zerno/strategy-brief`, html: renderStrategyBriefHTML(data) },
+            };
+        }
+        case "zerno_align_backlog": {
+            const data = asRecord(result);
+            return {
+                markdown: renderAlignmentMarkdown(data),
+                html: { uri: `ui://zerno/backlog-alignment`, html: renderAlignmentHTML(data) },
+            };
+        }
+        case "zerno_product_health": {
+            const data = asRecord(result);
+            return {
+                markdown: renderProductHealthMarkdown(data),
+                html: { uri: `ui://zerno/product-health`, html: renderProductHealthHTML(data) },
+            };
+        }
+        case "zerno_weekly_review": {
+            const data = asRecord(result);
+            return {
+                markdown: renderWeeklyReviewMarkdown(data),
+                html: { uri: `ui://zerno/weekly-review`, html: renderWeeklyReviewHTML(data) },
+            };
+        }
+        default:
+            return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Tool definitions
+// ---------------------------------------------------------------------------
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+        {
+            name: "zerno_get_runtime_config",
+            description: "Return MCP runtime binding (api_url, project_id, connection_id) for diagnostics.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "zerno_get_project_context",
+            description: "Get current ZERNO project context: stage, north star metric, weekly focus, next best action.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "zerno_get_stage",
+            description: "Get the current product stage with checklist items, do-not-do-yet list, and typical risks.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "zerno_list_ready_tasks",
+            description: "List tasks with status=ready or ready_for_agent in the ZERNO project. Prefer `zerno_list_tasks` for richer filtering.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "zerno_list_tasks",
+            description: "Powerful task search across the backlog. Filter by status[], priority[], theme[], assignee, score presence, staleness; order by ICE, priority, updated. Use this to enumerate the full backlog.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    statuses: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "e.g. ['backlog','ready','ready_for_agent','in_progress']",
+                    },
+                    priorities: { type: "array", items: { type: "string" } },
+                    themes: { type: "array", items: { type: "string" } },
+                    assignee_type: { type: "string", description: "agent | human" },
+                    assignee: { type: "string" },
+                    min_ice: { type: "number" },
+                    product_moving: { type: "boolean" },
+                    has_score: { type: "boolean", description: "true = only scored, false = only unscored" },
+                    stale_days: { type: "number", description: "only tasks not updated for this many days" },
+                    bet_ids: { type: "array", items: { type: "string" }, description: "Only tasks linked to one of these bet UUIDs" },
+                    no_bet: { type: "boolean", description: "true = only tasks WITHOUT a bet (orphans); false = only tasks WITH a bet" },
+                    include_merged: { type: "boolean", default: false },
+                    include_deleted: { type: "boolean", default: false },
+                    limit: { type: "number", default: 50 },
+                    order_by: {
+                        type: "string",
+                        enum: ["updated_desc", "ice_desc", "ice_asc", "created_desc", "priority_then_ice"],
+                        default: "updated_desc",
+                    },
+                },
+                required: [],
+            },
+        },
+        {
+            name: "zerno_update_task",
+            description: "Patch task fields: title, status, priority, importance_score, impact_score, effort_score (each 0-10), product_moving (★ flag), theme tag, agent_notes (your scratch space), agent_fit (claude|codex|human). ICE is recomputed automatically when any score changes.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "Task UUID" },
+                    title: { type: "string" },
+                    status: { type: "string" },
+                    priority: { type: "string", description: "low | medium | high | urgent" },
+                    importance_score: { type: "number", minimum: 0, maximum: 10 },
+                    impact_score: { type: "number", minimum: 0, maximum: 10 },
+                    effort_score: { type: "number", minimum: 0, maximum: 10 },
+                    product_moving: { type: "boolean" },
+                    theme: { type: "string", description: "Short cluster tag (e.g. mcp, ui, infra, copy)" },
+                    agent_notes: { type: "string", description: "Persistent notes for future agent runs" },
+                    agent_fit: { type: "string", description: "claude | codex | human | other" },
+                    bet_id: { type: ["string", "null"], description: "Strategic bet UUID to link this task to (null to detach)" },
+                },
+                required: ["task_id"],
+            },
+        },
+        {
+            name: "zerno_bulk_score_backlog",
+            description: "Atomically apply scoring/priority/theme/agent_fit updates to many tasks at once. Use this after analyzing the full backlog to write back the proposed ICE scores, themes, and agent assignments in one call.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    items: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                task_id: { type: "string" },
+                                importance_score: { type: "number", minimum: 0, maximum: 10 },
+                                impact_score: { type: "number", minimum: 0, maximum: 10 },
+                                effort_score: { type: "number", minimum: 0, maximum: 10 },
+                                priority: { type: "string" },
+                                product_moving: { type: "boolean" },
+                                theme: { type: "string" },
+                                agent_notes: { type: "string" },
+                                agent_fit: { type: "string" },
+                                bet_id: { type: ["string", "null"] },
+                            },
+                            required: ["task_id"],
+                        },
+                    },
+                },
+                required: ["items"],
+            },
+        },
+        {
+            name: "zerno_submit_task_triage",
+            description: "Submit AI triage proposals for one or more backlog tasks. Each item is stored as a `pending` suggestion (size/readiness/risk/type/next_action/reason); the underlying task is NOT mutated. A human accepts or rejects from the web UI. Use this after analyzing the inbox to write back classifications in one call.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    items: {
+                        type: "array",
+                        items: {
+                            type: "object",
+                            properties: {
+                                task_id: { type: "string", description: "Task UUID" },
+                                triage_type: {
+                                    type: "string",
+                                    description: "bug | product_task | ui_task | research | integration | tech_debt | refactoring | ops | unknown",
+                                },
+                                triage_size: { type: "string", description: "XS | S | M | L | XL" },
+                                triage_readiness: {
+                                    type: "string",
+                                    description: "ready | needs_clarification | needs_design_decision | needs_technical_investigation | duplicate_or_merge | too_large | blocked | trash",
+                                },
+                                triage_risk: { type: "string", description: "low | medium | high" },
+                                next_action: { type: "string", description: "One sentence on what to do next" },
+                                reason: { type: "string", description: "Why this classification" },
+                                confidence: { type: "string", description: "low | medium | high" },
+                            },
+                            required: ["task_id"],
+                        },
+                    },
+                    source_agent: {
+                        type: "string",
+                        description: "Identifier of the agent that produced this triage (e.g. codex, claude_code)",
+                    },
+                    agent_session_id: { type: "string" },
+                },
+                required: ["items"],
+            },
+        },
+        {
+            name: "zerno_merge_tasks",
+            description: "Soft-merge a duplicate/subset task INTO a target task. Source is marked done and linked via merged_into_id. Use when two tasks describe the same work.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "Source task to absorb (will be closed)" },
+                    target_id: { type: "string", description: "Target task that keeps living" },
+                },
+                required: ["task_id", "target_id"],
+            },
+        },
+        {
+            name: "zerno_get_backlog_health",
+            description: "Backlog dashboard: counts by status/priority/theme/assignee, ★ product movers, top-ICE, quick wins (high impact / low effort), unscored, stale (>7d). Call at the start of a triage session.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "zerno_strategy_brief",
+            description: "Strategic snapshot: stage, North Star metric, weekly focus, next best action, ACTIVE BETS (with hypothesis/target/kill criteria/task counts), open CONSTRAINTS, risks, problems, stage playbook (checklist + do-not-do-yet). Call this at the start of any strategic conversation: 'where are we going / why / what to NOT do'.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "zerno_align_backlog",
+            description: "Backlog alignment view: tasks grouped under each active strategic bet, plus ORPHAN tasks (no bet_id). Use this to find which tasks are noise (not connected to any strategic bet) and re-link or cut them via zerno_update_task / zerno_bulk_score_backlog / zerno_merge_tasks.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "zerno_product_health",
+            description: "Product Health Score 0-100 with 5 blocks (Strategy clarity, Execution focus, Backlog hygiene, Delivery risk, Customer signal) + actionable recommendations. Pure read across ProjectState, Bets, Constraints, Risks, Problems, MemoryNotes and ProductTask. Run weekly.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "zerno_weekly_review",
+            description: "What happened in the last N days (default 7): tasks completed, started, blocked, recent decisions, stale tasks, agent token/$ usage. Built from TaskEvent + AgentRun + Decision. Use to produce the weekly product review and propose next-week focus.",
+            inputSchema: {
+                type: "object",
+                properties: { days: { type: "number", default: 7, minimum: 1, maximum: 60 } },
+                required: [],
+            },
+        },
+        {
+            name: "zerno_get_execution_policy",
+            description: "Get the execution policy: max bulk tasks, safe/risky task types, plan requirements.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "zerno_get_agent_settings",
+            description: "Get project-level agent settings and enabled instruction/skill presets such as Karpathy guidelines.",
+            inputSchema: { type: "object", properties: {}, required: [] },
+        },
+        {
+            name: "zerno_get_task",
+            description: "Get full detail for a specific task by ID.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "Task UUID" },
+                },
+                required: ["task_id"],
+            },
+        },
+        {
+            name: "zerno_resume_task",
+            description: "Resume work on a task: returns the last checkpoint summary, recent events, and suggested next step. Call this first when starting a session on a task.",
+            inputSchema: {
+                type: "object",
+                properties: { task_id: { type: "string", description: "Task UUID" } },
+                required: ["task_id"],
+            },
+        },
+        {
+            name: "zerno_checkpoint",
+            description: "Persist a short summary of where the work stands before ending a session or hitting limits, so the next session can resume cleanly.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "Task UUID" },
+                    summary: { type: "string", description: "Short markdown summary, 1-5 lines" },
+                    branch: { type: "string", description: "Current git branch" },
+                    next_step: { type: "string", description: "What to do next on resume" },
+                },
+                required: ["task_id", "summary"],
+            },
+        },
+        {
+            name: "zerno_log_task_event",
+            description: "Record a free-form event for a task (commit, session_end, pr_open, etc). Used by hooks; agents normally do not call this directly.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "Task UUID" },
+                    event_type: { type: "string", description: "Event kind, e.g. commit | session_end | pr_open" },
+                    summary: { type: "string", description: "Short human-readable summary" },
+                    cost_tokens: { type: "number", minimum: 0 },
+                    duration_ms: { type: "number", minimum: 0 },
+                },
+                required: ["task_id", "event_type"],
+            },
+        },
+        {
+            name: "zerno_upload_plan",
+            description: "Upload a planning document (markdown) for a task. Call before executing the task.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "Task UUID" },
+                    markdown: { type: "string", description: "Full plan in markdown" },
+                    agent_session_id: { type: "string", description: "Optional agent session ID" },
+                },
+                required: ["task_id", "markdown"],
+            },
+        },
+        {
+            name: "zerno_upload_report",
+            description: "Upload an execution report (markdown) for a completed task.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "Task UUID" },
+                    markdown: { type: "string", description: "Report in markdown" },
+                    agent_session_id: { type: "string", description: "Optional agent session ID" },
+                },
+                required: ["task_id", "markdown"],
+            },
+        },
+        {
+            name: "zerno_update_task_status",
+            description: "Update task status. Allowed values: backlog | ready | in_progress | waiting_limit | review | done.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "Task UUID" },
+                    status: {
+                        type: "string",
+                        enum: ["backlog", "ready", "in_progress", "waiting_limit", "review", "done"],
+                    },
+                },
+                required: ["task_id", "status"],
+            },
+        },
+        {
+            name: "zerno_create_agent_intake_task",
+            description: "Create a new review task in ZERNO from ad-hoc implementation report when there is no existing task.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    title: { type: "string", description: "Short task title" },
+                    summary: { type: "string", description: "Implementation summary" },
+                    changed_files: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "List of changed file paths",
+                    },
+                    screenshot_urls: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Screenshot URLs or file references",
+                    },
+                    checks: {
+                        type: "array",
+                        items: { type: "string" },
+                        description: "Checks/tests summary entries",
+                    },
+                    safety_class: { type: "string", description: "Execution safety class, default bulk_safe" },
+                    agent_session_id: { type: "string", description: "Optional agent session ID" },
+                    agent_kind: { type: "string", description: "codex | claude | opencode | other" },
+                },
+                required: ["title", "summary"],
+            },
+        },
+        {
+            name: "zerno_memory_snapshot",
+            description: "Hero memory tool. Returns bundled project memory: state, stage playbook, active bets, open constraints, recent decisions, problems, risks, and pending agent notes. Pass task_id to attach the task being worked on; pass query to bias results to a topic. Call this at the START of every coding session.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    task_id: { type: "string", description: "Optional task UUID being worked on" },
+                    query: {
+                        type: "string",
+                        description: "Optional ILIKE filter applied to titles/markdown of bets/decisions/constraints",
+                    },
+                    decisions_limit: { type: "number" },
+                    bets_limit: { type: "number" },
+                    constraints_limit: { type: "number" },
+                    pending_notes_limit: { type: "number" },
+                },
+                required: [],
+            },
+        },
+        {
+            name: "zerno_memory_search",
+            description: "Full-text-ish (ILIKE) search across decisions, bets, constraints, and pending memory notes for the project. Returns ranked hits with snippets.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    query: { type: "string", minLength: 1 },
+                    limit_per_kind: { type: "number", default: 5 },
+                },
+                required: ["query"],
+            },
+        },
+        {
+            name: "zerno_memory_list_decisions",
+            description: "List recent product decisions for the project. Optional status filter.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    status: { type: "string" },
+                    limit: { type: "number" },
+                },
+                required: [],
+            },
+        },
+        {
+            name: "zerno_memory_list_bets",
+            description: "List active product bets for the project. Optional status filter.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    status: { type: "string" },
+                    limit: { type: "number" },
+                },
+                required: [],
+            },
+        },
+        {
+            name: "zerno_memory_list_constraints",
+            description: "List open constraints for the project. Optional status filter.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    status: { type: "string" },
+                    limit: { type: "number" },
+                },
+                required: [],
+            },
+        },
+        {
+            name: "zerno_memory_list_notes",
+            description: "List memory notes (agent inbox). Filter by status (pending|accepted|rejected|merged) or kind.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    status: { type: "string" },
+                    kind: { type: "string" },
+                    limit: { type: "number" },
+                },
+                required: [],
+            },
+        },
+        {
+            name: "zerno_run_start",
+            description: "Start an agent run for telemetry (tokens, cost, duration). Returns a run_id you must pass to record_usage and finish_run.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    agent_kind: {
+                        type: "string",
+                        description: "claude_code | cursor | codex | opencode | other",
+                    },
+                    agent_session_id: { type: "string" },
+                    title: { type: "string", description: "Short label, e.g. user prompt summary" },
+                    model: { type: "string", description: "Model id, e.g. claude-opus-4-7" },
+                    related_task_id: { type: "string", description: "Optional ZERNO task UUID" },
+                    started_at: { type: "string", description: "Optional ISO start time (defaults to now)" },
+                    extra: { type: "object", description: "Free-form metadata" },
+                },
+                required: ["agent_kind"],
+            },
+        },
+        {
+            name: "zerno_run_record_usage",
+            description: "Append token usage to a running run. Cost is computed server-side from the model. Call this after each turn / tool result.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    run_id: { type: "string" },
+                    input_tokens: { type: "number", default: 0 },
+                    output_tokens: { type: "number", default: 0 },
+                    cache_read_tokens: { type: "number", default: 0 },
+                    cache_write_tokens: { type: "number", default: 0 },
+                    model: {
+                        type: "string",
+                        description: "Override model for this delta (defaults to run.model)",
+                    },
+                },
+                required: ["run_id"],
+            },
+        },
+        {
+            name: "zerno_run_finish",
+            description: "Mark an agent run as succeeded | failed | cancelled. Optional summary/error_message.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    run_id: { type: "string" },
+                    status: {
+                        type: "string",
+                        enum: ["succeeded", "failed", "cancelled"],
+                        default: "succeeded",
+                    },
+                    summary: { type: "string" },
+                    error_message: { type: "string" },
+                    ended_at: { type: "string" },
+                },
+                required: ["run_id"],
+            },
+        },
+        {
+            name: "zerno_memory_capture_note",
+            description: "Append an agent-proposed note to the project memory inbox. Use this to record learnings, draft decisions, surfaced risks, or context that the human should curate. Agents NEVER write directly into Decision/Bet/Constraint — only here.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    kind: {
+                        type: "string",
+                        enum: ["learning", "decision_draft", "context", "risk", "todo"],
+                    },
+                    title: { type: "string", minLength: 1, maxLength: 300 },
+                    content_md: { type: "string", minLength: 1 },
+                    confidence: { type: "string", enum: ["low", "medium", "high"], default: "medium" },
+                    source: { type: "string", description: "Free-form source label, e.g. file path or url" },
+                    agent_session_id: { type: "string" },
+                    related_task_id: { type: "string", description: "Optional task UUID" },
+                },
+                required: ["kind", "title", "content_md"],
+            },
+        },
+    ],
+}));
+// ---------------------------------------------------------------------------
+// Tool handlers
+// ---------------------------------------------------------------------------
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+    const { name, arguments: args } = req.params;
+    try {
+        let result;
+        switch (name) {
+            case "zerno_get_project_context":
+                result = await client.getProjectContext();
+                break;
+            case "zerno_get_runtime_config":
+                result = client.getRuntimeConfig();
+                break;
+            case "zerno_get_stage":
+                result = await client.getStage();
+                break;
+            case "zerno_list_ready_tasks":
+                result = await client.listReadyTasks();
+                break;
+            case "zerno_list_tasks":
+                result = await client.listTasks({
+                    statuses: args?.statuses,
+                    priorities: args?.priorities,
+                    themes: args?.themes,
+                    assignee_type: args?.assignee_type,
+                    assignee: args?.assignee,
+                    min_ice: args?.min_ice,
+                    product_moving: args?.product_moving,
+                    has_score: args?.has_score,
+                    stale_days: args?.stale_days,
+                    include_merged: args?.include_merged,
+                    include_deleted: args?.include_deleted,
+                    limit: args?.limit,
+                    order_by: args?.order_by,
+                });
+                break;
+            case "zerno_update_task":
+                result = await client.updateTask(args.task_id, {
+                    title: args?.title,
+                    status: args?.status,
+                    priority: args?.priority,
+                    importance_score: args?.importance_score,
+                    impact_score: args?.impact_score,
+                    effort_score: args?.effort_score,
+                    product_moving: args?.product_moving,
+                    theme: args?.theme,
+                    agent_notes: args?.agent_notes,
+                    agent_fit: args?.agent_fit,
+                });
+                break;
+            case "zerno_bulk_score_backlog":
+                result = await client.bulkScoreBacklog(args.items ?? []);
+                break;
+            case "zerno_merge_tasks":
+                result = await client.mergeTasks(args.task_id, args.target_id);
+                break;
+            case "zerno_submit_task_triage":
+                result = await client.submitTaskTriage(args.items ?? [], {
+                    source_agent: args?.source_agent,
+                    agent_session_id: args?.agent_session_id,
+                });
+                break;
+            case "zerno_get_backlog_health":
+                result = await client.getBacklogHealth();
+                break;
+            case "zerno_strategy_brief":
+                result = await client.getStrategyBrief();
+                break;
+            case "zerno_align_backlog":
+                result = await client.getBacklogAlignment();
+                break;
+            case "zerno_product_health":
+                result = await client.getProductHealth();
+                break;
+            case "zerno_weekly_review":
+                result = await client.getWeeklyReview(args?.days);
+                break;
+            case "zerno_get_execution_policy":
+                result = await client.getExecutionPolicy();
+                break;
+            case "zerno_get_agent_settings":
+                result = await client.getAgentSettings();
+                break;
+            case "zerno_get_task":
+                result = await client.getTask(args.task_id);
+                break;
+            case "zerno_resume_task":
+                result = await client.resumeTask(args.task_id);
+                break;
+            case "zerno_checkpoint":
+                result = await client.checkpointTask(args.task_id, {
+                    summary: args.summary,
+                    branch: args?.branch,
+                    next_step: args?.next_step,
+                    extra: args?.extra,
+                });
+                break;
+            case "zerno_log_task_event":
+                result = await client.logTaskEvent(args.task_id, {
+                    event_type: args.event_type,
+                    summary: args?.summary,
+                    cost_tokens: args?.cost_tokens,
+                    duration_ms: args?.duration_ms,
+                });
+                break;
+            case "zerno_upload_plan":
+                result = await client.uploadPlan(args.task_id, args.markdown, args.agent_session_id);
+                break;
+            case "zerno_upload_report":
+                result = await client.uploadReport(args.task_id, args.markdown, args.agent_session_id);
+                break;
+            case "zerno_update_task_status":
+                result = await client.updateTaskStatus(args.task_id, args.status);
+                break;
+            case "zerno_create_agent_intake_task":
+                result = await client.createAgentIntakeTask({
+                    title: args.title,
+                    summary: args.summary,
+                    changed_files: args?.changed_files ?? [],
+                    screenshot_urls: args?.screenshot_urls ?? [],
+                    checks: args?.checks ?? [],
+                    safety_class: args?.safety_class ?? "bulk_safe",
+                    agent_session_id: args?.agent_session_id,
+                    agent_kind: args?.agent_kind,
+                });
+                break;
+            case "zerno_memory_snapshot":
+                result = await client.getMemorySnapshot({
+                    task_id: args?.task_id,
+                    query: args?.query,
+                    decisions_limit: args?.decisions_limit,
+                    bets_limit: args?.bets_limit,
+                    constraints_limit: args?.constraints_limit,
+                    pending_notes_limit: args?.pending_notes_limit,
+                });
+                break;
+            case "zerno_memory_search":
+                result = await client.searchMemory(args.query, args?.limit_per_kind);
+                break;
+            case "zerno_memory_list_decisions":
+                result = await client.listMemoryDecisions({
+                    status: args?.status,
+                    limit: args?.limit,
+                });
+                break;
+            case "zerno_memory_list_bets":
+                result = await client.listMemoryBets({
+                    status: args?.status,
+                    limit: args?.limit,
+                });
+                break;
+            case "zerno_memory_list_constraints":
+                result = await client.listMemoryConstraints({
+                    status: args?.status,
+                    limit: args?.limit,
+                });
+                break;
+            case "zerno_memory_list_notes":
+                result = await client.listMemoryNotes({
+                    status: args?.status,
+                    kind: args?.kind,
+                    limit: args?.limit,
+                });
+                break;
+            case "zerno_run_start":
+                result = await client.startRun({
+                    agent_kind: args.agent_kind,
+                    agent_session_id: args?.agent_session_id,
+                    title: args?.title,
+                    model: args?.model,
+                    related_task_id: args?.related_task_id,
+                    started_at: args?.started_at,
+                    extra: args?.extra,
+                });
+                break;
+            case "zerno_run_record_usage":
+                result = await client.recordRunUsage(args.run_id, {
+                    input_tokens: args?.input_tokens,
+                    output_tokens: args?.output_tokens,
+                    cache_read_tokens: args?.cache_read_tokens,
+                    cache_write_tokens: args?.cache_write_tokens,
+                    model: args?.model,
+                });
+                break;
+            case "zerno_run_finish":
+                result = await client.finishRun(args.run_id, {
+                    status: args?.status,
+                    summary: args?.summary,
+                    error_message: args?.error_message,
+                    ended_at: args?.ended_at,
+                });
+                break;
+            case "zerno_memory_capture_note":
+                result = await client.appendMemoryNote({
+                    kind: args.kind,
+                    title: args.title,
+                    content_md: args.content_md,
+                    confidence: args?.confidence,
+                    source: args?.source,
+                    agent_session_id: args?.agent_session_id,
+                    related_task_id: args?.related_task_id,
+                });
+                break;
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+        const rendered = renderForTool(name, (args ?? {}), result);
+        const fallbackJson = JSON.stringify(result, null, 2);
+        const content = [];
+        if (rendered?.html) {
+            content.push({
+                type: "resource",
+                resource: {
+                    uri: rendered.html.uri,
+                    mimeType: "text/html",
+                    text: rendered.html.html,
+                },
+                _meta: {
+                    "mcpui.dev/ui-preferred-frame-size": ["100%", "auto"],
+                },
+            });
+        }
+        if (rendered?.markdown) {
+            content.push({ type: "text", text: rendered.markdown });
+        }
+        content.push({ type: "text", text: fallbackJson });
+        return { content };
+    }
+    catch (err) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${err instanceof Error ? err.message : String(err)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// ---------------------------------------------------------------------------
+// Start
+// ---------------------------------------------------------------------------
+const transport = new StdioServerTransport();
+await server.connect(transport);