@rallycry/conveyor-mcp 4.3.28 → 4.3.30

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/{chunk-Y6ZJUNDX.js → chunk-X3EHPZNH.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", {
@@ -580,6 +615,18 @@ var ConveyorConnection = class {
     }
     return result;
   }
+  /**
+   * Move a card under a new parent, or detach it with an explicit null.
+   * `parentTaskId` rides the rest-spread rather than a conditional one so a
+   * null survives the call — stripping it would silently no-op a detach.
+   */
+  setTaskParent(params) {
+    const { projectId, ...rest } = params;
+    return this.call("setProjectTaskParent", {
+      projectId: this.resolveProjectId(projectId),
+      ...rest
+    });
+  }
   updateSubtask(params) {
     const { projectId, ...rest } = params;
     return this.call("updateProjectSubtask", {
@@ -781,6 +828,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 +882,3 @@ var ConveyorConnection = class {
 export {
   ConveyorConnection
 };
-//# sourceMappingURL=chunk-Y6ZJUNDX.js.map

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ConveyorConnection
-} from "./chunk-Y6ZJUNDX.js";
+} from "./chunk-X3EHPZNH.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"
       })
     }
   }
@@ -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: {
@@ -755,11 +760,46 @@ var listSubtasksContract = defineToolContract({
     }
   }
 });
+var SET_PARENT_ORDINAL = "Position among the new parent's children. Defaults to after every existing sibling. A detached card has no siblings to order against, so it only matters when you adopt.";
+var SET_PARENT_WARNINGS = "The move is reported, never refused: a card that already has a pull request, live compute, a release, children of its own, or dependency edges that now cross packs comes back with a warning in the result. Its branch is NOT re-cut against the new parent's feature branch.";
+var setTaskParentContract = defineToolContract({
+  name: "set_task_parent",
+  agent: {
+    description: `Adopt an EXISTING card into this card's pack, or eject one of this card's children. The card keeps its own chat, plan, and history \u2014 it moves under (or out from) the current card, inherits the board, and lands after the current children. To make a NEW child use create_subtask instead. ${SET_PARENT_WARNINGS}`,
+    fields: {
+      taskId: f.string({
+        desc: "Id, slug, or branch name of the card to move. Must live in this project."
+      }),
+      detach: f.optional(
+        f.boolean({
+          desc: "Eject the card from this pack instead of adopting it \u2014 it becomes a standalone card and stops following the parent's status. The card must already be a child of the current card."
+        })
+      ),
+      ordinal: f.optional(f.number({ desc: SET_PARENT_ORDINAL })),
+      followParentStatus: f.optional(f.boolean({ desc: AGENT_FOLLOW_PARENT_STATUS }))
+    }
+  },
+  mcp: {
+    description: `Re-parent an existing card: pass a parentTaskId to adopt it into that card's pack, or null to detach it into a standalone card. The card keeps its chat, plan, and history; adopting also moves it to the parent's board and orders it after the parent's existing children. Use create_subtask for a NEW child, and move_card to move a card to another PROJECT. Pass projectId to target a specific project; otherwise the configured default project is used. ${SET_PARENT_WARNINGS}`,
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "Id or slug of the card to move" }),
+      parentTaskId: f.nullable(
+        f.string({
+          desc: "Id or slug of the new parent, or null to detach the card from its current parent. Must be in the same project, and can be neither the card itself nor one of its own descendants."
+        })
+      ),
+      ordinal: f.optional(f.number({ desc: SET_PARENT_ORDINAL })),
+      followParentStatus: f.optional(f.boolean({ desc: MCP_FOLLOW_PARENT_STATUS }))
+    }
+  }
+});
 var subtasksContracts = [
   createSubtaskContract,
   updateSubtaskContract,
   deleteSubtaskContract,
-  listSubtasksContract
+  listSubtasksContract,
+  setTaskParentContract
 ];
 var mcpTaskIdOrSlug = f.string({ desc: "The task ID or slug" });
 var listTaskFilesContract = defineToolContract({
@@ -1335,12 +1375,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 +1403,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 +1448,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 +1466,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.'
       ),
@@ -1964,11 +2024,28 @@ function registerDeleteSubtask(server2, conn2) {
     };
   });
 }
+function registerSetTaskParent(server2, conn2) {
+  registerContractTool(server2, setTaskParentContract, async (params) => {
+    const result = await conn2.setTaskParent(params);
+    const from = result.previousParentTaskId ?? "none";
+    const to = result.parentSlug ?? result.parentTaskId ?? "none";
+    const warnings = result.warnings.length > 0 ? ` Warnings: ${result.warnings.join(", ")}.` : "";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Card ${result.slug} re-parented: ${from} -> ${to} (status: ${result.status}).${warnings}`
+        }
+      ]
+    };
+  });
+}
 function registerSubtaskTools(server2, conn2) {
   registerCreateSubtask(server2, conn2);
   registerUpdateSubtask(server2, conn2);
   registerListSubtasks(server2, conn2);
   registerDeleteSubtask(server2, conn2);
+  registerSetTaskParent(server2, conn2);
 }
 
 // src/tools/dependencies.ts
@@ -2591,4 +2668,3 @@ process.on("SIGTERM", () => {
   conn.disconnect();
   process.exit(0);
 });
-//# sourceMappingURL=cli.js.map