@rallycry/conveyor-mcp 5.0.3 → 5.0.5

package/README.md

@@ -76,6 +76,12 @@ CONVEYOR_PROJECT_ID = "<project-id>"
 | `CONVEYOR_PROJECT_ID`    | no       | Default project for unqualified tools. Omit it for multi-project mode.                |
 | `CONVEYOR_SUBPROJECT_ID` | no       | Default board. Unqualified `create_task`/`list_tasks`/`search_tasks` target it.       |
 
+## How the server exits
+
+The server's lifetime is its stdin pipe. It exits when stdin reaches EOF, on
+`SIGINT` or `SIGTERM`, and when its parent process changes — so a client that
+force-quits, crashes, or is torn down never leaves a server behind.
+
 ## Why `npx -y …@latest`
 
 Every form above launches the server through

package/dist/chunk-5KU3QS6A.js

@@ -0,0 +1,45 @@
+// src/lifecycle.ts
+function watchForClientExit(onExit, deps = {}) {
+  const stdin = deps.stdin ?? process.stdin;
+  const signals = deps.signals ?? process;
+  const getPpid = deps.getPpid ?? (() => process.ppid);
+  const intervalMs = deps.intervalMs ?? 3e4;
+  const watchStdin = deps.watchStdin ?? true;
+  let fired = false;
+  const fire = () => {
+    if (fired) return;
+    fired = true;
+    onExit();
+  };
+  signals.on("SIGINT", fire);
+  signals.on("SIGTERM", fire);
+  signals.on("SIGHUP", fire);
+  if (watchStdin && stdin.isTTY !== true) {
+    if (deps.resumeStdin) stdin.resume?.();
+    stdin.on("end", fire);
+    stdin.on("close", fire);
+  }
+  const initialPpid = getPpid();
+  const orphanCheck = setInterval(() => {
+    if (getPpid() !== initialPpid) fire();
+  }, intervalMs);
+  orphanCheck.unref?.();
+  return fire;
+}
+function installLifecycle(conn, deps = {}) {
+  const exit = deps.exit ?? ((code) => process.exit(code));
+  let stopping = false;
+  function stop(code = 0) {
+    if (stopping) return;
+    stopping = true;
+    conn.disconnect();
+    exit(code);
+  }
+  watchForClientExit(() => stop(), deps);
+  return stop;
+}
+
+export {
+  watchForClientExit,
+  installLifecycle
+};

package/dist/{chunk-XLDG5QEX.js → chunk-77XLXIFP.js}

