codetrellis 0.0.0-stage → 0.3.0

package/src/backend/mcp/tools/presence-tools.js

@@ -0,0 +1,185 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var presence_tools_exports = {};
+__export(presence_tools_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(presence_tools_exports);
+var import_zod = require("zod");
+var import_helpers = require("../helpers");
+var import_breakpoint_service = require("../../services/breakpoint-service");
+function register(server, deps) {
+  server.registerTool(
+    "present",
+    {
+      description: `Post a narration card to the Agent Presence Pane \u2014 a floating overlay in the CodeTrellis UI. Use this to explain what you're doing, narrate a walkthrough, or ask the user a question. Cards support basic markdown (bold, inline code, links). Set speak=true to have the card read aloud via text-to-speech. Set require_ack=true to make the card show a "Got it" button \u2014 pair with await_ack to pace a walkthrough.`,
+      inputSchema: {
+        text: import_zod.z.string().describe("Card body \u2014 supports **bold**, `code`, and [links](url)"),
+        speak: import_zod.z.boolean().optional().default(false).describe("Speak the card aloud via built-in TTS"),
+        require_ack: import_zod.z.boolean().optional().default(false).describe('Show a "Got it" button the user must click before you advance'),
+        tone: import_zod.z.enum(["neutral", "success", "warning", "question"]).optional().default("neutral").describe("Visual tone \u2014 controls the card's accent color"),
+        link_to: import_zod.z.string().optional().describe("Node ID or plan item UID to visually anchor the card to")
+      }
+    },
+    async ({ text, speak, require_ack, tone, link_to }, extra) => {
+      const { author } = (0, import_helpers.authorFromExtra)(deps, extra);
+      const card = deps.presenceService.postCard({
+        text,
+        speak,
+        requireAck: require_ack,
+        tone,
+        linkTo: link_to ?? null,
+        agentId: author
+      });
+      const n = deps.broadcast("presence-card", { card });
+      return (0, import_helpers.resultWithMeta)({ card_id: card.id }, n);
+    }
+  );
+  server.registerTool(
+    "await_ack",
+    {
+      description: 'Block until the user acknowledges a presence card (clicks "Got it" or speech finishes). Returns { acked: true, via: "click"|"speech-end" } on success, { acked: false, via: "timeout" } on timeout, or { acked: false, via: "dismissed" } if the pane was dismissed first. An unknown card_id is an error. Use this after present(require_ack=true) to pace a walkthrough \u2014 the agent waits for the human before advancing.',
+      inputSchema: {
+        card_id: import_zod.z.string().describe("ID of the card to wait for (returned by present)"),
+        timeout_ms: import_zod.z.number().optional().default(3e4).describe("Max wait in ms (default 30s, max 120s)")
+      }
+    },
+    async ({ card_id, timeout_ms }) => {
+      const clampedTimeout = Math.min(timeout_ms ?? 3e4, 12e4);
+      const existing = deps.presenceService.getCard(card_id);
+      if (!existing) {
+        return { content: [{ type: "text", text: `No presence card ${card_id}. Use the card_id that present returned; cards are cleared when the pane is dismissed and when CodeTrellis restarts.` }], isError: true };
+      }
+      if (existing.acked) {
+        return { content: [{ type: "text", text: JSON.stringify({
+          acked: true,
+          via: existing.ackedVia,
+          card_id
+        }, null, 2) }] };
+      }
+      const nonce = `ack-${card_id}`;
+      const p = new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          deps.pendingResponses.delete(nonce);
+          resolve(JSON.stringify({ acked: false, via: "timeout", card_id }));
+        }, clampedTimeout);
+        deps.pendingResponses.set(nonce, { resolve, reject, timer });
+      });
+      const resultStr = await p;
+      return { content: [{ type: "text", text: resultStr }] };
+    }
+  );
+  server.registerTool(
+    "dismiss_presence",
+    {
+      description: "Close the Agent Presence Pane and clear all cards. Use when a walkthrough or narration session is complete.",
+      inputSchema: {}
+    },
+    async () => {
+      for (const card of deps.presenceService.getCards()) {
+        const nonce = `ack-${card.id}`;
+        const pending = deps.pendingResponses.get(nonce);
+        if (!pending) continue;
+        clearTimeout(pending.timer);
+        deps.pendingResponses.delete(nonce);
+        pending.resolve(JSON.stringify({ acked: false, via: "dismissed", card_id: card.id }));
+      }
+      deps.presenceService.clearCards();
+      const n = deps.broadcast("presence-dismissed", {});
+      return (0, import_helpers.resultWithMeta)({ ok: true }, n);
+    }
+  );
+  server.registerTool(
+    "await_user_input",
+    {
+      description: "Block until the user types a reply in the Presence Pane, or timeout. Returns { text, at } with the user's message, { text: null, timed_out: true } on timeout, or { text: null, superseded: true } if another question replaced yours before the person answered. Use after presenting a question to let the user respond without leaving the app.",
+      inputSchema: {
+        prompt: import_zod.z.string().optional().describe("Hint text shown in the reply box"),
+        timeout_ms: import_zod.z.number().optional().default(6e4).describe("Max wait in ms (default 60s, max 300s)")
+      }
+    },
+    async ({ prompt, timeout_ms }) => {
+      const clampedTimeout = Math.min(timeout_ms ?? 6e4, 3e5);
+      const startedAt = Date.now();
+      if (prompt) {
+        deps.broadcast("presence-input-prompt", { prompt });
+      }
+      const immediate = deps.presenceService.consumeReply(startedAt);
+      if (immediate) {
+        return { content: [{ type: "text", text: JSON.stringify({
+          text: immediate.text,
+          at: immediate.createdAt
+        }, null, 2) }] };
+      }
+      const nonce = `reply-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      const p = new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          deps.pendingResponses.delete(nonce);
+          deps.presenceService.clearReplyWaiter(nonce);
+          resolve(JSON.stringify({ text: null, timed_out: true }));
+        }, clampedTimeout);
+        deps.pendingResponses.set(nonce, {
+          resolve,
+          reject: () => {
+          },
+          // never rejects — timeout resolves
+          timer
+        });
+      });
+      const replaced = deps.presenceService.setReplyWaiter(nonce);
+      const previous = replaced ? deps.pendingResponses.get(replaced) : void 0;
+      if (replaced && previous) {
+        clearTimeout(previous.timer);
+        deps.pendingResponses.delete(replaced);
+        previous.resolve(JSON.stringify({
+          text: null,
+          superseded: true,
+          note: "Another question replaced yours in the reply box before the person answered. Ask again if you still need it."
+        }));
+      }
+      const resultStr = await p;
+      return { content: [{ type: "text", text: resultStr }] };
+    }
+  );
+  server.registerTool(
+    "await_decision",
+    {
+      description: 'Wait for a person to answer a breakpoint. When a call returns "paused: waiting for a decision" with a ref, call this with that ref. Returns { status: "answered", decision: "continue" | "steer" | "stop", note } once they answer, or { status: "waiting" } after wait_seconds; then call it again with the same ref. The wait is kept by CodeTrellis, not by this call, so it survives timeouts, reconnects and restarts: an answer can take hours. On continue or steer, make the paused call again (a steer is a note to follow); on stop, do not.',
+      inputSchema: {
+        ref: import_zod.z.string().describe("The ref from the paused result"),
+        wait_seconds: import_zod.z.number().min(0).max(55).optional().describe("How long to wait in this call (default 25, max 55)")
+      }
+    },
+    async ({ ref, wait_seconds }, extra) => {
+      let hit = (0, import_breakpoint_service.getHit)(ref);
+      if (!hit) {
+        return { content: [{ type: "text", text: `No breakpoint is waiting with ref ${ref}.` }], isError: true };
+      }
+      const deadline = Date.now() + Math.min(wait_seconds ?? 25, 55) * 1e3;
+      while (hit.answeredAt === null && Date.now() < deadline && !extra?.signal?.aborted) {
+        await new Promise((r) => setTimeout(r, 250));
+        hit = (0, import_breakpoint_service.getHit)(ref) ?? hit;
+      }
+      return { content: [{ type: "text", text: JSON.stringify((0, import_breakpoint_service.decisionView)(hit), null, 2) }] };
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  register
+});

package/src/backend/mcp/tools/project-config-tools.js

@@ -0,0 +1,150 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var project_config_tools_exports = {};
+__export(project_config_tools_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(project_config_tools_exports);
+var import_zod = require("zod");
+function register(server, deps) {
+  server.registerTool(
+    "get_project_config",
+    {
+      description: "Read the per-project config at <projectRoot>/.codetrellis/config.json. Returns the raw projectConfig and the effective values after resolving precedence per-project > per-user. The effective surface only covers settings with a per-user counterpart (today: plans.{defaultVisibility,attachmentLocation}). channels.routing has no per-user layer to merge against and is therefore project-only \u2014 read it from projectConfig.channels.routing directly. Use this to see what conventions the team has agreed on for the project, and how they differ from your per-user defaults.",
+      inputSchema: {
+        project_root: import_zod.z.string().describe(
+          "Absolute path to the project root. The config is read from <project_root>/.codetrellis/config.json."
+        )
+      }
+    },
+    async ({ project_root }) => {
+      const config = deps.projectConfigService.getProjectConfig(project_root);
+      const effective = {
+        plans: {
+          defaultVisibility: deps.projectConfigService.getEffectiveDefaultVisibility(project_root),
+          attachmentLocation: deps.projectConfigService.getEffectiveAttachmentLocation(project_root)
+        },
+        sensors: deps.projectConfigService.getEffectiveSensorConfig(project_root)
+      };
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ projectConfig: config, effective }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  const channelRouteWhenSchema = import_zod.z.object({
+    eventType: import_zod.z.enum(["stuck", "need-decision", "need-context", "handing-off", "steer", "weigh-in"]).optional(),
+    status: import_zod.z.enum(["open", "resolved", "dismissed"]).optional(),
+    planUid: import_zod.z.string().optional(),
+    itemUid: import_zod.z.string().optional(),
+    minAgeMs: import_zod.z.number().optional()
+  });
+  const channelRouteToastSchema = import_zod.z.object({
+    target: import_zod.z.literal("in-app-toast"),
+    tone: import_zod.z.enum(["info", "warning", "error"]).optional(),
+    sticky: import_zod.z.boolean().optional()
+  });
+  const channelRouteWebhookSchema = import_zod.z.object({
+    target: import_zod.z.literal("webhook"),
+    url: import_zod.z.string(),
+    headers: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).optional()
+  });
+  const channelRoutingRuleSchema = import_zod.z.object({
+    id: import_zod.z.string().optional(),
+    description: import_zod.z.string().optional(),
+    enabled: import_zod.z.boolean().optional(),
+    when: channelRouteWhenSchema,
+    notify: import_zod.z.union([channelRouteToastSchema, channelRouteWebhookSchema])
+  });
+  server.registerTool(
+    "update_project_config",
+    {
+      description: "Update the per-project config at <projectRoot>/.codetrellis/config.json. Pass only the fields you want to change \u2014 unmentioned top-level sections are preserved. `channels.routing` is replaced wholesale when present (no array merge), so callers wanting to add a rule should read the current list first and write it back with the new rule appended. Project-level overrides win over the per-user defaults. The config file is committed to the manifest like any other plan content; teams can review changes through normal PR flow.",
+      inputSchema: {
+        project_root: import_zod.z.string().describe(
+          "Absolute path to the project root. The config is written to <project_root>/.codetrellis/config.json."
+        ),
+        plans: import_zod.z.object({
+          defaultVisibility: import_zod.z.enum(["shared", "local"]).optional().describe('Override the default visibility of new plans. "shared" = export to .codetrellis/plans/, "local" = DB-only.'),
+          attachmentLocation: import_zod.z.enum(["project", "user"]).optional().describe('Override where binary attachments live. "project" = in the repo, "user" = in the user data dir.')
+        }).optional().describe("Plan-related project-level overrides."),
+        channels: import_zod.z.object({
+          routing: import_zod.z.array(channelRoutingRuleSchema).optional().describe(
+            "Channel routing rules \u2014 list of {when, notify} rules evaluated when a channel event is posted. Each rule has a `when` clause (filters by eventType / status / planUid / itemUid / minAgeMs) and a `notify` target (`in-app-toast` for elevated toasts, or `webhook` for an HTTP POST to a user-controlled URL). Set `enabled: false` to keep a rule parsed but inactive. Replacement is wholesale; pass the full intended array."
+          )
+        }).optional().describe("Channel-related project-level overrides."),
+        sensors: import_zod.z.object({
+          drift: import_zod.z.object({
+            enabled: import_zod.z.boolean().optional().describe("Enable drift detection + channel bridging (default: true)."),
+            channelEvents: import_zod.z.boolean().optional().describe("Auto-post need-decision channel events on new deviations (default: true)."),
+            debounceMs: import_zod.z.number().optional().describe("Batch deviations arriving within this window in ms (default: 2000).")
+          }).optional().describe("Drift sensor \u2014 auto-fires when files change outside the plan."),
+          docs: import_zod.z.object({
+            enabled: import_zod.z.boolean().optional().describe("Enable doc-staleness detection + channel bridging (default: true)."),
+            channelEvents: import_zod.z.boolean().optional().describe("Auto-post need-decision channel events when a doc goes stale (default: true).")
+          }).optional().describe("Documentation sensor \u2014 auto-fires when referenced files change."),
+          stuck: import_zod.z.object({
+            enabled: import_zod.z.boolean().optional().describe("Enable stuck detection (default: false \u2014 needs calibration)."),
+            repetitionThreshold: import_zod.z.number().optional().describe("Same tool called N+ times consecutively with low arg variation (default: 8)."),
+            errorLoopThreshold: import_zod.z.number().optional().describe("Same tool errors N+ times in last 10 calls (default: 5)."),
+            idleMinutes: import_zod.z.number().optional().describe("No file change in M minutes while tools are active (default: 15).")
+          }).optional().describe("Stuck sensor \u2014 detects agents looping without progress. Default off."),
+          awareness: import_zod.z.object({
+            branchWindowDays: import_zod.z.number().optional().describe("A branch with no checkout here counts as a line of work when its last commit is this recent, in days (default: 7)."),
+            inlineNotices: import_zod.z.boolean().optional().describe("Tell an agent about an overlap on its next tool call (default: true)."),
+            holdSignOffOnHighSignals: import_zod.z.boolean().optional().describe("A code criterion fails while the plan's line of work has an open high overlap with other work, so sign-off waits (default: false).")
+          }).optional().describe("Awareness of parallel work (Phase 32).")
+        }).optional().describe(
+          "CDev Phase 4 \u2014 per-project sensor configuration. Controls when drift, documentation-staleness, and stuck-agent sensors fire and whether they post channel events. All settings have sensible defaults; override only when calibrating for this project. Pass individual sub-keys to override; absent keys preserve current values."
+        ),
+        repoRole: import_zod.z.enum(["planning", "code", "mixed"]).optional().describe(
+          `CDev Phase 3.6 \u2014 declare this repo's role in a multi-repo setup. "planning" = this is the canonical home for plans (code may be minimal). "code" = this repo ships product code; plans live elsewhere (cross-repo pointers carry the link). "mixed" / absent = the historical default; plans and code coexist here. The UI uses this to soften "no plans here yet" nudges in code repos that delegate planning elsewhere.`
+        ),
+        defaultSurface: import_zod.z.enum(["graph", "code", "brief"]).optional().describe(
+          `Phase 31 \u2014 where opening this folder lands. "brief" for a folder of documents (an analyst's work: tasks, materials, what good looks like), "code" for the code reader, "graph" (the default) for the dependency graph.`
+        )
+      }
+    },
+    async ({ project_root, plans, channels, sensors, repoRole, defaultSurface }) => {
+      const patch = {};
+      if (plans) patch.plans = plans;
+      if (channels) patch.channels = channels;
+      if (sensors) patch.sensors = sensors;
+      if (repoRole !== void 0) patch.repoRole = repoRole;
+      if (defaultSurface !== void 0) patch.defaultSurface = defaultSurface;
+      const updated = deps.projectConfigService.updateProjectConfig(project_root, patch);
+      deps.broadcast("project-config-changed", { projectRoot: project_root, config: updated });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ projectConfig: updated }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  register
+});

