codetrellis 0.0.0-stage → 0.3.0

package/src/backend/mcp/tools/budget-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 budget_tools_exports = {};
+__export(budget_tools_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(budget_tools_exports);
+var import_zod = require("zod");
+var import_helpers = require("../helpers");
+var import_budget_service = require("../../services/budget-service");
+var import_pricing = require("../../services/pricing");
+var import_push_notification_service = require("../../services/push-notification-service");
+function round(n, places = 1) {
+  if (n === null) return null;
+  const f = 10 ** places;
+  return Math.round(n * f) / f;
+}
+function summarise(planUid) {
+  const report = (0, import_budget_service.getBudgetReport)(planUid);
+  return {
+    plan_uid: planUid,
+    budget: report.budget ? {
+      minutes: report.budget.minutes,
+      cost_usd: report.budget.costUsd,
+      exempt: report.budget.exempt
+    } : null,
+    spent: {
+      minutes: round(report.spentMinutes),
+      cost_usd: round(report.spentCostUsd, 4),
+      cost_display: (0, import_pricing.formatCost)(report.spentCostUsd)
+    },
+    estimate: {
+      minutes: report.estimateMinutes,
+      cost_usd: report.estimateCostUsd
+    },
+    forecast: {
+      minutes: round(report.forecastMinutes),
+      cost_usd: round(report.forecastCostUsd, 4),
+      // Stated so a caller knows what the projection is based on rather
+      // than treating it as a measurement.
+      based_on_completion: report.completionRatio
+    },
+    by_agent: report.byAgent.map((a) => ({
+      agent_type: a.agentType,
+      minutes: round(a.minutes),
+      cost_usd: round(a.costUsd, 4)
+    })),
+    overruns: report.overruns.map((o) => ({
+      item_uid: o.itemUid,
+      estimate_minutes: o.estimateMinutes,
+      spent_minutes: round(o.spentMinutes)
+    })),
+    // Cost figures are only as current as the price table that produced
+    // them; saying which one avoids a stale number reading as fresh.
+    // This is the table the TOTAL was priced under — `mixed` when it
+    // spans a price change — not whichever table happens to be loaded
+    // now, which is what it used to report and is the exact claim the
+    // field exists to prevent.
+    pricing_version: report.pricingVersion,
+    pricing_versions: report.pricingVersions,
+    // An agent's change to the ceiling stays flagged until a person has seen
+    // it (Phase 32 §0.4g): what it was, what it became, and who changed it.
+    flagged_changes: report.flaggedChanges.map((c) => ({
+      by: c.actor,
+      by_type: c.actorType,
+      at: new Date(c.at).toISOString(),
+      before: c.before ? { minutes: c.before.minutes, cost_usd: c.before.costUsd, exempt: c.before.exempt } : null,
+      after: { minutes: c.after.minutes, cost_usd: c.after.costUsd, exempt: c.after.exempt }
+    })),
+    note: [
+      report.spentCostUsd === null && (0, import_budget_service.getUnattributedTokenReports)() === 0 ? "No cost recorded: no agent on this plan reported a model we have prices for. Time is still measured." : null,
+      // Distinguishes 'nothing was spent' from 'spending was reported and we
+      // could not attribute it'. Those render identically as a zero, and only
+      // one of them means the plan was cheap.
+      (0, import_budget_service.getUnattributedTokenReports)() > 0 ? "Cost is incomplete: " + (0, import_budget_service.getUnattributedTokenReports)() + " token report(s) could not be matched to a turn, because the id they carry (the agent\u2019s own session) and the id turns are keyed by (the MCP transport session) are different identifiers. Time is still measured; treat cost as a floor, not a total." : null,
+      // `estimate_minutes` / `estimate_cost_usd` exist on plan_items and no
+      // authoring path writes them, so estimate and overruns are structurally
+      // empty on every install. Saying so is the difference between 'this plan
+      // is within its estimate' and 'nobody set one' — which read identically
+      // before, and only one of them is true.
+      report.estimateMinutes === null && report.estimateCostUsd === null ? "No estimate recorded: nothing sets per-item estimates yet, so estimate is empty and overruns cannot be computed. This is an absent input, not a plan that is on budget." : null
+    ].filter(Boolean).join(" ") || void 0
+  };
+}
+function missingPlan(deps, planUid) {
+  return deps.planService.getPlan(planUid) ? null : { content: [{ type: "text", text: `Plan ${planUid} not found.` }], isError: true };
+}
+function register(server, deps) {
+  server.registerTool(
+    "get_budget",
+    {
+      description: "Time and cost for a plan: what has actually been spent, a forecast to completion, and a per-agent split. Time is measured for every agent; cost only where the agent reports a model we have prices for \u2014 an unknown cost is reported as null, never as zero. Estimates and overruns are reported only when a plan carries estimates, and nothing records them yet, so today they are always absent \u2014 see the note on the response.",
+      inputSchema: {
+        plan_uid: import_zod.z.string().describe("UID of the plan.")
+      }
+    },
+    async ({ plan_uid }) => missingPlan(deps, plan_uid) ?? {
+      content: [{ type: "text", text: JSON.stringify(summarise(plan_uid), null, 2) }]
+    }
+  );
+  server.registerTool(
+    "set_budget",
+    {
+      description: "Set or clear a plan budget. Either dimension may be set independently; pass null to clear one. Crossing 80% raises a need-decision channel event (once), and past 100% check_budget returns allowed=false. The ceiling is advisory \u2014 it cannot stop an agent, it tells one to stop. A change you make is recorded in your name with the values before it, and flagged to the person until they acknowledge it; say why in your reply to them.",
+      inputSchema: {
+        plan_uid: import_zod.z.string(),
+        minutes: import_zod.z.number().int().positive().nullable().optional().describe("Wall-clock minutes across every agent. Null clears."),
+        cost_usd: import_zod.z.number().positive().nullable().optional().describe("USD ceiling. Null clears."),
+        exempt: import_zod.z.boolean().optional().describe("Exempt this plan from its ceiling without clearing it \u2014 mirrors freeze exemptions.")
+      }
+    },
+    async ({ plan_uid, minutes, cost_usd, exempt }, extra) => {
+      const refused = missingPlan(deps, plan_uid);
+      if (refused) return refused;
+      const id = (0, import_helpers.authorFromExtra)(deps, extra);
+      const flaggedBefore = (0, import_budget_service.getBudgetReport)(plan_uid).flaggedChanges.length;
+      const budget = (0, import_budget_service.setBudget)({
+        planUid: plan_uid,
+        minutes,
+        costUsd: cost_usd,
+        exempt,
+        by: { actor: id.author, actorType: id.authorType, channel: "mcp" }
+      });
+      const n = deps.broadcast("plan-budget-changed", { planUid: plan_uid, budget, flagged: true });
+      if ((0, import_budget_service.getBudgetReport)(plan_uid).flaggedChanges.length > flaggedBefore) {
+        void (0, import_push_notification_service.pushForBudgetChange)(plan_uid, deps.planService.getPlan(plan_uid)?.title ?? plan_uid, id.author).catch(() => {
+        });
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({ ok: true, broadcastTo: n, ...summarise(plan_uid) }, null, 2)
+        }]
+      };
+    }
+  );
+  server.registerTool(
+    "check_budget",
+    {
+      description: "Whether more work should start on this plan. Call this before claiming an item, the same way check_freeze is called. Returns allowed=false once the plan is past its ceiling, with a reason to relay to the human. Advisory: nothing here can stop you, so respecting it is the point.",
+      inputSchema: {
+        plan_uid: import_zod.z.string()
+      }
+    },
+    async ({ plan_uid }) => {
+      const refused = missingPlan(deps, plan_uid);
+      if (refused) return refused;
+      const result = (0, import_budget_service.checkBudget)(plan_uid);
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify(
+            {
+              allowed: result.allowed,
+              state: result.state,
+              reason: result.reason,
+              ...summarise(plan_uid)
+            },
+            null,
+            2
+          )
+        }]
+      };
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  register
+});

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

