@rallycry/conveyor-mcp 4.3.27 → 4.3.29

package/dist/{chunk-Y6ZJUNDX.js → chunk-BKGMG2T3.js}

@@ -49,6 +49,8 @@ function enrichToolError(error, fallback) {
 var ConveyorConnection = class {
   socket = null;
   config;
+  /** project slug → id, for resolving `<project>/<card>` card paths. */
+  projectSlugIds = /* @__PURE__ */ new Map();
   constructor(config) {
     this.config = config;
   }
@@ -225,7 +227,7 @@ var ConveyorConnection = class {
   async updateTask(params) {
     const { projectId, addTags, removeTags, ...rest } = params;
     const resolvedProjectId = this.resolveProjectId(projectId);
-    const hasCoreUpdate = rest.title !== void 0 || rest.description !== void 0 || rest.plan !== void 0 || rest.status !== void 0 || rest.risk !== void 0 || rest.storyPointValue !== void 0 || rest.assignedUserId !== void 0 || rest.subProjectId !== void 0;
+    const hasCoreUpdate = rest.title !== void 0 || rest.description !== void 0 || rest.plan !== void 0 || rest.status !== void 0 || rest.risk !== void 0 || rest.storyPointValue !== void 0 || rest.assignedUserId !== void 0 || rest.subProjectId !== void 0 || rest.githubBranch !== void 0;
     const removedTags = removeTags ?? [];
     const addedTags = addTags ?? [];
     if (removedTags.length > 0) {
@@ -317,6 +319,39 @@ var ConveyorConnection = class {
     const response = await this.call("listAccessibleProjects", { pageSize: 100 });
     return this.normalizeProjectList(response);
   }
+  /**
+   * Resolve a project SLUG (as pasted in a `<project>/<card>` card path) to its
+   * id.
+   *
+   * Cached, because a slug→id mapping effectively never changes and this sits
+   * in front of an ordinary card lookup. A miss refetches once before failing,
+   * so a project created after the cache warmed still resolves.
+   *
+   * Throws naming the slug rather than falling back to the configured default
+   * project: the caller pasted a specific project, and silently answering about
+   * a different one is the worst possible outcome here.
+   */
+  async resolveProjectIdBySlug(slug) {
+    const cached = this.projectSlugIds.get(slug);
+    if (cached) return cached;
+    await this.refreshProjectSlugCache();
+    const resolved = this.projectSlugIds.get(slug);
+    if (!resolved) {
+      throw new Error(
+        `No accessible Conveyor project has the slug "${slug}". Use list_projects to see the projects this connection can reach.`
+      );
+    }
+    return resolved;
+  }
+  async refreshProjectSlugCache() {
+    for (const project of await this.listProjects()) {
+      if (typeof project !== "object" || project === null) continue;
+      const { slug, id } = project;
+      if (typeof slug === "string" && typeof id === "string") {
+        this.projectSlugIds.set(slug, id);
+      }
+    }
+  }
   // ── Build Management ────────────────────────────────────────────────
   startBuild(taskId, projectId) {
     return this.call("startProjectBuild", {
@@ -781,6 +816,50 @@ var ConveyorConnection = class {
       socket.off("pty:data", handler);
     };
   }
+  // ── Board card collection (conveyor-wait) ───────────────────────────
+  /**
+   * Fetch one page of a project's live card collection.
+   *
+   * A cursor-less call also joins the scope room, which is what starts (or
+   * restarts, after a reconnect) delta delivery. Cursor-bearing calls are pure
+   * paging and join nothing, so always lead with the cursor-less call.
+   */
+  subscribeToCardCollection(projectId, opts = {}) {
+    return this.callService("taskService", "collection:subscribe", {
+      collection: "cardsByProject",
+      scopeId: projectId,
+      cursor: opts.cursor ?? null,
+      limit: opts.limit
+    });
+  }
+  /**
+   * Listen for card collection deltas on a project scope. The event name is
+   * the room name by design — no id parsing client-side. Returns an
+   * unsubscribe function.
+   */
+  onCardDelta(projectId, handler) {
+    const socket = this.socket;
+    if (!socket) throw new Error("Not connected");
+    const event = `taskService:collection:cardsByProject:${projectId}`;
+    socket.on(event, handler);
+    return () => {
+      socket.off(event, handler);
+    };
+  }
+  /**
+   * Run `handler` on every reconnect of the underlying socket. A reconnect
+   * drops every room this socket had joined, so long-lived subscribers must
+   * re-subscribe and reconcile whatever they missed. Returns an unsubscribe
+   * function.
+   */
+  onReconnect(handler) {
+    const socket = this.socket;
+    if (!socket) throw new Error("Not connected");
+    socket.on("connect", handler);
+    return () => {
+      socket.off("connect", handler);
+    };
+  }
   // ── Connection lifecycle ────────────────────────────────────────────
   disconnect() {
     this.socket?.disconnect();
@@ -791,4 +870,3 @@ var ConveyorConnection = class {
 export {
   ConveyorConnection
 };
-//# sourceMappingURL=chunk-Y6ZJUNDX.js.map

package/dist/chunk-D3Q2QZJA.js

@@ -0,0 +1,162 @@
+// src/wait.ts
+var WAIT_CARD_TYPES = ["task", "incident", "suggestion", "chat"];
+var WAIT_SCOPES = ["mine", "unclaimed", "all"];
+var WAIT_STATUSES = [
+  "Planning",
+  "Open",
+  "InProgress",
+  "ReviewPR",
+  "ReviewDev",
+  "ReviewLive",
+  "Complete",
+  "Cancelled"
+];
+var DEFAULT_WAIT_TYPES = ["task", "incident", "suggestion"];
+var DEFAULT_WAIT_SCOPES = ["mine", "unclaimed"];
+var DEFAULT_WAIT_STATUSES = ["Open"];
+function splitList(value) {
+  return value.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+}
+function normalizeToken(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function parseWaitTypes(value) {
+  if (value === void 0) return [...DEFAULT_WAIT_TYPES];
+  const out = [];
+  for (const raw of splitList(value)) {
+    const token = normalizeToken(raw);
+    if (token === "all") return [...WAIT_CARD_TYPES];
+    const match = WAIT_CARD_TYPES.find((type) => type === token || `${type}s` === token);
+    if (!match) {
+      throw new Error(`Unknown card type "${raw}". Valid: ${WAIT_CARD_TYPES.join(", ")}, all.`);
+    }
+    if (!out.includes(match)) out.push(match);
+  }
+  if (out.length === 0) return [...DEFAULT_WAIT_TYPES];
+  return out;
+}
+function parseWaitScopes(value) {
+  if (value === void 0) return [...DEFAULT_WAIT_SCOPES];
+  const out = [];
+  for (const raw of splitList(value)) {
+    const token = normalizeToken(raw);
+    if (token === "all" || token === "any") return ["all"];
+    const match = WAIT_SCOPES.find((scope) => scope === token);
+    if (!match) {
+      throw new Error(`Unknown scope "${raw}". Valid: ${WAIT_SCOPES.join(", ")}.`);
+    }
+    if (!out.includes(match)) out.push(match);
+  }
+  if (out.length === 0) return [...DEFAULT_WAIT_SCOPES];
+  return out;
+}
+function parseWaitStatuses(value) {
+  if (value === void 0) return [...DEFAULT_WAIT_STATUSES];
+  const out = [];
+  for (const raw of splitList(value)) {
+    const token = normalizeToken(raw);
+    if (token === "all" || token === "any") return [...WAIT_STATUSES];
+    const match = WAIT_STATUSES.find((status) => normalizeToken(status) === token);
+    if (!match) {
+      throw new Error(`Unknown status "${raw}". Valid: ${WAIT_STATUSES.join(", ")}, all.`);
+    }
+    if (!out.includes(match)) out.push(match);
+  }
+  if (out.length === 0) return [...DEFAULT_WAIT_STATUSES];
+  return out;
+}
+function toWaitCard(item) {
+  return {
+    id: item.id,
+    slug: item.slug ?? null,
+    title: item.title ?? null,
+    type: item.type ?? null,
+    status: item.status ?? null,
+    assignedUserId: item.assignedUser?.id ?? null
+  };
+}
+function matchesFilter(card, filter) {
+  const type = card.type ?? "task";
+  if (!filter.types.includes(type)) return false;
+  if (card.status === null || !filter.statuses.includes(card.status)) return false;
+  return matchesScope(card, filter);
+}
+function matchesScope(card, filter) {
+  if (filter.scopes.includes("all")) return true;
+  if (filter.scopes.includes("unclaimed") && card.assignedUserId === null) return true;
+  if (filter.scopes.includes("mine") && filter.userId !== null && card.assignedUserId === filter.userId) {
+    return true;
+  }
+  return false;
+}
+var MatchSet = class {
+  constructor(filter) {
+    this.filter = filter;
+  }
+  filter;
+  matched = /* @__PURE__ */ new Set();
+  get size() {
+    return this.matched.size;
+  }
+  has(id) {
+    return this.matched.has(id);
+  }
+  /** Seed from the first snapshot. Pre-existing matches never trigger. */
+  seed(cards) {
+    this.matched.clear();
+    for (const card of cards) {
+      if (matchesFilter(card, this.filter)) this.matched.add(card.id);
+    }
+  }
+  /**
+   * Re-seed after a `reset` delta or a reconnect gap, returning every card
+   * that entered matching state while we were not listening.
+   *
+   * `complete` says whether the snapshot walk reached the end of the scope.
+   * When it did not, ids we no longer see are merged forward rather than
+   * dropped — forgetting a still-matching card would re-report it as new on
+   * its next delta.
+   */
+  reseed(cards, complete = true) {
+    const triggers = [];
+    const next = new Set(complete ? [] : this.matched);
+    for (const card of cards) {
+      if (!matchesFilter(card, this.filter)) continue;
+      next.add(card.id);
+      if (!this.matched.has(card.id)) triggers.push(card);
+    }
+    this.matched.clear();
+    for (const id of next) this.matched.add(id);
+    return triggers;
+  }
+  /** Apply an `added`/`updated` delta. Returns the card only on entry. */
+  upsert(card) {
+    const matches = matchesFilter(card, this.filter);
+    const held = this.matched.has(card.id);
+    if (matches && !held) {
+      this.matched.add(card.id);
+      return card;
+    }
+    if (!matches && held) this.matched.delete(card.id);
+    return null;
+  }
+  /** Apply a `removed` delta. A deleted card is never new work. */
+  remove(id) {
+    this.matched.delete(id);
+  }
+};
+
+export {
+  WAIT_CARD_TYPES,
+  WAIT_SCOPES,
+  WAIT_STATUSES,
+  DEFAULT_WAIT_TYPES,
+  DEFAULT_WAIT_SCOPES,
+  DEFAULT_WAIT_STATUSES,
+  parseWaitTypes,
+  parseWaitScopes,
+  parseWaitStatuses,
+  toWaitCard,
+  matchesFilter,
+  MatchSet
+};

package/dist/{chunk-N2XC2PGJ.js → chunk-HIVOGGE3.js}

@@ -116,4 +116,3 @@ export {
   attachTunnel,
   runTunnel
 };
-//# sourceMappingURL=chunk-N2XC2PGJ.js.map

package/dist/chunk-OPZL4NDT.js

@@ -0,0 +1,175 @@
+import {
+  MatchSet,
+  toWaitCard
+} from "./chunk-D3Q2QZJA.js";
+
+// src/wait-runner.ts
+var SNAPSHOT_PAGE_LIMIT = 500;
+var SNAPSHOT_MAX_PAGES = 20;
+var RESYNC_ATTEMPTS = 4;
+var RESYNC_RETRY_DELAY_MS = 3e3;
+var WaitSession = class {
+  constructor(options) {
+    this.options = options;
+    this.tracker = new MatchSet(options.filter);
+  }
+  options;
+  tracker;
+  /**
+   * Deltas that land before (or during) a snapshot are held, then replayed
+   * against the freshly seeded set. Replaying an already-matching card is a
+   * no-op, so the overlap is safe.
+   */
+  buffered = [];
+  seeded = false;
+  done = false;
+  offDelta;
+  offReconnect;
+  timer;
+  /** Serializes snapshots: a reset arriving mid-resync queues, it does not race. */
+  chain = Promise.resolve();
+  settle;
+  abort;
+  run() {
+    return new Promise((resolve, reject) => {
+      const { source, projectId, timeoutMs, log = () => {
+      } } = this.options;
+      this.settle = resolve;
+      this.abort = reject;
+      this.offDelta = source.onCardDelta(projectId, (delta) => this.applyDelta(delta));
+      this.offReconnect = source.onReconnect(() => {
+        log("Reconnected \u2014 re-snapshotting the board scope.");
+        this.schedule(false);
+      });
+      this.timer = setTimeout(() => this.finish({ reason: "timeout" }), timeoutMs);
+      this.schedule(true);
+    });
+  }
+  teardown() {
+    this.done = true;
+    if (this.timer !== void 0) clearTimeout(this.timer);
+    this.offDelta?.();
+    this.offReconnect?.();
+  }
+  finish(result) {
+    if (this.done) return;
+    this.teardown();
+    this.settle?.(result);
+  }
+  fail(error) {
+    if (this.done) return;
+    this.teardown();
+    this.abort?.(error instanceof Error ? error : new Error(String(error)));
+  }
+  schedule(initial) {
+    this.chain = this.chain.then(() => initial ? this.seedOrResync(true) : this.resyncWithRetry()).catch((err) => this.fail(err));
+  }
+  /**
+   * Re-snapshot after a reset or a reconnect, retrying a transient failure.
+   *
+   * Giving up here is not a soft failure: deltas buffer while the session is
+   * unseeded, so an abandoned resync would leave the wait deaf until its
+   * deadline. Rethrow only once every attempt is spent. The initial seed stays
+   * fatal by contrast — that failure means a bad project id or revoked access.
+   */
+  async resyncWithRetry() {
+    const { resyncRetryDelayMs = RESYNC_RETRY_DELAY_MS, log } = this.options;
+    for (let attempt = 1; attempt <= RESYNC_ATTEMPTS; attempt++) {
+      if (this.done) return;
+      try {
+        await this.seedOrResync(false);
+        return;
+      } catch (err) {
+        if (attempt === RESYNC_ATTEMPTS) throw err;
+        const message = err instanceof Error ? err.message : String(err);
+        log?.(
+          `Re-snapshot attempt ${attempt} failed (${message}) \u2014 retrying in ${Math.round(resyncRetryDelayMs / 1e3)}s.`
+        );
+        await this.delay(resyncRetryDelayMs);
+      }
+    }
+  }
+  /** A sleep that never holds the process open past the wait itself. */
+  delay(ms) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(resolve, ms);
+      timer.unref?.();
+    });
+  }
+  applyDelta(delta) {
+    if (this.done) return;
+    if (!this.seeded) {
+      this.buffered.push(delta);
+      return;
+    }
+    switch (delta.type) {
+      case "added":
+      case "updated": {
+        const entered = this.tracker.upsert(toWaitCard(delta.item));
+        if (entered) this.finish({ reason: "event", card: entered });
+        break;
+      }
+      case "removed":
+        this.tracker.remove(delta.id);
+        break;
+      case "reset":
+        this.options.log?.("Board scope reset \u2014 re-snapshotting.");
+        this.schedule(false);
+        break;
+    }
+  }
+  /** Walk the scope to the end, or until the page cap stops us. */
+  async snapshotAll() {
+    const {
+      source,
+      projectId,
+      pageLimit = SNAPSHOT_PAGE_LIMIT,
+      maxPages = SNAPSHOT_MAX_PAGES
+    } = this.options;
+    const cards = [];
+    let cursor = null;
+    let complete = false;
+    for (let page = 0; page < maxPages; page++) {
+      const result = await source.subscribeToCardCollection(projectId, {
+        cursor,
+        limit: pageLimit
+      });
+      for (const item of result.items ?? []) cards.push(toWaitCard(item));
+      cursor = result.nextCursor ?? null;
+      if (cursor === null) {
+        complete = true;
+        break;
+      }
+    }
+    return { cards, complete };
+  }
+  async seedOrResync(initial) {
+    this.seeded = false;
+    const { cards, complete } = await this.snapshotAll();
+    if (this.done) return;
+    if (initial) {
+      this.tracker.seed(cards);
+      this.options.log?.(
+        `Watching ${cards.length} card(s) \u2014 ${this.tracker.size} already match; waiting for new work.`
+      );
+    } else {
+      const triggers = this.tracker.reseed(cards, complete);
+      if (triggers.length > 0) {
+        this.finish({ reason: "event", card: triggers[0] });
+        return;
+      }
+    }
+    this.seeded = true;
+    for (const delta of this.buffered.splice(0)) {
+      if (this.done) return;
+      this.applyDelta(delta);
+    }
+  }
+};
+function runWait(options) {
+  return new WaitSession(options).run();
+}
+
+export {
+  runWait
+};

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ConveyorConnection
-} from "./chunk-Y6ZJUNDX.js";
+} from "./chunk-BKGMG2T3.js";
 
 // src/cli.ts
 import { createRequire } from "module";
@@ -215,7 +215,10 @@ var getTaskContract = defineToolContract({
     fields: {
       projectId: mcpProjectId,
       taskId: f.string({
-        desc: "The task ID or slug (the value in a card URL, /cards/<slug>)"
+        // The path form is MCP-only on purpose: an in-pod agent is bound to one
+        // project, where a bare slug already resolves, so the `agent` half of
+        // this contract deliberately says nothing about it.
+        desc: "The task ID or slug (the value in a card URL, /cards/<slug>), or a path-form reference '<project-slug>/<card-slug>' from the board's Copy path action"
       })
     }
   }
@@ -393,13 +396,13 @@ var tagRef = f.string({
 var getTagContract = defineToolContract({
   name: "get_tag",
   agent: {
-    description: "Read one tag's full glossary entry: description, the full markdown overview (the term's spec \u2014 philosophy, mechanics, invariants), linked files/rules (each with its verified-link status \u2014 ok/stale/unchecked \u2014 from the periodic repo check), parent/child tags, active-card count, attachment count (files labelled as examples of the term), and recent revisions with their reasons. Call this whenever a chat message, plan, or tag list points at a term you need the full context for. A response with `overviewPath` set means the overview is sourced from that repo file \u2014 prefer Reading the path from your checkout (branch-correct); the served overview is the base-branch materialization (`overviewSource.state`: ok/pending/stale).",
+    description: "Read one tag's full glossary entry: description, the full markdown overview (the term's spec \u2014 philosophy, mechanics, invariants), linked files/rules (each with its verified-link status \u2014 ok/stale/unchecked \u2014 from the periodic repo check), parent/child tags, active-card count, attachment count (files labelled as examples of the term), and recent revisions with their reasons. Call this whenever a chat message, plan, or tag list points at a term you need the full context for. A response with `overviewPath` set means the overview is sourced from that repo file \u2014 prefer Reading the path from your checkout (branch-correct); the served overview is materialized from the project's dev branch (the PR base; default branch when the repo has no dev branch) (`overviewSource.state`: ok/pending/stale).",
     fields: {
       tag: tagRef
     }
   },
   mcp: {
-    description: "Read one tag's full glossary entry \u2014 description, markdown overview, context links (each with its verified-link status: ok/stale/unchecked plus last-checked provenance), parent/child tags, active-card count, attachment count (files labelled as examples of the term \u2014 read the tiles with list_tag_attachments), and recent revisions with provenance. A response with `overviewPath` set means the overview is sourced from that repo file at the base branch (`overviewSource.state`: ok/pending/stale) \u2014 clients with a checkout can read the path directly for the branch-correct copy. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    description: "Read one tag's full glossary entry \u2014 description, markdown overview, context links (each with its verified-link status: ok/stale/unchecked plus last-checked provenance), parent/child tags, active-card count, attachment count (files labelled as examples of the term \u2014 read the tiles with list_tag_attachments), and recent revisions with provenance. A response with `overviewPath` set means the overview is sourced from that repo file at the project's dev branch (the PR base; default branch when the repo has no dev branch) (`overviewSource.state`: ok/pending/stale) \u2014 clients with a checkout can read the path directly for the branch-correct copy. Pass projectId to target a specific project; otherwise the configured default project is used.",
     fields: {
       projectId: mcpProjectId,
       tag: tagRef
@@ -632,10 +635,11 @@ var MCP_STATUS_ENUM = [
   "Complete",
   "Cancelled"
 ];
+var AGENT_TAGS = `Glossary tag names to label the child with, e.g. ["agent", "pack"]. Names, not ids, matched case-insensitively against this project's tags (use list_tags to see them). A name that matches nothing comes back in the result and never fails the create.`;
 var createSubtaskContract = defineToolContract({
   name: "create_subtask",
   agent: {
-    description: "Create a subtask under the current parent task. Use when breaking a complex parent into smaller pieces during planning. For post-task follow-ups use create_follow_up_task.",
+    description: "Create a subtask (a child card) under the CURRENT card. This is how a card becomes a pack: the first child turns this card into the pack parent, and the children build as one unit. Use when breaking the current card into smaller pieces during planning. For a sibling card that lands after this one merges, use create_follow_up_task.",
     fields: {
       title: f.string({ desc: "Subtask title" }),
       description: f.optional(f.string({ desc: cardDescriptionDesc("Brief description") })),
@@ -643,7 +647,8 @@ var createSubtaskContract = defineToolContract({
       ordinal: f.optional(f.number({ desc: "Step/order number (0-based)" })),
       storyPointValue: f.optional(f.number({ desc: SP_DESCRIPTION })),
       followParentStatus: f.optional(f.boolean({ desc: AGENT_FOLLOW_PARENT_STATUS })),
-      dependsOn: f.optional(f.array(f.string(), { desc: AGENT_DEPENDS_ON }))
+      dependsOn: f.optional(f.array(f.string(), { desc: AGENT_DEPENDS_ON })),
+      tags: f.optional(f.array(f.string(), { desc: AGENT_TAGS }))
     }
   },
   mcp: {
@@ -1335,12 +1340,26 @@ function registerListTasks(server2, conn2) {
     }
   );
 }
+function splitCardRef(ref) {
+  const slash = ref.indexOf("/");
+  if (slash <= 0) return { cardSlug: ref };
+  const projectSlug = ref.slice(0, slash);
+  const cardSlug = ref.slice(slash + 1);
+  if (!cardSlug) return { cardSlug: ref };
+  return { projectSlug, cardSlug };
+}
+async function resolveCardRef(conn2, ref, projectId2) {
+  const { projectSlug, cardSlug } = splitCardRef(ref);
+  if (!projectSlug) return { cardSlug, projectId: projectId2 };
+  return { cardSlug, projectId: await conn2.resolveProjectIdBySlug(projectSlug) };
+}
 function registerGetTask(server2, conn2) {
   registerContractTool(
     server2,
     getTaskContract,
     async (params) => {
-      const task = await conn2.getTask(params.taskId, params.projectId);
+      const ref = await resolveCardRef(conn2, params.taskId, params.projectId);
+      const task = await conn2.getTask(ref.cardSlug, ref.projectId);
       return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
     },
     { alwaysLoad: true }
@@ -1349,13 +1368,16 @@ function registerGetTask(server2, conn2) {
 function registerGetCardBySlug(server2, conn2) {
   server2.tool(
     "get_card_by_slug",
-    "Get full card details by the slug from a card URL (/cards/<slug>) instead of a task ID. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    'Get full card details by the slug from a card URL (/cards/<slug>) instead of a task ID. Also accepts the board\'s "Copy path" form, `<project-slug>/<card-slug>` \u2014 an embedded project slug wins over projectId and over the configured default. Pass projectId to target a specific project; otherwise the configured default project is used.',
     {
       projectId: z5.string().optional().describe("Target Conveyor project ID"),
-      slug: z5.string().describe("The card slug from a Conveyor card URL, e.g. 'ship-it'")
+      slug: z5.string().describe(
+        "The card slug from a Conveyor card URL, e.g. 'ship-it', or a path-form reference 'my-project/ship-it' (the board's Copy path action)"
+      )
     },
     async (params) => {
-      const task = await conn2.getCardBySlug(params.slug, params.projectId);
+      const ref = await resolveCardRef(conn2, params.slug, params.projectId);
+      const task = await conn2.getCardBySlug(ref.cardSlug, ref.projectId);
       return { content: [{ type: "text", text: JSON.stringify(task, null, 2) }] };
     }
   );
@@ -1391,7 +1413,7 @@ function registerCreateTask(server2, conn2) {
 function registerUpdateTask(server2, conn2) {
   server2.tool(
     "update_task",
-    "Update task fields: title, description, plan, status, risk, story points, assignment, or tags. Set status to claim a card (InProgress), triage it (Open), or cancel it (Cancelled); for review approvals prefer approve_task / request_changes, which guard against stale-state races. Tags are additive/subtractive \u2014 pass addTags/removeTags with tag names (not a replace-set). Pass projectId to target a specific project; otherwise the configured default project is used. Moving a task beyond Planning auto-fills any missing icon, story points, and agent assignment \u2014 don't spend turns on them; pass storyPointValue only to correct the sizing yourself. For subtasks use update_subtask.",
+    "Update task fields: title, description, plan, status, risk, story points, assignment, githubBranch, or tags. Set status to claim a card (InProgress), triage it (Open), or cancel it (Cancelled); for review approvals prefer approve_task / request_changes, which guard against stale-state races. Tags are additive/subtractive \u2014 pass addTags/removeTags with tag names (not a replace-set). Pass projectId to target a specific project; otherwise the configured default project is used. Moving a task beyond Planning auto-fills any missing icon, story points, and agent assignment \u2014 don't spend turns on them; pass storyPointValue only to correct the sizing yourself. For subtasks use update_subtask.",
     {
       projectId: z5.string().optional().describe("Target Conveyor project ID"),
       taskId: z5.string().describe("The task ID"),
@@ -1409,6 +1431,9 @@ function registerUpdateTask(server2, conn2) {
       subProjectId: z5.string().nullable().optional().describe(
         "Assign the task to a sub-project board; null moves it back to the parent board. Omit to leave unchanged."
       ),
+      githubBranch: z5.string().nullable().optional().describe(
+        "Record the task's ACTUAL working branch (e.g. a locally-driven pack's branch cut at claim time, so identification never mints a competing name and pack-child merges settle against reality), or null to detach. The branch must already exist on origin, and a live workspace bound to a different branch rejects the write."
+      ),
       addTags: z5.array(z5.string()).optional().describe(
         'Tag names to add to the card (e.g. ["refactor"]). Additive \u2014 existing tags are kept. Unknown names are rejected; use list_tags to see available tags or manage_tags to create one.'
       ),
@@ -1757,6 +1782,8 @@ var MIME_BY_EXT = {
   ".txt": "text/plain",
   ".log": "text/plain",
   ".md": "text/markdown",
+  ".mmd": "text/vnd.mermaid",
+  ".mermaid": "text/vnd.mermaid",
   ".csv": "text/csv",
   ".html": "text/html",
   ".css": "text/css",
@@ -2589,4 +2616,3 @@ process.on("SIGTERM", () => {
   conn.disconnect();
   process.exit(0);
 });
-//# sourceMappingURL=cli.js.map