package/src/backend/mcp/tools/review-tools.js

@@ -0,0 +1,172 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var review_tools_exports = {};
+__export(review_tools_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(review_tools_exports);
+var import_review_architecture = require("../../services/review-architecture");
+var import_review_marks = require("../../services/review-marks");
+var import_review_task = require("../../services/review-task");
+var import_helpers = require("../helpers");
+var import_git_safety = require("../../services/git-safety");
+var import_zod = require("zod");
+var import_snapshot_compare_service = require("../../services/snapshot-compare-service");
+var import_plan_review_service = require("../../services/plan-review-service");
+var import_pr_draft_service = require("../../services/pr-draft-service");
+var import_review_queue_service = require("../../services/review-queue-service");
+const COMPARAND_HELP = `One of: "live" (working tree), "baseline" (the pinned baseline), "checkpoint:<id>", or "commit:<ref>" (a sha or a branch; list_comparands offers each line of work's branch). A commit carries its dependency edges, so dependencies nobody planned are found for branch reviews too.`;
+function register(server, deps) {
+  server.registerTool(
+    "list_comparands",
+    {
+      description: "Every point you can compare against: the live working tree, the pinned baseline, stored checkpoints, and recent commits. Use these values with compare_snapshots or review_plan.",
+      inputSchema: {
+        project_path: import_zod.z.string().describe("Absolute path to the project root.")
+      }
+    },
+    async ({ project_path }) => ({
+      content: [{ type: "text", text: JSON.stringify((0, import_snapshot_compare_service.listComparands)(project_path, void 0, await (0, import_snapshot_compare_service.comparandBranches)(project_path)), null, 2) }]
+    })
+  );
+  server.registerTool(
+    "compare_snapshots",
+    {
+      description: "Architectural delta between any two points: files added / removed / modified, edges added and removed, and the blast radius of what changed. " + COMPARAND_HELP,
+      inputSchema: {
+        project_path: import_zod.z.string(),
+        before: import_zod.z.string().describe(COMPARAND_HELP),
+        after: import_zod.z.string().describe(COMPARAND_HELP)
+      }
+    },
+    async ({ project_path, before, after }) => {
+      const result = (0, import_snapshot_compare_service.compareSnapshots)(before, after, project_path);
+      if (!result.ok) {
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result.result, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "review_plan",
+    {
+      description: 'Does this change do what the plan said? Reports items fully landed, partially landed and untouched \u2014 plus the two things a textual diff cannot show: files that changed with NO item claiming them, and dependencies that appeared with no item planning them. A new cross-module dependency is one import line in a diff and a new coupling in the architecture; this is where it becomes visible. Set format="markdown" to get a block you can post as a PR comment with your own GitHub credentials \u2014 CodeTrellis holds none.',
+      inputSchema: {
+        plan_uid: import_zod.z.string(),
+        project_path: import_zod.z.string(),
+        before: import_zod.z.string().optional().describe(`Defaults to the newest commit (so the review covers what changed since it); "baseline" when the project has no commits. ${COMPARAND_HELP}`),
+        after: import_zod.z.string().optional().describe(`Defaults to "live". ${COMPARAND_HELP}`),
+        format: import_zod.z.enum(["json", "markdown"]).optional().describe("Defaults to json.")
+      }
+    },
+    async ({ plan_uid, project_path, before, after, format }) => {
+      const reviewed = (0, import_plan_review_service.reviewPlan)({ planUid: plan_uid, projectPath: project_path, before, after });
+      if (!reviewed.ok) {
+        return { content: [{ type: "text", text: JSON.stringify(reviewed, null, 2) }], isError: true };
+      }
+      const result = { ok: true, review: await (0, import_plan_review_service.withArchitecture)(reviewed.review, project_path) };
+      if (format === "markdown") {
+        const plan = deps.planService.getPlan(plan_uid);
+        return {
+          content: [{
+            type: "text",
+            text: (0, import_plan_review_service.renderReviewMarkdown)(result.review, plan?.title)
+          }]
+        };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result.review, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "get_pr_draft",
+    {
+      description: "The title and body for a pull request describing this plan: what it set out to do, the tickets it came from, and the review \u2014 what landed, what did not, and what changed that nobody asked for. YOU do the git and open the PR with your own credentials; this supplies the part you cannot write, because the plan, its ticket lineage and the architectural delta exist nowhere else. Nothing here touches the repository. Check `warnings` before opening: they are the things a reviewer will ask about.",
+      inputSchema: {
+        plan_uid: import_zod.z.string(),
+        project_path: import_zod.z.string(),
+        before: import_zod.z.string().optional().describe(`Defaults to the newest commit (so the review covers what changed since it); "baseline" when the project has no commits. ${COMPARAND_HELP}`),
+        after: import_zod.z.string().optional().describe(`Defaults to "live". ${COMPARAND_HELP}`)
+      }
+    },
+    async ({ plan_uid, project_path, before, after }) => {
+      const result = (0, import_pr_draft_service.buildPrDraft)({ planUid: plan_uid, projectPath: project_path, before, after, architecture: await (0, import_pr_draft_service.draftArchitecture)(project_path, before, after) });
+      if (!result.ok) {
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }], isError: true };
+      }
+      return { content: [{ type: "text", text: JSON.stringify(result.draft, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "get_review_queue",
+    {
+      description: `The review queue: every line of work (a branch) that has plan items, reviewed against the main checkout's branch, with where its criteria stand, its blast radius, dependencies nobody planned, open overlaps with other work, whether it is ready, and a suggested merge order with the reason for each place. A line that changes something another imports goes first, so the other updates to it rather than breaking. The order is a suggestion, never enforced. Use it to answer "what should merge next, and why".`,
+      inputSchema: {
+        project_path: import_zod.z.string()
+      }
+    },
+    async ({ project_path }) => {
+      const queue = (0, import_review_queue_service.reviewQueue)(project_path);
+      return { content: [{ type: "text", text: JSON.stringify(queue, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "review_change",
+    {
+      description: `What a change does to the architecture, with no plan needed: between two commits (a branch and its base), the imports added and removed between folders, outside packages added or dropped (package.json, requirements.txt, go.mod), HTTP calls, routes and SQL added or dropped, imports across the team's rules, and what it does to the rulebook. Read it before the text diff. When head is a branch a plan item names, it also says whether the change did what the task said (task): each criterion with where it stands, the planned files touched and not, and the changed files nobody planned. Without a linked task there is no task section. format="markdown" gives the section for a pull request comment.`,
+      inputSchema: {
+        base: import_zod.z.string().max(200).describe("The commit or branch the change started from, e.g. origin/main."),
+        head: import_zod.z.string().max(200).optional().describe("The change: a commit or branch. Defaults to HEAD."),
+        project_path: import_zod.z.string().optional().describe("An opened project. Omit for the one open in the app."),
+        format: import_zod.z.enum(["json", "markdown"]).optional().describe("Defaults to json."),
+        mark_reviewed: import_zod.z.boolean().optional().describe(
+          "Remember that you reviewed it at its head now. Your next review_change of the same head says what moved since, and which of these findings the pushes addressed."
+        )
+      }
+    },
+    async ({ base, head, project_path, format, mark_reviewed }, extra) => {
+      const root = project_path ?? deps.getActiveProjectPath();
+      if (!root) return { isError: true, content: [{ type: "text", text: "No project is open." }] };
+      if (!(0, import_git_safety.isSafeGitRef)(base) || head !== void 0 && !(0, import_git_safety.isSafeGitRef)(head)) {
+        return { isError: true, content: [{ type: "text", text: "base and head must be commits or branch names." }] };
+      }
+      const a = await (0, import_review_architecture.architectureOf)(root, base, head ?? "HEAD");
+      if ("error" in a) return { isError: true, content: [{ type: "text", text: a.error }] };
+      const who = (0, import_helpers.authorFromExtra)(deps, extra);
+      const target = head ?? "HEAD";
+      const mark = (0, import_review_marks.lastMark)(root, target, who.author);
+      const since = mark ? (0, import_review_marks.sinceLastLook)(root, mark, a.head, a.words) : null;
+      if (mark_reviewed) (0, import_review_marks.markReviewed)(root, { target, reviewer: who.author, reviewerType: who.authorType, base: a.base, commit: a.head, findings: a.words });
+      const task = (0, import_review_task.taskOutcome)(root, base, target);
+      if (format === "markdown") {
+        return { content: [{ type: "text", text: `${since ? `${since.words}
+
+` : ""}${(0, import_review_architecture.architectureMarkdown)(a)}${task ? `
+
+${(0, import_review_task.taskMarkdown)(task)}` : ""}` }] };
+      }
+      return {
+        _meta: { summary: `${a.words.length} architecture finding${a.words.length === 1 ? "" : "s"} between ${base} and ${head ?? "HEAD"}` },
+        content: [{ type: "text", text: JSON.stringify({ ...a, ...since ? { since } : {}, ...task ? { task } : {} }, null, 2) }]
+      };
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  register
+});