@@ -49,10 +49,14 @@ function enrichToolError(error, fallback) {
 var ConveyorConnection = class {
   socket = null;
   config;
+  socketFactory;
   /** project slug → id, for resolving `<project>/<card>` card paths. */
   projectSlugIds = /* @__PURE__ */ new Map();
-  constructor(config) {
+  /** Session rooms this connection has joined, replayed after every reconnect. */
+  subscribedSessionIds = /* @__PURE__ */ new Set();
+  constructor(config, socketFactory = io) {
     this.config = config;
+    this.socketFactory = socketFactory;
   }
   get projectId() {
     return this.resolveProjectId();
@@ -86,12 +90,32 @@ var ConveyorConnection = class {
     if (Array.isArray(record.data)) return record.data;
     return [];
   }
+  /**
+   * Re-join every room this connection needs.
+   *
+   * Runs on the FIRST connect and on every reconnect. A socket.io reconnect
+   * starts a fresh server-side socket that belongs to no rooms, and Cloud Run
+   * cuts each websocket at its 60-minute request limit, so a subscribe sent
+   * only once left long-lived MCP connections silently outside the project room
+   * for the rest of the day.
+   */
+  rejoinRooms() {
+    const socket = this.socket;
+    if (!socket) return;
+    socket.emit("projectService:subscribe", { id: this.config.projectId });
+    for (const sessionId of this.subscribedSessionIds) {
+      socket.emit("agentSessionService:subscribe", {
+        entryId: sessionId,
+        requiredLevel: "Read"
+      });
+    }
+  }
   connect() {
     return new Promise((resolve, reject) => {
       let settled = false;
       let attempts = 0;
       const maxAttempts = 15;
-      this.socket = io(
+      this.socket = this.socketFactory(
         this.config.apiUrl,
         buildConveyorSocketOptions({
           projectToken: this.config.projectToken,
@@ -99,12 +123,15 @@ var ConveyorConnection = class {
         })
       );
       this.socket.on("connect", () => {
+        this.rejoinRooms();
         if (!settled) {
           settled = true;
-          this.socket?.emit("projectService:subscribe", { id: this.config.projectId });
           resolve();
         }
       });
+      this.socket.on("disconnect", (reason) => {
+        if (reason === "io server disconnect") this.socket?.connect();
+      });
       this.socket.on("connect_error", (err) => {
         const message = err?.message ?? "unknown error";
         if (!settled && AUTH_ERROR_RE.test(message)) {
@@ -547,6 +574,52 @@ var ConveyorConnection = class {
       ...rest
     });
   }
+  // ── Decisions ───────────────────────────────────────────────────────
+  //
+  // Every method resolves the project the same way the rest of the surface
+  // does, so a caller with a configured default never has to pass one.
+  createDecision(params) {
+    const { projectId, ...rest } = params;
+    return this.call("createProjectDecision", {
+      projectId: this.resolveProjectId(projectId),
+      ...rest
+    });
+  }
+  listDecisions(params) {
+    const { projectId, ...rest } = params;
+    return this.call("listProjectDecisions", {
+      projectId: this.resolveProjectId(projectId),
+      ...rest
+    });
+  }
+  getDecision(params) {
+    const { projectId, ...rest } = params;
+    return this.call("getProjectDecision", {
+      projectId: this.resolveProjectId(projectId),
+      ...rest
+    });
+  }
+  voteDecision(params) {
+    const { projectId, ...rest } = params;
+    return this.call("voteProjectDecision", {
+      projectId: this.resolveProjectId(projectId),
+      ...rest
+    });
+  }
+  resolveDecision(params) {
+    const { projectId, ...rest } = params;
+    return this.call("resolveProjectDecision", {
+      projectId: this.resolveProjectId(projectId),
+      ...rest
+    });
+  }
+  updateDecision(params) {
+    const { projectId, ...rest } = params;
+    return this.call("updateProjectDecision", {
+      projectId: this.resolveProjectId(projectId),
+      ...rest
+    });
+  }
   // ── Meetings ────────────────────────────────────────────────────────
   listMeetings(params) {
     const { projectId, ...rest } = params;
@@ -943,6 +1016,7 @@ var ConveyorConnection = class {
   subscribeToSession(sessionId) {
     const socket = this.socket;
     if (!socket) throw new Error("Not connected");
+    this.subscribedSessionIds.add(sessionId);
     socket.emit("agentSessionService:subscribe", {
       entryId: sessionId,
       requiredLevel: "Read"
@@ -1013,6 +1087,7 @@ var ConveyorConnection = class {
   disconnect() {
     this.socket?.disconnect();
     this.socket = null;
+    this.subscribedSessionIds.clear();
   }
 };
 

package/dist/cli.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
+import {
+  installLifecycle
+} from "./chunk-5KU3QS6A.js";
 import {
   ConveyorConnection
-} from "./chunk-XLDG5QEX.js";
+} from "./chunk-77XLXIFP.js";
 
 // src/cli.ts
 import { createRequire } from "module";
@@ -69,7 +72,7 @@ function registerProjectTools(server2, conn2) {
 // src/tools/connection.ts
 import { z as z4 } from "zod";
 
-// ../shared/dist/chunk-42BS7Y35.js
+// ../shared/dist/chunk-6NPOGQPP.js
 import { z as z2 } from "zod";
 var DEFAULT_SONNET_MODEL = "claude-sonnet-5";
 var DEFAULT_OPUS_MODEL = "claude-opus-5";
@@ -303,14 +306,14 @@ var f = {
     return { kind: "nullable", inner };
   }
 };
-function compileString(z11, spec) {
-  let schema = z11.string();
+function compileString(z13, spec) {
+  let schema = z13.string();
   if (spec.min !== void 0) schema = schema.min(spec.min);
   if (spec.max !== void 0) schema = schema.max(spec.max);
   return schema;
 }
-function compileNumber(z11, spec) {
-  let schema = z11.number();
+function compileNumber(z13, spec) {
+  let schema = z13.number();
   if (spec.int) schema = schema.int();
   if (spec.positive) schema = schema.positive();
   if (spec.nonnegative) schema = schema.nonnegative();
@@ -318,49 +321,49 @@ function compileNumber(z11, spec) {
   if (spec.max !== void 0) schema = schema.max(spec.max);
   return schema;
 }
-function compileArray(z11, spec) {
-  let schema = z11.array(compileField(z11, spec.item));
+function compileArray(z13, spec) {
+  let schema = z13.array(compileField(z13, spec.item));
   if (spec.min !== void 0) schema = schema.min(spec.min);
   return schema;
 }
-function compileBase(z11, spec) {
+function compileBase(z13, spec) {
   switch (spec.kind) {
     case "string":
-      return compileString(z11, spec);
+      return compileString(z13, spec);
     case "number":
-      return compileNumber(z11, spec);
+      return compileNumber(z13, spec);
     case "boolean":
-      return z11.boolean();
+      return z13.boolean();
     case "enum":
-      return z11.enum([...spec.values]);
+      return z13.enum([...spec.values]);
     case "array":
-      return compileArray(z11, spec);
+      return compileArray(z13, spec);
     case "object":
-      return z11.object(compileShape(z11, spec.fields));
+      return z13.object(compileShape(z13, spec.fields));
   }
 }
 function descriptionOf(spec) {
   if (spec.kind === "optional" || spec.kind === "nullable") return descriptionOf(spec.inner);
   return spec.desc;
 }
-function compileUndescribed(z11, spec) {
+function compileUndescribed(z13, spec) {
   if (spec.kind === "optional") {
-    return compileUndescribed(z11, spec.inner).optional();
+    return compileUndescribed(z13, spec.inner).optional();
   }
   if (spec.kind === "nullable") {
-    return compileUndescribed(z11, spec.inner).nullable();
+    return compileUndescribed(z13, spec.inner).nullable();
   }
-  return compileBase(z11, spec);
+  return compileBase(z13, spec);
 }
-function compileField(z11, spec) {
-  const schema = compileUndescribed(z11, spec);
+function compileField(z13, spec) {
+  const schema = compileUndescribed(z13, spec);
   const desc = descriptionOf(spec);
   return desc === void 0 ? schema : schema.describe(desc);
 }
-function compileShape(z11, fields) {
+function compileShape(z13, fields) {
   const shape = {};
   for (const [key, spec] of Object.entries(fields)) {
-    shape[key] = compileField(z11, spec);
+    shape[key] = compileField(z13, spec);
   }
   return shape;
 }
@@ -473,7 +476,7 @@ var SEARCH_STATUSES = [
   "Complete",
   "Cancelled"
 ];
-var SEARCH_CARD_TYPES = ["task", "incident", "suggestion"];
+var SEARCH_CARD_TYPES = ["task", "incident", "suggestion", "decision"];
 var searchFilterFields = {
   tagNames: f.optional(
     f.array(f.string(), {
@@ -1166,6 +1169,235 @@ var createSuggestionContract = defineToolContract({
   }
 });
 var suggestionsContracts = [createSuggestionContract];
+var OPTION_KINDS = ["current", "planned", "proposed"];
+var STATUS_LABELS = ["Open", "Decided", "Cancelled"];
+var optionDescription = "What this option means in the product, written as GIVEN / WHEN / THEN. Concrete enough that a reader six months from now can tell which behaviour was chosen.";
+var optionsDesc = "Two or three options. More than three means the question is not framed yet \u2014 narrow it or split it. Mark the option describing what the code does today as kind: current.";
+var defaultOptionDesc = "1-based position of the option that wins if nobody decides by the deadline. Required: silence has to become a decision, never a stall.";
+var agentOption = f.object(
+  {
+    label: f.string({ min: 1, desc: "Short name for the option, under 80 characters" }),
+    description: f.string({ min: 1, desc: optionDescription }),
+    kind: f.optional(
+      f.enum(OPTION_KINDS, {
+        desc: 'current = what the code does today, planned = already agreed but unbuilt, proposed = new. Defaults to "proposed".'
+      })
+    )
+  },
+  { desc: "One option people can choose" }
+);
+var createDecisionContract = defineToolContract({
+  name: "create_decision",
+  agent: {
+    description: `Raise a product decision: a fork the plan cannot be right without. Two or three options, one default, a deadline. Run list_decisions FIRST \u2014 an answered decision is the answer, and re-asking it wastes everybody's time. Do NOT file a decision for an assumption you can simply state: an assumed behaviour belongs in the plan as a GIVEN / WHEN / THEN line under "Assumed behaviours". Returns the decision's id, slug, and url.`,
+    fields: {
+      question: f.string({
+        min: 1,
+        desc: "The question, as one plain sentence ending in a question mark"
+      }),
+      summary: f.optional(
+        f.string({
+          desc: cardDescriptionDesc("One or two sentences of context for the card face")
+        })
+      ),
+      context: f.string({
+        min: 1,
+        desc: "Markdown background: why this is being asked now, and what breaks if it is answered wrongly"
+      }),
+      options: f.array(agentOption, { min: 2, desc: optionsDesc }),
+      default_option: f.number({ int: true, min: 1, max: 3, desc: defaultOptionDesc }),
+      deadline_hours: f.optional(
+        f.number({ min: 1, max: 720, desc: "Hours until the default applies. Default 72." })
+      ),
+      impacted_cards: f.optional(
+        f.array(f.string(), {
+          desc: "Slugs or ids of cards this decision blocks. They cannot start until it is settled, and they are un-blocked the moment it is. Blocking a card needs Moderate access: without it the decision is still raised and each ref comes back under refused."
+        })
+      ),
+      include_current_card: f.optional(
+        f.boolean({
+          desc: "Also block the card this session is working on. Defaults to true \u2014 you are raising this because your own plan is stuck on it. Pass false to raise the question without stopping your own work."
+        })
+      ),
+      tag_names: f.optional(
+        f.array(f.string(), {
+          desc: "Tag names. The settled decision is written into each tag's overview, which is how the next agent finds it."
+        })
+      ),
+      raised_by_pr: f.optional(
+        f.number({ int: true, min: 1, desc: "PR number that surfaced the question" })
+      )
+    }
+  },
+  mcp: {
+    description: "Raise a product decision on a Conveyor project: a fork that has to be settled before the work can be planned correctly. Two or three options, one default that applies if nobody decides, and a deadline. Search list_decisions first \u2014 a Decided decision is the answer. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId,
+      question: f.string({ desc: "The question, as one plain sentence" }),
+      summary: f.optional(f.string({ desc: cardDescriptionDesc("Context for the card face") })),
+      context: f.string({ desc: "Markdown background: why this is being asked now" }),
+      options: f.array(agentOption, { min: 2, desc: optionsDesc }),
+      defaultOption: f.number({ int: true, min: 1, max: 3, desc: defaultOptionDesc }),
+      deadlineHours: f.optional(
+        f.number({ min: 1, max: 720, desc: "Hours until the default applies. Default 72." })
+      ),
+      impactedCards: f.optional(
+        f.array(f.string(), {
+          desc: "Slugs or ids of cards this decision blocks. Needs Moderate access; without it each ref comes back under refused and the decision is still raised."
+        })
+      ),
+      tagNames: f.optional(f.array(f.string(), { desc: "Tag names to categorize the decision" })),
+      raisedByPr: f.optional(
+        f.number({ int: true, min: 1, desc: "PR number that surfaced the question" })
+      )
+    }
+  }
+});
+var listDecisionsContract = defineToolContract({
+  name: "list_decisions",
+  agent: {
+    description: `Search this project's decisions. Run this BEFORE planning anything in an area: "have we already decided how X behaves?" Decided rows carry their resolution, so the list doubles as the decision log. Filter by card to see what is blocking a specific card.`,
+    fields: {
+      status: f.optional(
+        f.enum(STATUS_LABELS, {
+          desc: "Open = still being voted on, Decided = settled, Cancelled = dropped"
+        })
+      ),
+      tag: f.optional(f.string({ desc: 'Tag name, e.g. "slack"' })),
+      card: f.optional(
+        f.string({ desc: "Slug or id of a card \u2014 returns the decisions it is blocked by" })
+      ),
+      query: f.optional(f.string({ desc: "Text search on the question" })),
+      limit: f.optional(f.number({ desc: "Max rows to return (default 50, max 200)" }))
+    }
+  },
+  mcp: {
+    description: `List and search a Conveyor project's decisions. Decided rows include their resolution, so this is the fastest way to answer "did we already settle this?". Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: {
+      projectId: mcpProjectId,
+      status: f.optional(f.enum(STATUS_LABELS, { desc: "Filter by state" })),
+      tag: f.optional(f.string({ desc: "Tag name to filter by" })),
+      card: f.optional(f.string({ desc: "Card slug or id \u2014 decisions blocking that card" })),
+      query: f.optional(f.string({ desc: "Text search on the question" })),
+      limit: f.optional(
+        f.number({ int: true, min: 1, max: 200, desc: "Max rows to return (default 50)" })
+      )
+    }
+  }
+});
+var getDecisionContract = defineToolContract({
+  name: "get_decision",
+  agent: {
+    description: "Read one decision in full: its context, every option with its GIVEN / WHEN / THEN, every vote with who cast it and why, the running tally, the cards it blocks, and the resolution once there is one. Use read_task_chat with the same id for the discussion thread.",
+    fields: {
+      decision: f.string({ min: 1, desc: "Decision slug or id" })
+    }
+  },
+  mcp: {
+    description: "Read one Conveyor decision in full \u2014 context, options, votes with reasons, tally, impacted cards, and the resolution. Pass projectId to disambiguate a slug; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId,
+      decision: f.string({ desc: "Decision slug or id" })
+    }
+  }
+});
+var voteDecisionContract = defineToolContract({
+  name: "vote_decision",
+  agent: {
+    description: "Vote on an open decision. One vote per voter: voting again replaces your previous one. Always give a reason \u2014 the resolution weighs reasons over counts, and a vote with no reason carries almost nothing.",
+    fields: {
+      decision: f.string({ min: 1, desc: "Decision slug or id" }),
+      option: f.string({ min: 1, desc: "Option id, or its 1-based position" }),
+      reason: f.optional(
+        f.string({ desc: "Why this option, in one or two sentences (max 255 characters)" })
+      )
+    }
+  },
+  mcp: {
+    description: "Vote on an open Conveyor decision, with a reason. One vote per voter \u2014 voting again replaces the previous one.",
+    fields: {
+      projectId: mcpProjectId,
+      decision: f.string({ desc: "Decision slug or id" }),
+      option: f.string({ desc: "Option id, or its 1-based position" }),
+      reason: f.optional(f.string({ desc: "Why this option (max 255 characters)" }))
+    }
+  }
+});
+var resolveDecisionContract = defineToolContract({
+  name: "resolve_decision",
+  agent: {
+    description: "Settle a decision. This is not a formality: the resolution is written into the plan of every card the decision blocked, into each of their chats, and into the overview of every tag it carries, and those cards become startable. Say what was decided in one or two sentences \u2014 a reader months later should not need to open the thread.",
+    fields: {
+      decision: f.string({ min: 1, desc: "Decision slug or id" }),
+      option: f.string({ min: 1, desc: "Winning option id, or its 1-based position" }),
+      resolution: f.string({
+        min: 1,
+        desc: "What was decided, in one or two plain sentences (max 255 characters)"
+      }),
+      notes: f.optional(
+        f.string({ desc: "Markdown reasoning. Link any verdict attachment here." })
+      )
+    }
+  },
+  mcp: {
+    description: "Settle a Conveyor decision. The resolution is written into every impacted card's plan and chat and into its tags' overviews, and the impacted cards become startable.",
+    fields: {
+      projectId: mcpProjectId,
+      decision: f.string({ desc: "Decision slug or id" }),
+      option: f.string({ desc: "Winning option id, or its 1-based position" }),
+      resolution: f.string({ desc: "What was decided (max 255 characters)" }),
+      notes: f.optional(f.string({ desc: "Markdown reasoning" }))
+    }
+  }
+});
+var updateDecisionContract = defineToolContract({
+  name: "update_decision",
+  agent: {
+    description: "Change an open decision: extend its deadline, link or unlink the cards it blocks, or cancel it. Cancelling un-blocks the impacted cards without answering the question, so only do it when the question stopped mattering.",
+    fields: {
+      decision: f.string({ min: 1, desc: "Decision slug or id" }),
+      deadline_hours: f.optional(f.number({ desc: "New deadline, in hours from now. 1 to 720." })),
+      add_impacted_cards: f.optional(
+        f.array(f.string(), { desc: "Slugs or ids of cards to block on this decision" })
+      ),
+      remove_impacted_cards: f.optional(
+        f.array(f.string(), { desc: "Ids of cards to stop blocking" })
+      ),
+      status: f.optional(
+        f.enum(["Cancelled", "Open"], {
+          desc: "Cancelled drops the question; Open reopens a settled one and clears its answer"
+        })
+      )
+    }
+  },
+  mcp: {
+    description: "Change an open Conveyor decision: extend the deadline, link or unlink impacted cards, cancel it, or reopen a settled one.",
+    fields: {
+      projectId: mcpProjectId,
+      decision: f.string({ desc: "Decision slug or id" }),
+      deadlineHours: f.optional(
+        f.number({ min: 1, max: 720, desc: "New deadline, in hours from now" })
+      ),
+      addImpactedCards: f.optional(
+        f.array(f.string(), { desc: "Slugs or ids of cards to block on this decision" })
+      ),
+      removeImpactedCards: f.optional(
+        f.array(f.string(), { desc: "Ids of cards to stop blocking" })
+      ),
+      status: f.optional(
+        f.enum(["Cancelled", "Open"], { desc: "Cancel it, or reopen a settled one" })
+      )
+    }
+  }
+});
+var decisionsContracts = [
+  createDecisionContract,
+  listDecisionsContract,
+  getDecisionContract,
+  voteDecisionContract,
+  resolveDecisionContract,
+  updateDecisionContract
+];
 var createPullRequestContract = defineToolContract({
   name: "create_pull_request",
   agent: {
@@ -1826,6 +2058,7 @@ var TOOL_CONTRACTS = Object.fromEntries(
     ...subtasksContracts,
     ...attachmentsContracts,
     ...suggestionsContracts,
+    ...decisionsContracts,
     ...pullRequestContracts,
     ...integrationsContracts,
     ...driveContracts,
@@ -3309,6 +3542,8 @@ import { z as z72 } from "zod";
 import { z as z82 } from "zod";
 import { z as z92 } from "zod";
 import { z as z102 } from "zod";
+import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var ACHIEVEMENT_RARITIES = [
   {
     key: "common",
@@ -4797,135 +5032,291 @@ var DeleteTaskAuditRequestSchema = z92.object({
 var MarkInitialPromptSubmittedRequestSchema = z92.object({
   sessionId: z92.string()
 });
+var DECISION_STATUS_LABELS = ["Open", "Decided", "Cancelled"];
+var DECISION_OPTION_KINDS = ["current", "planned", "proposed"];
+var DECISION_VOTE_SOURCES = ["web", "slack", "discord", "agent"];
+var DECISION_OPTIONS_MIN = 2;
+var DECISION_OPTIONS_MAX = 3;
+var DECISION_OPTION_LABEL_MAX = 80;
+var DECISION_QUESTION_MAX = 200;
+var DECISION_RESOLUTION_MAX = CARD_DESCRIPTION_MAX;
+var DECISION_VOTE_REASON_MAX = CARD_DESCRIPTION_MAX;
+var DECISION_DEADLINE_MIN_HOURS = 1;
+var DECISION_DEADLINE_MAX_DAYS = 30;
+var DECISION_DEADLINE_MAX_HOURS = DECISION_DEADLINE_MAX_DAYS * 24;
+var DECISION_LIST_MAX_LIMIT = 200;
+var decisionIdSchema = z102.string().cuid("Invalid decision ID");
+var optionInputSchema = z102.object({
+  label: z102.string().min(1, "Option label is required").max(DECISION_OPTION_LABEL_MAX),
+  description: z102.string().min(1, "Describe the option as GIVEN / WHEN / THEN"),
+  kind: z102.enum(DECISION_OPTION_KINDS).optional()
+});
+var optionsArraySchema = z102.array(optionInputSchema).min(DECISION_OPTIONS_MIN, `A decision needs at least ${DECISION_OPTIONS_MIN} options`).max(
+  DECISION_OPTIONS_MAX,
+  `A decision takes at most ${DECISION_OPTIONS_MAX} options \u2014 more than that means the question is not framed yet`
+);
+var CreateDecisionRequestSchema = z102.object({
+  projectId: z102.string().cuid("Invalid project ID"),
+  /** The question, as one plain sentence. */
+  title: z102.string().min(1, "A decision needs a question").max(DECISION_QUESTION_MAX),
+  description: z102.string().max(CARD_DESCRIPTION_MAX).optional(),
+  context: z102.string().min(1, "Context is required \u2014 say why this is being asked now"),
+  options: optionsArraySchema,
+  /** 1-based position of the option that wins on silence. */
+  defaultOptionOrdinal: z102.number().int().min(1).max(DECISION_OPTIONS_MAX),
+  deadlineHours: z102.number().min(DECISION_DEADLINE_MIN_HOURS).max(DECISION_DEADLINE_MAX_HOURS).optional(),
+  /** Cards this decision blocks, by cuid or slug. */
+  impactedCardRefs: z102.array(z102.string().min(1)).max(50).optional(),
+  tagNames: z102.array(z102.string().min(1)).max(10).optional(),
+  raisedByTaskId: z102.string().min(1).optional(),
+  raisedByPrNumber: z102.number().int().positive().optional()
+});
+var VoteDecisionRequestSchema = z102.object({
+  decisionId: decisionIdSchema,
+  optionId: z102.string().cuid("Invalid option ID"),
+  reason: z102.string().max(DECISION_VOTE_REASON_MAX).optional(),
+  source: z102.enum(DECISION_VOTE_SOURCES).optional()
+});
+var RemoveDecisionVoteRequestSchema = z102.object({
+  decisionId: decisionIdSchema
+});
+var ResolveDecisionRequestSchema = z102.object({
+  decisionId: decisionIdSchema,
+  chosenOptionId: z102.string().cuid("Invalid option ID"),
+  resolution: z102.string().min(1, "A resolution is required \u2014 say what was decided").max(DECISION_RESOLUTION_MAX),
+  resolutionNotes: z102.string().optional()
+});
+var CancelDecisionRequestSchema = z102.object({
+  decisionId: decisionIdSchema,
+  /** Why it is being dropped. Posted to the decision thread. */
+  reason: z102.string().max(DECISION_RESOLUTION_MAX).optional()
+});
+var ReopenDecisionRequestSchema = z102.object({
+  decisionId: decisionIdSchema,
+  deadlineHours: z102.number().min(DECISION_DEADLINE_MIN_HOURS).max(DECISION_DEADLINE_MAX_HOURS).optional()
+});
+var UpdateDecisionRequestSchema = z102.object({
+  decisionId: decisionIdSchema,
+  title: z102.string().min(1).max(200).optional(),
+  description: z102.string().max(CARD_DESCRIPTION_MAX).optional(),
+  context: z102.string().min(1).optional(),
+  deadlineAt: z102.string().datetime().optional(),
+  /** Only accepted while the decision has zero votes. */
+  options: optionsArraySchema.optional(),
+  defaultOptionOrdinal: z102.number().int().min(1).max(DECISION_OPTIONS_MAX).optional(),
+  addImpactedCardRefs: z102.array(z102.string().min(1)).max(50).optional(),
+  removeImpactedCardIds: z102.array(z102.string().min(1)).max(50).optional()
+});
+var GetDecisionRequestSchema = z102.object({
+  /** cuid or slug. A slug needs `projectId` to resolve unambiguously. */
+  decisionId: z102.string().min(1),
+  projectId: z102.string().cuid().optional()
+});
+var ListDecisionsRequestSchema = z102.object({
+  projectId: z102.string().cuid("Invalid project ID"),
+  status: z102.enum(DECISION_STATUS_LABELS).optional(),
+  /** Tag name, not id — an agent knows the tag it is working under. */
+  tag: z102.string().min(1).optional(),
+  /** Decisions that this card is blocked by (cuid or slug). */
+  cardId: z102.string().min(1).optional(),
+  query: z102.string().min(1).optional(),
+  limit: z102.number().int().min(1).max(DECISION_LIST_MAX_LIMIT).optional()
+});
+var optionInput = z11.object({
+  label: z11.string().min(1).max(DECISION_OPTION_LABEL_MAX),
+  description: z11.string().min(1),
+  kind: z11.enum(DECISION_OPTION_KINDS).optional()
+});
+var optionsInput = z11.array(optionInput).min(DECISION_OPTIONS_MIN).max(DECISION_OPTIONS_MAX);
+var deadlineHours = z11.number().min(DECISION_DEADLINE_MIN_HOURS).max(DECISION_DEADLINE_MAX_HOURS).optional();
+var CreateProjectDecisionRequestSchema = z11.object({
+  projectId: z11.string(),
+  question: z11.string().min(1).max(200),
+  summary: z11.string().max(CARD_DESCRIPTION_MAX).optional(),
+  context: z11.string().min(1),
+  options: optionsInput,
+  defaultOption: z11.number().int().min(1).max(DECISION_OPTIONS_MAX),
+  deadlineHours,
+  impactedCards: z11.array(z11.string().min(1)).max(50).optional(),
+  /**
+   * Pod surface only: also block the card this session is working on. The
+   * session's task id is resolved SERVER-side from `sessionId` — a
+   * client-supplied card id would let a pod block any card in the project.
+   */
+  includeCurrentCard: z11.boolean().optional(),
+  sessionId: z11.string().optional(),
+  tagNames: z11.array(z11.string().min(1)).max(10).optional(),
+  raisedByPr: z11.number().int().positive().optional(),
+  requestingUserId: z11.string().optional()
+});
+var ListProjectDecisionsRequestSchema = z11.object({
+  projectId: z11.string(),
+  status: z11.enum(DECISION_STATUS_LABELS).optional(),
+  tag: z11.string().min(1).optional(),
+  card: z11.string().min(1).optional(),
+  query: z11.string().min(1).optional(),
+  limit: z11.number().int().min(1).max(DECISION_LIST_MAX_LIMIT).optional(),
+  requestingUserId: z11.string().optional()
+});
+var GetProjectDecisionRequestSchema = z11.object({
+  projectId: z11.string(),
+  decision: z11.string().min(1),
+  requestingUserId: z11.string().optional()
+});
+var VoteProjectDecisionRequestSchema = z11.object({
+  projectId: z11.string(),
+  decision: z11.string().min(1),
+  /** An option id, or its 1-based position. */
+  option: z11.string().min(1),
+  reason: z11.string().max(CARD_DESCRIPTION_MAX).optional(),
+  requestingUserId: z11.string().optional()
+});
+var ResolveProjectDecisionRequestSchema = z11.object({
+  projectId: z11.string(),
+  decision: z11.string().min(1),
+  option: z11.string().min(1),
+  resolution: z11.string().min(1).max(DECISION_RESOLUTION_MAX),
+  notes: z11.string().optional(),
+  requestingUserId: z11.string().optional()
+});
+var UpdateProjectDecisionRequestSchema = z11.object({
+  projectId: z11.string(),
+  decision: z11.string().min(1),
+  deadlineHours,
+  addImpactedCards: z11.array(z11.string().min(1)).max(50).optional(),
+  removeImpactedCards: z11.array(z11.string().min(1)).max(50).optional(),
+  status: z11.enum(["Cancelled", "Open"]).optional(),
+  requestingUserId: z11.string().optional()
+});
 var MEETING_CHECKLIST_TITLE_MAX = 300;
 var MEETING_TRANSCRIPT_MAX_CHARS = 2e6;
 var MEETING_TITLE_MAX = 200;
 var MEETING_OCCURRED_AT_MIN_YEAR = 2e3;
 var MEETING_OCCURRED_AT_MAX_FUTURE_MS = 48 * 60 * 60 * 1e3;
 var OCCURRED_AT_RANGE_MESSAGE = `occurredAt must be a real date: no earlier than ${MEETING_OCCURRED_AT_MIN_YEAR}, and no more than 48 hours in the future.`;
-var MeetingOccurredAtSchema = z102.string().datetime().refine((value) => {
+var MeetingOccurredAtSchema = z12.string().datetime().refine((value) => {
   const ms = Date.parse(value);
   if (Number.isNaN(ms)) return false;
   if (ms > Date.now() + MEETING_OCCURRED_AT_MAX_FUTURE_MS) return false;
   return new Date(ms).getUTCFullYear() >= MEETING_OCCURRED_AT_MIN_YEAR;
 }, OCCURRED_AT_RANGE_MESSAGE);
-var CreateMeetingFromTranscriptRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  rawText: z102.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
-  title: z102.string().min(1).max(MEETING_TITLE_MAX).optional(),
+var CreateMeetingFromTranscriptRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  rawText: z12.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
+  title: z12.string().min(1).max(MEETING_TITLE_MAX).optional(),
   /** ISO 8601. Defaults to now when the source carries no date. */
   occurredAt: MeetingOccurredAtSchema.optional(),
   /** Override auto-detection. Rarely needed; detection handles the three formats. */
-  format: z102.enum(["text", "vtt", "srt"]).optional(),
-  source: z102.enum(["manual", "slack"]).optional()
+  format: z12.enum(["text", "vtt", "srt"]).optional(),
+  source: z12.enum(["manual", "slack"]).optional()
 });
-var GetMeetingRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid()
+var GetMeetingRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid()
 });
-var UpdateMeetingRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid(),
-  title: z102.string().min(1).max(MEETING_TITLE_MAX).optional(),
+var UpdateMeetingRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  title: z12.string().min(1).max(MEETING_TITLE_MAX).optional(),
   occurredAt: MeetingOccurredAtSchema.optional()
 });
-var RegenerateMeetingSummaryRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid()
+var RegenerateMeetingSummaryRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid()
 });
-var DeleteMeetingRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid()
+var DeleteMeetingRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid()
 });
-var checklistTitle = z102.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX);
-var ListMeetingChecklistRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid()
+var checklistTitle = z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX);
+var ListMeetingChecklistRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid()
 });
-var AddMeetingChecklistItemsRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid(),
-  items: z102.array(z102.object({ title: checklistTitle })).min(1).max(50)
+var AddMeetingChecklistItemsRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  items: z12.array(z12.object({ title: checklistTitle })).min(1).max(50)
 });
-var UpdateMeetingChecklistItemRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid(),
-  itemId: z102.string().cuid(),
+var UpdateMeetingChecklistItemRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  itemId: z12.string().cuid(),
   title: checklistTitle.optional(),
-  ordinal: z102.number().int().min(0).optional(),
+  ordinal: z12.number().int().min(0).optional(),
   /** Explicit null clears the link; undefined leaves it alone. */
-  linkedTaskId: z102.string().cuid().nullable().optional()
+  linkedTaskId: z12.string().cuid().nullable().optional()
 }).refine(
   (v) => v.title !== void 0 || v.ordinal !== void 0 || v.linkedTaskId !== void 0,
   "Pass at least one of title, ordinal, or linkedTaskId."
 );
-var DeleteMeetingChecklistItemRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid(),
-  itemId: z102.string().cuid()
-});
-var SetMeetingChecklistItemCheckedRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid(),
-  itemId: z102.string().cuid(),
-  checked: z102.boolean(),
+var DeleteMeetingChecklistItemRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  itemId: z12.string().cuid()
+});
+var SetMeetingChecklistItemCheckedRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  itemId: z12.string().cuid(),
+  checked: z12.boolean(),
   /** Attach the card in the same call that ticks the item. */
-  linkedTaskId: z102.string().cuid().nullable().optional()
+  linkedTaskId: z12.string().cuid().nullable().optional()
 });
-var ListMeetingsRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  limit: z102.number().int().min(1).max(50).optional(),
-  search: z102.string().max(200).optional()
+var ListMeetingsRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  limit: z12.number().int().min(1).max(50).optional(),
+  search: z12.string().max(200).optional()
 });
-var ReadMeetingTranscriptRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid(),
-  offset: z102.number().int().min(0).optional(),
-  limit: z102.number().int().min(1).max(500).optional()
+var ReadMeetingTranscriptRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  offset: z12.number().int().min(0).optional(),
+  limit: z12.number().int().min(1).max(500).optional()
 });
 var MEETING_SUMMARY_MAX_CHARS = 5e4;
-var AddProjectMeetingChecklistItemsRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid(),
-  items: z102.array(z102.object({ title: z102.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX) })).min(1).max(50),
-  requestingUserId: z102.string().optional()
-});
-var CheckProjectMeetingChecklistItemRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid(),
-  title: z102.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
-  checked: z102.boolean(),
+var AddProjectMeetingChecklistItemsRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  items: z12.array(z12.object({ title: z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX) })).min(1).max(50),
+  requestingUserId: z12.string().optional()
+});
+var CheckProjectMeetingChecklistItemRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  title: z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  checked: z12.boolean(),
   /** Card id or slug. Resolved server-side and required to be in the project. */
-  linkedTask: z102.string().min(1).optional(),
-  requestingUserId: z102.string().optional()
-});
-var EditProjectMeetingChecklistItemRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid(),
-  title: z102.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
-  newTitle: z102.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
-  requestingUserId: z102.string().optional()
-});
-var RemoveProjectMeetingChecklistItemRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid(),
-  title: z102.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
-  requestingUserId: z102.string().optional()
-});
-var CreateProjectMeetingRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  rawText: z102.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
-  title: z102.string().min(1).max(MEETING_TITLE_MAX).optional(),
+  linkedTask: z12.string().min(1).optional(),
+  requestingUserId: z12.string().optional()
+});
+var EditProjectMeetingChecklistItemRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  title: z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  newTitle: z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  requestingUserId: z12.string().optional()
+});
+var RemoveProjectMeetingChecklistItemRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  title: z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  requestingUserId: z12.string().optional()
+});
+var CreateProjectMeetingRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  rawText: z12.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
+  title: z12.string().min(1).max(MEETING_TITLE_MAX).optional(),
   occurredAt: MeetingOccurredAtSchema.optional(),
-  requestingUserId: z102.string().optional()
+  requestingUserId: z12.string().optional()
 });
-var UpdateProjectMeetingRequestSchema = z102.object({
-  projectId: z102.string().cuid(),
-  meetingId: z102.string().cuid(),
-  title: z102.string().min(1).max(MEETING_TITLE_MAX).optional(),
+var UpdateProjectMeetingRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  title: z12.string().min(1).max(MEETING_TITLE_MAX).optional(),
   occurredAt: MeetingOccurredAtSchema.optional(),
-  summary: z102.string().min(1).max(MEETING_SUMMARY_MAX_CHARS).optional(),
-  requestingUserId: z102.string().optional()
+  summary: z12.string().min(1).max(MEETING_SUMMARY_MAX_CHARS).optional(),
+  requestingUserId: z12.string().optional()
 }).refine(
   (v) => v.title !== void 0 || v.occurredAt !== void 0 || v.summary !== void 0,
   "Pass at least one of title, occurredAt, or summary."
@@ -5262,13 +5653,17 @@ var CARD_TYPE_SURFACE = {
   task: "board",
   chat: "board",
   incident: "report",
-  suggestion: "report"
+  suggestion: "report",
+  // Decisions get their own surface: they are neither built on the board nor
+  // triaged in the report feeds. Cards → Decisions is their only feed.
+  decision: "decision"
 };
 var surfaceTypes = (surface) => Object.keys(CARD_TYPE_SURFACE).filter(
   (type) => CARD_TYPE_SURFACE[type] === surface
 );
 var BOARD_CARD_TYPES = surfaceTypes("board");
 var REPORT_CARD_TYPES = surfaceTypes("report");
+var DECISION_CARD_TYPES = surfaceTypes("decision");
 
 // src/tools/logs.ts
 function registerLogTools(server2, conn2) {
@@ -5449,6 +5844,83 @@ ${res.lines.join("\n")}${footer}` }] };
   });
 }
 
+// src/tools/decisions.ts
+function registerDecisionReads(server2, conn2) {
+  registerContractTool(server2, listDecisionsContract, async (params) => {
+    const res = await conn2.listDecisions(params);
+    if (res.decisions.length === 0) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: "No decisions match. Nothing has been settled here, so the choice is open \u2014 state it as an assumption in the plan, or raise a decision with create_decision if the plan cannot be right without an answer."
+          }
+        ]
+      };
+    }
+    return { content: [{ type: "text", text: JSON.stringify(res.decisions, null, 2) }] };
+  });
+  registerContractTool(server2, getDecisionContract, async (params) => {
+    const res = await conn2.getDecision(params);
+    return { content: [{ type: "text", text: JSON.stringify(res, null, 2) }] };
+  });
+}
+function registerDecisionWrites(server2, conn2) {
+  registerContractTool(server2, createDecisionContract, async (params) => {
+    const { defaultOption, deadlineHours: deadlineHours2, impactedCards, tagNames, raisedByPr, ...rest } = params;
+    const res = await conn2.createDecision({
+      ...rest,
+      defaultOption,
+      deadlineHours: deadlineHours2,
+      impactedCards,
+      tagNames,
+      raisedByPr
+    });
+    const refused = res.refused.length > 0 ? `
+Not linked: ${res.refused.map((r) => `${r.ref} (${r.reason})`).join("; ")}` : "";
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Raised decision ${res.slug} \u2014 ${res.url}
+Blocking ${res.impactedLinked.length} card(s).${refused}`
+        }
+      ]
+    };
+  });
+  registerContractTool(server2, voteDecisionContract, async (params) => {
+    const res = await conn2.voteDecision(params);
+    const tally = res.options.map((o) => `${o.label}: ${o.votes}`).join(", ");
+    return { content: [{ type: "text", text: `Voted on ${res.slug}. Tally \u2014 ${tally}.` }] };
+  });
+  registerContractTool(server2, resolveDecisionContract, async (params) => {
+    const res = await conn2.resolveDecision(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Settled ${res.slug} as "${res.chosenOption}". ${res.impactedCount} card(s) were written back to and are no longer blocked.`
+        }
+      ]
+    };
+  });
+  registerContractTool(server2, updateDecisionContract, async (params) => {
+    const res = await conn2.updateDecision(params);
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Updated ${res.slug} \u2014 ${res.status}, ${res.impactedCount} impacted card(s), deadline ${res.deadlineAt}.`
+        }
+      ]
+    };
+  });
+}
+function registerDecisionTools(server2, conn2) {
+  registerDecisionReads(server2, conn2);
+  registerDecisionWrites(server2, conn2);
+}
+
 // src/tools/index.ts
 function registerAllTools(server2, conn2) {
   registerProjectTools(server2, conn2);
@@ -5467,6 +5939,7 @@ function registerAllTools(server2, conn2) {
   registerIntegrationTools(server2, conn2);
   registerDriveTools(server2, conn2);
   registerMeetingTools(server2, conn2);
+  registerDecisionTools(server2, conn2);
 }
 
 // src/cli.ts
@@ -5497,11 +5970,5 @@ var server = new McpServer({
 registerAllTools(server, conn);
 var transport = new StdioServerTransport();
 await server.connect(transport);
-process.on("SIGINT", () => {
-  conn.disconnect();
-  process.exit(0);
-});
-process.on("SIGTERM", () => {
-  conn.disconnect();
-  process.exit(0);
-});
+var stop = installLifecycle(conn);
+server.server.onclose = () => stop();

package/dist/{connection-B7CwszOV.d.ts → connection-DclP31lm.d.ts}

@@ -1,4 +1,5 @@
-import { ListDriveFilesResponse, ReadDriveFileResponse, DriveFileDTO, DeleteDriveFileResponse, ProjectIntegrationsSummary, GaAnalyticsSummaryDTO, ProjectChannelDTO, ReadChannelMessagesResponse, PostChannelMessageResponse, ListMeetingsResponse, MeetingForAgent, ReadMeetingTranscriptResponse, MeetingChecklistItemForAgent } from '@project/shared';
+import { io, Socket } from 'socket.io-client';
+import { ListDriveFilesResponse, ReadDriveFileResponse, DriveFileDTO, DeleteDriveFileResponse, ProjectIntegrationsSummary, GaAnalyticsSummaryDTO, ProjectChannelDTO, ReadChannelMessagesResponse, PostChannelMessageResponse, CreateProjectDecisionRequest, CreateProjectDecisionResponse, ListProjectDecisionsRequest, ProjectDecisionRow, ProjectDecisionDetail, VoteProjectDecisionRequest, ResolveProjectDecisionRequest, UpdateProjectDecisionRequest, ListMeetingsResponse, MeetingForAgent, ReadMeetingTranscriptResponse, MeetingChecklistItemForAgent } from '@project/shared';
 
 interface ConveyorMcpConfig {
     apiUrl: string;
@@ -310,12 +311,20 @@ interface PrioritySummary {
     color: string;
     description?: string | null;
 }
+/**
+ * Creates the underlying socket. Defaults to socket.io's `io`; tests inject a
+ * fake so the reconnect wiring in `connect()` can be driven without a server.
+ */
+type ConveyorSocketFactory = (url: string, options: Parameters<typeof io>[1]) => Pick<Socket, "on" | "emit" | "close" | "connect" | "disconnect">;
 declare class ConveyorConnection {
     private socket;
     private config;
+    private socketFactory;
     /** project slug → id, for resolving `<project>/<card>` card paths. */
     private projectSlugIds;
-    constructor(config: ConveyorMcpConfig);
+    /** Session rooms this connection has joined, replayed after every reconnect. */
+    private subscribedSessionIds;
+    constructor(config: ConveyorMcpConfig, socketFactory?: ConveyorSocketFactory);
     get projectId(): string;
     private resolveProjectId;
     /** The configured default board (CONVEYOR_SUBPROJECT_ID), if any. */
@@ -329,6 +338,16 @@ declare class ConveyorConnection {
      */
     private resolveSubProjectId;
     private normalizeProjectList;
+    /**
+     * Re-join every room this connection needs.
+     *
+     * Runs on the FIRST connect and on every reconnect. A socket.io reconnect
+     * starts a fresh server-side socket that belongs to no rooms, and Cloud Run
+     * cuts each websocket at its 60-minute request limit, so a subscribe sent
+     * only once left long-lived MCP connections silently outside the project room
+     * for the rest of the day.
+     */
+    private rejoinRooms;
     connect(): Promise<void>;
     private call;
     /**
@@ -670,6 +689,27 @@ declare class ConveyorConnection {
         text: string;
         threadTs?: string;
     }): Promise<PostChannelMessageResponse>;
+    createDecision(params: Omit<CreateProjectDecisionRequest, "projectId"> & {
+        projectId?: string;
+    }): Promise<CreateProjectDecisionResponse>;
+    listDecisions(params: Omit<ListProjectDecisionsRequest, "projectId"> & {
+        projectId?: string;
+    }): Promise<{
+        decisions: ProjectDecisionRow[];
+    }>;
+    getDecision(params: {
+        projectId?: string;
+        decision: string;
+    }): Promise<ProjectDecisionDetail>;
+    voteDecision(params: Omit<VoteProjectDecisionRequest, "projectId"> & {
+        projectId?: string;
+    }): Promise<ProjectDecisionDetail>;
+    resolveDecision(params: Omit<ResolveProjectDecisionRequest, "projectId"> & {
+        projectId?: string;
+    }): Promise<ProjectDecisionDetail>;
+    updateDecision(params: Omit<UpdateProjectDecisionRequest, "projectId"> & {
+        projectId?: string;
+    }): Promise<ProjectDecisionDetail>;
     listMeetings(params: {
         projectId?: string;
         limit?: number;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-export { A as ActivePtySession, d as ConveyorConnection, e as ConveyorMcpConfig, P as PtyAttachSnapshot, c as PtyDataChunk } from './connection-B7CwszOV.js';
+export { A as ActivePtySession, d as ConveyorConnection, e as ConveyorMcpConfig, P as PtyAttachSnapshot, c as PtyDataChunk } from './connection-DclP31lm.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-XLDG5QEX.js";
+} from "./chunk-77XLXIFP.js";
 export {
   ConveyorConnection,
   attachTunnel,

package/dist/tunnel-cli.js

@@ -2,9 +2,12 @@
 import {
   runTunnel
 } from "./chunk-HIVOGGE3.js";
+import {
+  watchForClientExit
+} from "./chunk-5KU3QS6A.js";
 import {
   ConveyorConnection
-} from "./chunk-XLDG5QEX.js";
+} from "./chunk-77XLXIFP.js";
 
 // src/tunnel-cli.ts
 var HELP = `conveyor-tunnel \u2014 attach your local terminal to a cloud Claude Code session.
@@ -125,8 +128,7 @@ function cleanupAndExit(code) {
   conn.disconnect();
   process.exit(code);
 }
-process.on("SIGINT", () => cleanupAndExit(0));
-process.on("SIGTERM", () => cleanupAndExit(0));
+watchForClientExit(() => cleanupAndExit(0), { watchStdin: false });
 try {
   await conn.connect();
   log("Connected to Conveyor API.");

package/dist/tunnel.d.ts

@@ -1,4 +1,5 @@
-import { A as ActivePtySession, P as PtyAttachSnapshot, c as PtyDataChunk } from './connection-B7CwszOV.js';
+import { A as ActivePtySession, P as PtyAttachSnapshot, c as PtyDataChunk } from './connection-DclP31lm.js';
+import 'socket.io-client';
 import '@project/shared';
 
 /**

package/dist/wait-cli.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
+import {
+  watchForClientExit
+} from "./chunk-5KU3QS6A.js";
 import {
   ConveyorConnection
-} from "./chunk-XLDG5QEX.js";
+} from "./chunk-77XLXIFP.js";
 import {
   runWait
 } from "./chunk-OPZL4NDT.js";
@@ -257,8 +260,7 @@ function interrupt() {
   exiting = true;
   emitResult({ reason: "interrupted" }, () => shutdown(0));
 }
-process.on("SIGINT", interrupt);
-process.on("SIGTERM", interrupt);
+watchForClientExit(interrupt, { resumeStdin: true });
 try {
   await conn.connect();
 } catch (err) {

package/dist/wait-runner.d.ts

@@ -1,5 +1,6 @@
-import { C as CardCollectionPage, a as CardCollectionDelta } from './connection-B7CwszOV.js';
+import { C as CardCollectionPage, a as CardCollectionDelta } from './connection-DclP31lm.js';
 import { WaitFilter, WaitResult } from './wait.js';
+import 'socket.io-client';
 import '@project/shared';
 
 /**

package/dist/wait.d.ts

@@ -1,4 +1,5 @@
-import { b as CardCollectionItem } from './connection-B7CwszOV.js';
+import { b as CardCollectionItem } from './connection-DclP31lm.js';
+import 'socket.io-client';
 import '@project/shared';
 
 /**

package/package.json

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