@@ -0,0 +1,205 @@
+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 channel_tools_exports = {};
+__export(channel_tools_exports, {
+  register: () => register
+});
+module.exports = __toCommonJS(channel_tools_exports);
+var import_helpers = require("../helpers");
+var import_zod = require("zod");
+var import_channel_event_service = require("../../services/channel-event-service");
+var import_channel_event_file_service = require("../../services/channel-event-file-service");
+var import_channel_dispatcher_service = require("../../services/channel-dispatcher-service");
+var import_plan_file_service = require("../../services/plan-file-service");
+var import_plan_service = require("../../services/plan-service");
+var import_types = require("../../../shared/types");
+const eventTypeEnum = import_zod.z.enum([
+  "stuck",
+  "need-decision",
+  "need-context",
+  "handing-off",
+  "steer",
+  "weigh-in"
+]);
+const statusEnum = import_zod.z.enum(["open", "resolved", "dismissed"]);
+function register(server, deps) {
+  server.registerTool(
+    "post_channel_event",
+    {
+      description: "Post a channel event to a plan. Six event types in the peer-to-peer team-coordination vocabulary: stuck (failing repeatedly), need-decision (genuine choice can't make alone), need-context (missing knowledge), handing-off (another actor should take over; here's what was tried), steer (direction in response), weigh-in (here's my thinking \u2014 what do others see?). Both humans and agents can post any of these. Events are durable; when the plan is shared (linked to disk), the event is exported to .codetrellis/plans/<slug>/channels/<uid>.yaml and travels via git.",
+      inputSchema: {
+        plan_uid: import_zod.z.string().describe("UID of the plan to post the event on."),
+        item_uid: import_zod.z.string().nullable().optional().describe(
+          "Optional UID of the plan item this event anchors to. Useful when a stuck/need-decision is specific to one item."
+        ),
+        event_type: eventTypeEnum.describe("One of the six channel event types."),
+        message: import_zod.z.string().describe("Plain-English description of the event. Required. Used as the headline by readers."),
+        attempted: import_zod.z.array(import_zod.z.string()).optional().describe(
+          "For stuck / handing-off: short list of what was tried. One entry per attempt."
+        ),
+        options: import_zod.z.array(import_zod.z.string()).optional().describe(
+          "For need-decision: the alternatives the asker has identified."
+        ),
+        responds_to: import_zod.z.string().nullable().optional().describe(
+          "Optional. UID of the channel event this responds to (for threading). Posting a `steer` against a `stuck` does NOT auto-resolve the stuck \u2014 resolution is a separate `resolve_channel_event` call."
+        )
+      }
+    },
+    async ({ plan_uid, item_uid, event_type, message, attempted, options, responds_to }) => {
+      const { author, authorType, agentModel } = resolveAttribution(deps);
+      const payload = { message };
+      if (attempted && attempted.length > 0) payload.attempted = attempted;
+      if (options && options.length > 0) payload.options = options;
+      const created = (0, import_channel_event_service.postChannelEvent)({
+        planUid: plan_uid,
+        itemUid: item_uid ?? null,
+        eventType: event_type,
+        payload,
+        author,
+        authorType,
+        agentModel,
+        respondsTo: responds_to ?? null
+      });
+      maybeExportEvent(created);
+      deps.broadcast("channel-event-posted", {
+        uid: created.uid,
+        planUid: created.planUid,
+        itemUid: created.itemUid,
+        eventType: created.eventType,
+        respondsTo: created.respondsTo
+      });
+      (0, import_channel_dispatcher_service.dispatchChannelEvent)(created).catch((err) => console.warn("[Channels] dispatch failed:", err));
+      return { content: [{ type: "text", text: JSON.stringify(created, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "list_channel_events",
+    {
+      description: 'List channel events for a plan, newest-first. Filter by event type, status, or scoped item. Use this to see "what needs my attention" (status=open) or to review the team-coordination history.',
+      inputSchema: {
+        plan_uid: import_zod.z.string().describe("UID of the plan to list events for."),
+        event_types: import_zod.z.array(eventTypeEnum).optional().describe(
+          "Filter to these event types. Omit for all."
+        ),
+        status: import_zod.z.array(statusEnum).optional().describe(
+          'Filter to these statuses. Omit for all. "open" surfaces "what needs response".'
+        ),
+        item_uid: import_zod.z.string().optional().describe(
+          "Scope to events anchored to this plan item."
+        ),
+        since_ms: import_zod.z.number().optional().describe(
+          "UNIX ms cutoff \u2014 only events with created_at >= since_ms. Useful for incremental polling."
+        ),
+        limit: import_zod.z.number().optional().describe("Cap. Default 200."),
+        offset: import_zod.z.number().optional().describe("Pagination offset. Default 0.")
+      }
+    },
+    async ({ plan_uid, event_types, status, item_uid, since_ms, limit, offset }) => {
+      const opts = {};
+      if (event_types && event_types.length > 0) opts.eventTypes = event_types;
+      if (status && status.length > 0) opts.status = status;
+      if (item_uid) opts.itemUid = item_uid;
+      if (since_ms !== void 0) opts.sinceMs = since_ms;
+      if (limit !== void 0) opts.limit = limit;
+      if (offset !== void 0) opts.offset = offset;
+      const events = (0, import_channel_event_service.listChannelEvents)(plan_uid, opts);
+      return { content: [{ type: "text", text: JSON.stringify(events, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "get_channel_thread",
+    {
+      description: "Return a channel event thread \u2014 the root event plus all descendant responses, ordered chronologically. Use this to read the full back-and-forth around a stuck / need-decision conversation.",
+      inputSchema: {
+        root_event_uid: import_zod.z.string().describe("UID of the thread root (typically a stuck or need-decision event).")
+      }
+    },
+    async ({ root_event_uid }) => {
+      const events = (0, import_channel_event_service.listThread)(root_event_uid);
+      return { content: [{ type: "text", text: JSON.stringify(events, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "resolve_channel_event",
+    {
+      description: 'Mark a channel event as resolved. Typically called after a stuck has been steered through, or a need-decision has been answered. Sets status to "resolved" and exports the change to disk.',
+      inputSchema: {
+        event_uid: import_zod.z.string().describe("UID of the channel event to resolve.")
+      }
+    },
+    async ({ event_uid }) => {
+      const updated = (0, import_channel_event_service.setChannelEventStatus)(event_uid, "resolved");
+      maybeExportEvent(updated);
+      deps.broadcast("channel-event-status-changed", {
+        uid: updated.uid,
+        planUid: updated.planUid,
+        status: updated.status
+      });
+      (0, import_channel_dispatcher_service.dispatchChannelEvent)(updated).catch((err) => console.warn("[Channels] dispatch failed:", err));
+      return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
+    }
+  );
+  server.registerTool(
+    "dismiss_channel_event",
+    {
+      description: 'Mark a channel event as dismissed. Used when an event no longer needs a response (e.g., the underlying issue went away, or the asker abandoned the line of inquiry). The event stays in the history; it just stops appearing in "what needs my attention" lists.',
+      inputSchema: {
+        event_uid: import_zod.z.string().describe("UID of the channel event to dismiss.")
+      }
+    },
+    async ({ event_uid }) => {
+      const updated = (0, import_channel_event_service.setChannelEventStatus)(event_uid, "dismissed");
+      maybeExportEvent(updated);
+      deps.broadcast("channel-event-status-changed", {
+        uid: updated.uid,
+        planUid: updated.planUid,
+        status: updated.status
+      });
+      (0, import_channel_dispatcher_service.dispatchChannelEvent)(updated).catch((err) => console.warn("[Channels] dispatch failed:", err));
+      return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
+    }
+  );
+}
+function resolveAttribution(deps) {
+  const settings = deps.getSettings();
+  const humanAuthor = settings.identity.email || "human";
+  const agentType = (0, import_helpers.authorFromExtra)(deps, void 0).author;
+  const match = deps.sessionService.getActiveSessions().find((s) => s.sessionId === deps.sessionId);
+  return {
+    author: humanAuthor,
+    authorType: agentType,
+    agentModel: match?.model ?? null
+  };
+}
+function maybeExportEvent(event) {
+  const plan = (0, import_plan_service.getPlan)(event.planUid);
+  if (!plan) return;
+  const linkedDir = (0, import_plan_file_service.getLinkedPlanDir)(event.planUid, plan.projectPath);
+  if (!linkedDir) return;
+  try {
+    (0, import_channel_event_file_service.exportChannelEvent)(event, plan.projectPath);
+  } catch (err) {
+    console.warn(`[ChannelTools] Failed to export event ${event.uid} to disk:`, err);
+  }
+}
+void import_types.CHANNEL_EVENT_TYPES;
+void import_types.CHANNEL_EVENT_STATUSES;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  register
+});

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

@@ -0,0 +1,181 @@
+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 contribution_tools_exports = {};
+__export(contribution_tools_exports, {
+  registerContributionTools: () => registerContributionTools
+});
+module.exports = __toCommonJS(contribution_tools_exports);
+var import_zod = require("zod");
+var import_pantry_resolution_service = require("../../services/pantry-resolution-service");
+var import_contribution_service = require("../../services/contribution-service");
+function registerContributionTools(server) {
+  server.tool(
+    "resolve_pantry_references",
+    'Check which attachment references can be resolved locally. Returns "resolved" or "external" for each, enabling placeholder display for team-only content that external contributors cannot access.',
+    {
+      project_path: import_zod.z.string().describe("Absolute path to project root"),
+      references: import_zod.z.array(import_zod.z.string()).optional().describe("Specific references to resolve. If omitted, scans the plan for all references."),
+      plan_slug: import_zod.z.string().optional().describe("Plan slug to scan for references (used when references is omitted)")
+    },
+    async ({ project_path, references, plan_slug }) => {
+      try {
+        if (references?.length) {
+          const results = (0, import_pantry_resolution_service.resolveReferences)(references, project_path);
+          const resolved = results.filter((r) => r.status === "resolved").length;
+          const external = results.filter((r) => r.status === "external").length;
+          return {
+            content: [{ type: "text", text: JSON.stringify({ total: results.length, resolved, external, results }) }]
+          };
+        }
+        if (plan_slug) {
+          const scan = (0, import_pantry_resolution_service.scanPlanReferences)(project_path, plan_slug);
+          return {
+            content: [{ type: "text", text: JSON.stringify(scan) }]
+          };
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify({ error: "Provide either references[] or plan_slug to scan" }) }],
+          isError: true
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error resolving references: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "promote_to_contribution",
+    "Promote a local item to the contributions staging area (`.codetrellis/contributions/<branch>/`). The staged content travels as part of the contributor's PR for team review.",
+    {
+      project_path: import_zod.z.string().describe("Absolute path to project root"),
+      item_uid: import_zod.z.string().describe("UID of the item to promote"),
+      title: import_zod.z.string().describe("Title of the item"),
+      kind: import_zod.z.string().describe("Item kind (action, object, etc.)"),
+      status: import_zod.z.string().optional().describe("Item status"),
+      body: import_zod.z.string().optional().describe("Item body/description content"),
+      description: import_zod.z.string().optional().describe("Brief description of the contribution for reviewers"),
+      attachments: import_zod.z.array(import_zod.z.object({
+        uid: import_zod.z.string(),
+        kind: import_zod.z.string(),
+        value: import_zod.z.string(),
+        label: import_zod.z.string().optional()
+      })).optional().describe("Attachments to include with the promoted item")
+    },
+    async ({ project_path, item_uid, title, kind, status, body, description, attachments }) => {
+      try {
+        const result = (0, import_contribution_service.promoteItemToContribution)(project_path, {
+          uid: item_uid,
+          title,
+          kind,
+          status,
+          body,
+          description,
+          attachments
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            message: `Promoted "${title}" to contributions staging area`,
+            contribution: result
+          }) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error promoting to contribution: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_contributions",
+    "List items currently staged in the contributions area for the current branch. Shows what will be included in the next PR.",
+    {
+      project_path: import_zod.z.string().describe("Absolute path to project root")
+    },
+    async ({ project_path }) => {
+      try {
+        const summary = (0, import_contribution_service.listContributions)(project_path);
+        return {
+          content: [{ type: "text", text: JSON.stringify(summary) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error listing contributions: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "accept_contributions",
+    "Accept contributed items from a branch's staging area into a plan's manifest. Moves items from contributions/ into the plan, cleans up the staging area. Called after reviewing a contributor's PR.",
+    {
+      project_path: import_zod.z.string().describe("Absolute path to project root"),
+      branch: import_zod.z.string().describe("Branch name whose contributions to accept"),
+      plan_slug: import_zod.z.string().describe("Plan slug to accept contributions into")
+    },
+    async ({ project_path, branch, plan_slug }) => {
+      try {
+        const result = (0, import_contribution_service.acceptContributions)(project_path, branch, plan_slug);
+        const msg = result.errors.length > 0 ? `Accepted ${result.accepted} contributions with ${result.errors.length} error(s)` : `Accepted ${result.accepted} contributions into plan "${plan_slug}"`;
+        return {
+          content: [{ type: "text", text: JSON.stringify({ message: msg, ...result }) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error accepting contributions: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "prepare_contributor_branch",
+    "Create a filtered git branch containing only the plan content the team wants to share with an external contributor. Omits local items, team-only attachments, and private comments. The contributor can fork from this branch.",
+    {
+      project_path: import_zod.z.string().describe("Absolute path to project root"),
+      plan_slug: import_zod.z.string().describe("Plan slug to export"),
+      branch_name: import_zod.z.string().describe("Name for the new contributor branch"),
+      include_items: import_zod.z.array(import_zod.z.string()).optional().describe("Specific item UIDs to include (omit for all shared items)")
+    },
+    async ({ project_path, plan_slug, branch_name, include_items }) => {
+      try {
+        const result = (0, import_contribution_service.prepareContributorBranch)(project_path, plan_slug, branch_name, {
+          includeItems: include_items
+        });
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            message: `Created contributor branch "${branch_name}" with ${result.itemCount} shared items`,
+            ...result
+          }) }]
+        };
+      } catch (err) {
+        return {
+          content: [{ type: "text", text: `Error preparing contributor branch: ${err}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerContributionTools
+});