@rallycry/conveyor-mcp 5.0.17 → 5.0.18

package/dist/{chunk-IRVUONC3.js → chunk-BOAMGYLU.js}

@@ -1,4 +1,4 @@
-// ../shared/dist/chunk-SFSQ7NKP.js
+// ../shared/dist/chunk-RSAY7FNH.js
 import { z } from "zod";
 import { z as z2 } from "zod";
 var DEFAULT_SONNET_MODEL = "claude-sonnet-5-5";
@@ -500,9 +500,9 @@ var searchFilterFields = {
       desc: "Only return cards with no assignee (mutually exclusive with assigneeId)"
     })
   ),
-  limit: f.optional(f.number({ desc: "Max results to return (default 20)" }))
+  limit: f.optional(f.number({ desc: "Max results to return (default 20, at most 200)" }))
 };
-var searchResultNote = "Every result lists the tags it carries, so you can see why it matched. Results are relevance-ordered: highest priority first then newest; suggestions-only queries rank by upvote score. Returns summaries \u2014 plan omitted, description truncated; use get_task for full details.";
+var searchResultNote = "Every result lists the tags it carries, so you can see why it matched. Searches every status, Complete and Cancelled included, unless statusFilters narrows it. Returns at most 200 results. Results are relevance-ordered: highest priority first then newest; suggestions-only queries rank by upvote score. Returns summaries \u2014 plan omitted, description truncated; use get_task for full details.";
 var searchTasksContract = defineToolContract({
   name: "search_tasks",
   agent: {

package/dist/{chunk-OPZL4NDT.js → chunk-J7LQ5DAT.js}

@@ -4,10 +4,26 @@ import {
 } from "./chunk-D3Q2QZJA.js";
 
 // src/wait-runner.ts
+var STATE_PAGE_LIMIT = 1e3;
+var STATE_MAX_PAGES = 50;
 var SNAPSHOT_PAGE_LIMIT = 500;
 var SNAPSHOT_MAX_PAGES = 20;
 var RESYNC_ATTEMPTS = 4;
 var RESYNC_RETRY_DELAY_MS = 3e3;
+function isLeanSeedUnsupported(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /^Request timed out: listCardStates$|^Validation error|unknown method/i.test(message);
+}
+function toWaitCardFromState(row) {
+  return {
+    id: row.id,
+    slug: row.slug ?? null,
+    title: row.title ?? null,
+    type: row.type ?? null,
+    status: row.status ?? null,
+    assignedUserId: row.assignedUserId ?? null
+  };
+}
 var WaitSession = class {
   constructor(options) {
     this.options = options;
@@ -23,6 +39,14 @@ var WaitSession = class {
   buffered = [];
   seeded = false;
   done = false;
+  /** Flips off once the API shows it lacks `listCardStates`. */
+  leanSeed = true;
+  /**
+   * Set once a `listCardStates` call has answered. From then on the method
+   * exists, so a failure is transient and goes to the resync retry — it never
+   * downgrades the session to the walk.
+   */
+  leanSeedConfirmed = false;
   offDelta;
   offReconnect;
   timer;
@@ -118,8 +142,57 @@ var WaitSession = class {
         break;
     }
   }
-  /** Walk the scope to the end, or until the page cap stops us. */
+  /** The lean seed while the API has `listCardStates`, else the collection walk. */
   async snapshotAll() {
+    if (this.leanSeed) {
+      const lean = await this.leanSnapshot();
+      if (lean) return lean;
+    }
+    if (this.done) return { cards: [], complete: false, pages: 0 };
+    return this.walkCollection();
+  }
+  fetchStates(cursor) {
+    const { source, projectId, filter, statePageLimit = STATE_PAGE_LIMIT } = this.options;
+    return source.listCardStates(projectId, {
+      statuses: filter.statuses,
+      types: filter.types,
+      cursor,
+      limit: statePageLimit
+    });
+  }
+  /**
+   * Join the scope room, then page the cards in the watched statuses and
+   * types. Returns null when the first `listCardStates` call of the session
+   * fails the way an older API does: the session then walks the collection
+   * for the rest of its life.
+   */
+  async leanSnapshot() {
+    const { source, projectId, stateMaxPages = STATE_MAX_PAGES, log } = this.options;
+    await source.subscribeToCardCollection(projectId, { limit: 1 });
+    let page;
+    try {
+      page = await this.fetchStates(null);
+    } catch (error) {
+      if (this.leanSeedConfirmed || !isLeanSeedUnsupported(error)) throw error;
+      this.leanSeed = false;
+      if (!this.done) {
+        const message = error instanceof Error ? error.message : String(error);
+        log?.(`listCardStates did not answer (${message}) \u2014 walking the board instead.`);
+      }
+      return null;
+    }
+    this.leanSeedConfirmed = true;
+    const cards = page.items.map(toWaitCardFromState);
+    let pages = 1;
+    while (page.nextCursor !== null && pages < stateMaxPages) {
+      page = await this.fetchStates(page.nextCursor);
+      pages++;
+      cards.push(...page.items.map(toWaitCardFromState));
+    }
+    return { cards, complete: page.nextCursor === null, pages };
+  }
+  /** The fallback: walk the collection to the end, or until the page cap stops us. */
+  async walkCollection() {
     const {
       source,
       projectId,
@@ -129,11 +202,13 @@ var WaitSession = class {
     const cards = [];
     let cursor = null;
     let complete = false;
-    for (let page = 0; page < maxPages; page++) {
+    let pages = 0;
+    while (pages < maxPages) {
       const result = await source.subscribeToCardCollection(projectId, {
         cursor,
         limit: pageLimit
       });
+      pages++;
       for (const item of result.items ?? []) cards.push(toWaitCard(item));
       cursor = result.nextCursor ?? null;
       if (cursor === null) {
@@ -141,16 +216,16 @@ var WaitSession = class {
         break;
       }
     }
-    return { cards, complete };
+    return { cards, complete, pages };
   }
   async seedOrResync(initial) {
     this.seeded = false;
-    const { cards, complete } = await this.snapshotAll();
+    const { cards, complete, pages } = 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.`
+        `Seeded ${cards.length} card(s) from ${pages} page(s) \u2014 ${this.tracker.size} already match; waiting for new work.`
       );
     } else {
       const triggers = this.tracker.reseed(cards, complete);

package/dist/{chunk-6JLKJUYV.js → chunk-XLNIBIX4.js}

@@ -1104,6 +1104,20 @@ var ConveyorConnection = class {
       limit: opts.limit
     });
   }
+  /**
+   * A lean, status-filtered page of a project's cards, ordered by id — the
+   * conveyor-wait seed. An API from before this method never acks the call,
+   * so callers on an older server see a timeout (see `wait-runner.ts`).
+   */
+  listCardStates(projectId, opts) {
+    return this.call("listCardStates", {
+      projectId,
+      statuses: opts.statuses,
+      types: opts.types,
+      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

package/dist/cli.js

@@ -81,13 +81,13 @@ import {
   uploadAttachmentContract,
   uploadSiteAssetsContract,
   voteDecisionContract
-} from "./chunk-IRVUONC3.js";
+} from "./chunk-BOAMGYLU.js";
 import {
   installLifecycle
 } from "./chunk-5KU3QS6A.js";
 import {
   ConveyorConnection
-} from "./chunk-6JLKJUYV.js";
+} from "./chunk-XLNIBIX4.js";
 
 // src/cli.ts
 import { createRequire } from "module";
@@ -552,7 +552,7 @@ function summarizeTask(task) {
   const { plan, description, ...rest } = task;
   const summary = { ...rest };
   summary.description = typeof description === "string" && description.length > DESCRIPTION_PREVIEW_CHARS ? `${description.slice(0, DESCRIPTION_PREVIEW_CHARS)}\u2026 [truncated \u2014 use get_task for the full description]` : description ?? null;
-  summary.hasPlan = typeof plan === "string" && plan.length > 0;
+  summary.hasPlan = typeof plan === "string" ? plan.length > 0 : rest.hasPlan === true;
   return summary;
 }
 
@@ -579,10 +579,10 @@ function registerListTasks(server2, conn2) {
   registerHotTool(
     server2,
     "list_tasks",
-    "List project cards, optionally filtered by card type, status, or assignment (a specific assignee, or unassigned tasks). Defaults to type=task \u2014 pass typeFilters to list incidents, suggestions or decisions. Results are relevance-ordered: highest priority first then newest; suggestions-only queries rank by upvote score. Pass projectId to target a specific project; otherwise the configured default project is used. Returns summaries \u2014 plan omitted, description truncated; use get_task for full details.",
+    "List project cards, optionally filtered by card type, status, or assignment (a specific assignee, or unassigned tasks). Defaults to type=task \u2014 pass typeFilters to list incidents, suggestions or decisions. Without a status, Complete and Cancelled cards are left out \u2014 pass status to list one of them, or use search_tasks, which covers every status. Returns at most 200 cards. Results are relevance-ordered: highest priority first then newest; suggestions-only queries rank by upvote score. Pass projectId to target a specific project; otherwise the configured default project is used. Returns summaries \u2014 plan omitted, description truncated; use get_task for full details.",
     {
       projectId: z5.string().optional().describe("Target Conveyor project ID"),
-      status: z5.enum(STATUS_ENUM).optional().describe("Filter by task status"),
+      status: z5.enum(STATUS_ENUM).optional().describe("Filter by task status. Omit for every status except Complete and Cancelled."),
       typeFilters: z5.array(z5.enum(CARD_TYPE_ENUM)).optional().describe(
         'Card types to include, e.g. ["incident"] or ["task", "incident"]. Omit for tasks only.'
       ),
@@ -590,7 +590,7 @@ function registerListTasks(server2, conn2) {
       unassigned: z5.boolean().optional().describe("Only return tasks with no assignee (mutually exclusive with assigneeId)"),
       subProjectId: BOARD_FILTER,
       onHold: z5.boolean().optional().describe("true = only cards on hold, false = exclude them, omit = both"),
-      limit: z5.number().optional().describe("Max tasks to return (default 50)")
+      limit: z5.number().optional().describe("Max tasks to return (default 50, at most 200)")
     },
     async (params) => {
       const tasks = await conn2.listTasks(params);
@@ -2272,6 +2272,13 @@ var ListProjectTasksRequestSchema = z72.object({
 }).refine((p) => !(p.unassigned && p.assigneeId), {
   message: "Pass either assigneeId or unassigned, not both"
 });
+var ListCardStatesRequestSchema = z72.object({
+  projectId: z72.string(),
+  statuses: z72.array(z72.string()).min(1).max(32),
+  types: z72.array(z72.string()).optional(),
+  cursor: z72.string().nullable().optional(),
+  limit: z72.number().int().positive().optional().default(500)
+});
 var GetProjectTaskRequestSchema = z72.object({
   projectId: z72.string(),
   taskId: z72.string()

package/dist/{connection-Ctg-QM1s.d.ts → connection-C2qTFync.d.ts}

@@ -130,6 +130,23 @@ interface CardCollectionPage {
     nextCursor: string | null;
     totalCount: number;
 }
+/**
+ * One `listCardStates` row: the six fields conveyor-wait filters on and
+ * prints, with a flat assignee id. Mirrors `CardStateDTO` in @project/shared.
+ */
+interface CardStateRow {
+    id: string;
+    slug: string | null;
+    title: string | null;
+    type: string | null;
+    status: string | null;
+    assignedUserId: string | null;
+}
+/** One page of `listCardStates`, ordered by id. */
+interface CardStatePage {
+    items: CardStateRow[];
+    nextCursor: string | null;
+}
 /**
  * A quickdraw collection change on a card scope. `added` vs `updated` is
  * cosmetic — most card writes go through a hand-rolled upsert that always
@@ -1099,6 +1116,17 @@ declare class ConveyorConnection {
         cursor?: string | null;
         limit?: number;
     }): Promise<CardCollectionPage>;
+    /**
+     * A lean, status-filtered page of a project's cards, ordered by id — the
+     * conveyor-wait seed. An API from before this method never acks the call,
+     * so callers on an older server see a timeout (see `wait-runner.ts`).
+     */
+    listCardStates(projectId: string, opts: {
+        statuses: string[];
+        types?: string[];
+        cursor?: string | null;
+        limit?: number;
+    }): Promise<CardStatePage>;
     /**
      * 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
@@ -1115,4 +1143,4 @@ declare class ConveyorConnection {
     disconnect(): void;
 }
 
-export { type ActivePtySession as A, type CardCollectionPage as C, type PtyAttachSnapshot as P, type CardCollectionDelta as a, type CardCollectionItem as b, type PtyDataChunk as c, ConveyorConnection as d, type ConveyorMcpConfig as e };
+export { type ActivePtySession as A, type CardCollectionPage as C, type PtyAttachSnapshot as P, type CardStatePage as a, type CardCollectionDelta as b, type CardCollectionItem as c, type PtyDataChunk as d, ConveyorConnection as e, type ConveyorMcpConfig as f };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { A as ActivePtySession, d as ConveyorConnection, e as ConveyorMcpConfig, P as PtyAttachSnapshot, c as PtyDataChunk } from './connection-Ctg-QM1s.js';
+export { A as ActivePtySession, e as ConveyorConnection, f as ConveyorMcpConfig, P as PtyAttachSnapshot, d as PtyDataChunk } from './connection-C2qTFync.js';
 export { AttachTunnelOptions, ResolvedPtySession, RunTunnelOptions, TunnelConnection, TunnelHandle, TunnelSession, TunnelTty, WaitForPtySessionOptions, attachTunnel, runTunnel, waitForPtySession } from './tunnel.js';
 import 'socket.io-client';
 import '@project/shared';

package/dist/index.js

@@ -5,7 +5,7 @@ import {
 } from "./chunk-HIVOGGE3.js";
 import {
   ConveyorConnection
-} from "./chunk-6JLKJUYV.js";
+} from "./chunk-XLNIBIX4.js";
 export {
   ConveyorConnection,
   attachTunnel,

package/dist/site-assets-cli.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 import {
   transferSiteAsset
-} from "./chunk-IRVUONC3.js";
+} from "./chunk-BOAMGYLU.js";
 import {
   ConveyorConnection
-} from "./chunk-6JLKJUYV.js";
+} from "./chunk-XLNIBIX4.js";
 
 // src/site-assets-cli.ts
 import crypto from "crypto";

package/dist/tunnel-cli.js

@@ -7,7 +7,7 @@ import {
 } from "./chunk-5KU3QS6A.js";
 import {
   ConveyorConnection
-} from "./chunk-6JLKJUYV.js";
+} from "./chunk-XLNIBIX4.js";
 
 // src/tunnel-cli.ts
 var HELP = `conveyor-tunnel \u2014 attach your local terminal to a cloud Claude Code session.

package/dist/tunnel.d.ts

@@ -1,4 +1,4 @@
-import { A as ActivePtySession, P as PtyAttachSnapshot, c as PtyDataChunk } from './connection-Ctg-QM1s.js';
+import { A as ActivePtySession, P as PtyAttachSnapshot, d as PtyDataChunk } from './connection-C2qTFync.js';
 import 'socket.io-client';
 import '@project/shared';
 

package/dist/wait-cli.js

@@ -4,10 +4,10 @@ import {
 } from "./chunk-5KU3QS6A.js";
 import {
   ConveyorConnection
-} from "./chunk-6JLKJUYV.js";
+} from "./chunk-XLNIBIX4.js";
 import {
   runWait
-} from "./chunk-OPZL4NDT.js";
+} from "./chunk-J7LQ5DAT.js";
 import {
   DEFAULT_WAIT_SCOPES,
   DEFAULT_WAIT_STATUSES,

package/dist/wait-runner.d.ts

@@ -1,4 +1,4 @@
-import { C as CardCollectionPage, a as CardCollectionDelta } from './connection-Ctg-QM1s.js';
+import { C as CardCollectionPage, a as CardStatePage, b as CardCollectionDelta } from './connection-C2qTFync.js';
 import { WaitFilter, WaitResult } from './wait.js';
 import 'socket.io-client';
 import '@project/shared';
@@ -7,9 +7,16 @@ import '@project/shared';
  * `conveyor-wait` runner — the live half of the engine.
  *
  * `wait.ts` decides what "matching" means; this module owns the socket-shaped
- * lifecycle around it: seed from a paged snapshot, apply deltas, re-snapshot
- * after a `reset` or a reconnect, and settle on the first card that enters the
- * filter (or on the deadline).
+ * lifecycle around it: seed, apply deltas, re-seed after a `reset` or a
+ * reconnect, and settle on the first card that enters the filter (or on the
+ * deadline).
+ *
+ * A seed is two calls, not a walk of the board. A cursor-less collection
+ * subscribe with `limit: 1` joins the scope room, which is what makes deltas
+ * flow; its one item is ignored. `listCardStates` then pages just the cards in
+ * the watched statuses and types — six fields each, usually one page. An API
+ * from before `listCardStates` gets today's walk of the collection instead
+ * (conveyor-mcp publishes ahead of the API release).
  *
  * It talks to a narrow `CardCollectionSource` rather than a socket, so the
  * reconnect, reset, and paging paths are unit-testable without a server.
@@ -24,6 +31,12 @@ interface CardCollectionSource {
         cursor?: string | null;
         limit?: number;
     }): Promise<CardCollectionPage>;
+    listCardStates(projectId: string, opts: {
+        statuses: string[];
+        types?: string[];
+        cursor?: string | null;
+        limit?: number;
+    }): Promise<CardStatePage>;
     onCardDelta(projectId: string, handler: (delta: CardCollectionDelta) => void): () => void;
     onReconnect(handler: () => void): () => void;
 }
@@ -32,7 +45,13 @@ interface RunWaitOptions {
     projectId: string;
     filter: WaitFilter;
     timeoutMs: number;
+    /** Rows per `listCardStates` page. */
+    statePageLimit?: number;
+    /** Page cap for one `listCardStates` seed. */
+    stateMaxPages?: number;
+    /** Items per page of the fallback collection walk. */
     pageLimit?: number;
+    /** Page cap for the fallback collection walk. */
     maxPages?: number;
     /** Backoff between re-snapshot attempts. Overridable so tests stay fast. */
     resyncRetryDelayMs?: number;

package/dist/wait-runner.js

@@ -1,6 +1,6 @@
 import {
   runWait
-} from "./chunk-OPZL4NDT.js";
+} from "./chunk-J7LQ5DAT.js";
 import "./chunk-D3Q2QZJA.js";
 export {
   runWait

package/dist/wait.d.ts

@@ -1,4 +1,4 @@
-import { b as CardCollectionItem } from './connection-Ctg-QM1s.js';
+import { c as CardCollectionItem } from './connection-C2qTFync.js';
 import 'socket.io-client';
 import '@project/shared';
 
@@ -14,10 +14,14 @@ import '@project/shared';
  * - **Creates arrive as `updated` deltas.** Most card writes go through the
  *   service's hand-rolled upsert choke point, which always emits `updated`.
  *   "New work" is therefore a set diff, never a delta-type check.
- * - **The snapshot ack is one PAGE, not the scope.** `cardsByProject` omits
- *   `ids` (the scope is unbounded), so seeding walks `nextCursor` to the end.
- *   When the walk is capped we merge instead of replacing, because dropping an
- *   unseen id would make it look newly-matching on the next delta.
+ * - **The seed is not the collection snapshot.** A snapshot ack is one page
+ *   of full cards, and a large project's scope runs to thousands of them. The
+ *   seed instead pages `listCardStates`: only the watched statuses and types,
+ *   six fields a row. The collection subscribe (with `limit: 1`) only joins
+ *   the delta room. An older API without `listCardStates` falls back to
+ *   walking the collection's `nextCursor` to the end. When either walk is
+ *   capped we merge instead of replacing, because dropping an unseen id would
+ *   make it look newly-matching on the next delta.
  *
  * The live half — snapshot paging, reconnect, and settling — lives in
  * `wait-runner.ts`; this module is the pure filter and set-diff logic it uses.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-mcp",
-  "version": "5.0.17",
+  "version": "5.0.18",
   "description": "Conveyor MCP server for Claude Code PM integration",
   "keywords": [
     "claude",