@rallycry/conveyor-mcp 5.0.15 → 5.0.17

package/dist/chunk-IRVUONC3.js

@@ -0,0 +1,2559 @@
+// ../shared/dist/chunk-SFSQ7NKP.js
+import { z } from "zod";
+import { z as z2 } from "zod";
+var DEFAULT_SONNET_MODEL = "claude-sonnet-5-5";
+var DEFAULT_OPUS_MODEL = "claude-opus-5-5";
+var DEFAULT_HAIKU_MODEL = "claude-haiku-4-5-20251001";
+var FABLE_MODEL = "claude-fable-5-1";
+var PREVIOUS_SONNET_MODEL = "claude-sonnet-5";
+var PREVIOUS_OPUS_MODEL = "claude-opus-5";
+function formatModelId(provider, model) {
+  return `${provider}/${model}`;
+}
+var JEV_MODEL = "jev-1.13.0";
+var JEV_MODEL_ID = formatModelId("typesafe", JEV_MODEL);
+var JEV_ZEN_MODEL = "jev-1.13";
+var JEV_ZEN_MODEL_ID = formatModelId("zen", JEV_ZEN_MODEL);
+var JEV_INPUT_PRICE_PER_TOKEN = 0.042 / 1e6;
+var JEV_STATE_MAX_CHARS = 1e5;
+var PTY_STREAM_PORT_BASE = 7420;
+var PTY_STREAM_PORT_ATTEMPTS = 8;
+var PREVIEW_PORT_DENY_LIST = [
+  5432,
+  6379,
+  9200,
+  ...Array.from({ length: PTY_STREAM_PORT_ATTEMPTS }, (_, i) => PTY_STREAM_PORT_BASE + i)
+];
+function normalizeCheckpointPath(value) {
+  let normalized = value.trim().replace(/\/{2,}/g, "/");
+  normalized = normalized.split("/").filter((segment) => segment !== ".").join("/");
+  while (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
+  return normalized;
+}
+var checkpointPathSchema = z.string().transform(normalizeCheckpointPath).pipe(
+  z.string().min(1).refine((value) => value !== ".", "Checkpoint paths must name a repository entry").refine((value) => !value.startsWith("/"), "Checkpoint paths must be repository-relative").refine(
+    (value) => !/^[A-Za-z]:[\\/]/.test(value) && !value.includes("\\"),
+    "Checkpoint paths must use repository-relative POSIX syntax"
+  ).refine(
+    (value) => !value.split("/").includes(".."),
+    "Checkpoint paths must not traverse a parent directory"
+  )
+);
+var secretNameSchema = z.string().regex(/^[A-Za-z_][A-Za-z0-9_]*$/);
+var checkpointKeySchema = z.string().regex(/^[0-9a-f]{64}$/);
+var checkpointDigestRefSchema = z.string().regex(/^[^\s@]+@sha256:[0-9a-f]{64}$/);
+var ACTIONS_PREBAKE_REGISTRY_PATTERN = /^[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?(?::(?:[1-9][0-9]{0,4}))?(?:\/[a-z0-9]+(?:[._-][a-z0-9]+)*)*$/;
+var actionsPrebakeRegistrySchema = z.string().trim().min(1).regex(
+  ACTIONS_PREBAKE_REGISTRY_PATTERN,
+  "Actions prebake registry must be a lowercase host[:port] with an optional path prefix"
+).refine((value) => {
+  const port = /:([0-9]+)(?:\/|$)/.exec(value)?.[1];
+  return !port || Number(port) <= 65535;
+}, "Actions prebake registry port must be between 1 and 65535");
+function uniqueSortedArray(item, minimum = 0) {
+  return z.array(item).min(minimum).superRefine((values, ctx) => {
+    if (new Set(values).size !== values.length) {
+      ctx.addIssue({ code: z.ZodIssueCode.custom, message: "Duplicate values are not allowed" });
+    }
+  }).transform((values) => [...values].sort());
+}
+var projectCheckpointSettingsSchema = z.object({
+  enabled: z.literal(true),
+  cacheCommand: z.string().trim().min(1),
+  cacheInputPaths: uniqueSortedArray(checkpointPathSchema, 1),
+  reusableArtifactPaths: uniqueSortedArray(checkpointPathSchema, 1),
+  finalizeCommand: z.string().trim().min(1),
+  credentialEpoch: z.string().trim().min(1),
+  requiredSecretNames: uniqueSortedArray(secretNameSchema).optional(),
+  optionalSecretNames: uniqueSortedArray(secretNameSchema).optional(),
+  bakeWebAppBuild: z.boolean().optional()
+}).superRefine((checkpoint, ctx) => {
+  const required = new Set(checkpoint.requiredSecretNames ?? []);
+  for (const name of checkpoint.optionalSecretNames ?? []) {
+    if (required.has(name)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ["optionalSecretNames"],
+        message: "A secret cannot be both required and optional"
+      });
+    }
+  }
+});
+var CARD_DESCRIPTION_MAX = 255;
+var CARD_DESCRIPTION_LIMIT_MESSAGE = `Card descriptions are capped at ${CARD_DESCRIPTION_MAX} characters \u2014 write 1-2 plain sentences a non-engineer can read; put technical detail in the plan or card chat.`;
+var CARD_DESCRIPTION_FIELD_HINT = `max ${CARD_DESCRIPTION_MAX} chars, 1-2 plain sentences a non-engineer can read \u2014 put technical detail in the plan`;
+var MAX_MANUAL_TESTS_PER_TASK = 5;
+var MAX_MANUAL_TEST_TITLE_LENGTH = 200;
+var ManualTestItemsSchema = z2.array(z2.object({ title: z2.string().min(1).max(MAX_MANUAL_TEST_TITLE_LENGTH) })).min(1).max(MAX_MANUAL_TESTS_PER_TASK);
+function describeManualTestRejection(item) {
+  return item.reason === "cap" ? `Rejected "${item.title}": the card already holds ${MAX_MANUAL_TESTS_PER_TASK} manual tests. Use remove_manual_test or edit_manual_test to consolidate.` : `Rejected "${item.title}": names an automated step (lint, tests, CI, shell); manual tests describe what a person does in the app.`;
+}
+var DEFAULT_CI_WAIT_TIMEOUT_MINUTES = 45;
+var MAX_CI_WAIT_TIMEOUT_MINUTES = 180;
+var SEVERITY_ENUM = [
+  "DEBUG",
+  "INFO",
+  "NOTICE",
+  "WARNING",
+  "ERROR",
+  "CRITICAL",
+  "ALERT",
+  "EMERGENCY"
+];
+var MAX_LINE_CHARS = 400;
+var DEFAULT_SINCE_MINUTES = 60;
+var FULL_MODE_MAX_ENTRIES = 10;
+function truncateLine(text) {
+  const oneLine = text.replace(/\s*\n\s*/g, " \u23CE ");
+  if (oneLine.length <= MAX_LINE_CHARS) return oneLine;
+  const overflow = oneLine.length - MAX_LINE_CHARS;
+  return `${oneLine.slice(0, MAX_LINE_CHARS)}\u2026[+${overflow}c]`;
+}
+function entrySource(entry) {
+  return entry.resource.service_name ?? entry.resource.pod_name ?? entry.resource.database_id ?? entry.resourceType ?? "-";
+}
+var PAYLOAD_SKIP_KEYS = /* @__PURE__ */ new Set(["message", "severity", "timestamp", "level", "stack"]);
+var PAYLOAD_PRIORITY = [
+  "error",
+  "outcome",
+  "serviceName",
+  "methodName",
+  "userId",
+  "taskId",
+  "sessionId",
+  "workspaceId",
+  "projectId",
+  "durationMs"
+];
+var PAYLOAD_VALUE_MAX_CHARS = 160;
+function compactPayloadValue(value) {
+  const raw = typeof value === "string" ? value : JSON.stringify(value);
+  const flat = (raw ?? "undefined").replace(/\s+/g, " ");
+  const quoted = typeof value === "string" && /[\s"]/.test(flat) ? JSON.stringify(flat) : flat;
+  return quoted.length > PAYLOAD_VALUE_MAX_CHARS ? `${quoted.slice(0, PAYLOAD_VALUE_MAX_CHARS)}\u2026` : quoted;
+}
+function formatPayloadSuffix(payloadJson) {
+  if (!payloadJson) return "";
+  let parsed;
+  try {
+    parsed = JSON.parse(payloadJson);
+  } catch {
+    const flat = payloadJson.replace(/\s+/g, " ");
+    return ` | payload=${flat.slice(0, PAYLOAD_VALUE_MAX_CHARS)}\u2026[truncated, use full]`;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return "";
+  const obj = parsed;
+  const rank = (key) => {
+    const i = PAYLOAD_PRIORITY.indexOf(key);
+    return i === -1 ? PAYLOAD_PRIORITY.length : i;
+  };
+  const parts = Object.keys(obj).filter((k) => !PAYLOAD_SKIP_KEYS.has(k) && obj[k] !== void 0 && obj[k] !== null).sort((a, b) => rank(a) - rank(b) || a.localeCompare(b)).map((k) => `${k}=${compactPayloadValue(obj[k])}`);
+  return parts.length > 0 ? ` | ${parts.join(" ")}` : "";
+}
+function httpPrefixOf(entry) {
+  return entry.httpRequest?.status ? `http ${entry.httpRequest.status} ${entry.httpRequest.method ?? ""} ${entry.httpRequest.url ?? ""}`.trim() + " \u2014 " : "";
+}
+function formatLogEntryLine(entry) {
+  const httpPrefix = httpPrefixOf(entry);
+  return `${entry.timestamp} ${entry.severity.padEnd(7)} [${entrySource(entry)}] ${truncateLine(
+    `${httpPrefix}${entry.message}${formatPayloadSuffix(entry.payload)}`
+  )}`;
+}
+function formatPayloadFull(payloadJson) {
+  let parsed;
+  try {
+    parsed = JSON.parse(payloadJson);
+  } catch {
+    return payloadJson;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    return JSON.stringify(parsed, null, 2);
+  }
+  const obj = Object.fromEntries(
+    Object.entries(parsed).filter(([k]) => !PAYLOAD_SKIP_KEYS.has(k))
+  );
+  return Object.keys(obj).length > 0 ? JSON.stringify(obj, null, 2) : "";
+}
+function formatLogEntryFull(entry) {
+  const head = `${entry.timestamp} ${entry.severity} [${entrySource(entry)}]${entry.insertId ? ` insertId=${entry.insertId}` : ""}`;
+  const payload = entry.payload ? formatPayloadFull(entry.payload) : "";
+  return [
+    head,
+    `${httpPrefixOf(entry)}${entry.message}`,
+    ...payload ? [payload] : [],
+    ...entry.payloadTruncated ? ["\u2026[payload truncated server-side]"] : []
+  ].join("\n");
+}
+function fullModeLimit(limit) {
+  return Math.min(limit ?? FULL_MODE_MAX_ENTRIES, FULL_MODE_MAX_ENTRIES);
+}
+function formatFullEntries(entries) {
+  return entries.map((entry, i) => (i === 0 ? "" : "\n") + formatLogEntryFull(entry));
+}
+async function runQueryGcpLogs(port, params, now = Date.now) {
+  const startTime = params.startTime ?? new Date(now() - (params.sinceMinutes ?? DEFAULT_SINCE_MINUTES) * 6e4).toISOString();
+  const full = params.full === true;
+  const limit = full ? fullModeLimit(params.limit) : params.limit;
+  const result = await port.queryGcpLogs({
+    projectId: params.projectId,
+    env: params.env,
+    severity: params.severity,
+    services: params.services,
+    sqlInstances: params.sqlInstances,
+    allServices: params.allServices,
+    search: params.search,
+    filter: params.filter,
+    startTime,
+    endTime: params.endTime,
+    limit,
+    pageToken: params.pageToken,
+    ...full ? { full: true } : {}
+  });
+  if (result.error) return result.error;
+  const header = [
+    `env=${params.env ?? "prod"}`,
+    `window=${startTime}\u2192${params.endTime ?? "now"}`,
+    ...params.severity ? [`minSeverity=${params.severity}`] : [],
+    `scope=${result.scopedServices ? `[${result.scopedServices.join(", ")}]` : "all"}`,
+    `entries=${result.entries.length}`,
+    ...full ? ["full=true"] : []
+  ].join(" ");
+  const lines = full ? formatFullEntries(result.entries) : result.entries.map(formatLogEntryLine);
+  const footer = result.nextPageToken ? [`-- more available: pass pageToken="${result.nextPageToken}" to continue`] : [];
+  if (lines.length === 0) {
+    return [
+      header,
+      "(no matching log entries \u2014 widen the window, lower minSeverity, or drop filters)"
+    ].join("\n");
+  }
+  return [header, ...lines, ...footer].join("\n");
+}
+async function runQueryGrafanaLogs(port, params, now = Date.now) {
+  const startTime = params.startTime ?? new Date(now() - (params.sinceMinutes ?? DEFAULT_SINCE_MINUTES) * 6e4).toISOString();
+  const result = await port.queryGrafanaLogs({
+    projectId: params.projectId,
+    env: params.env,
+    level: params.level,
+    services: params.services,
+    search: params.search,
+    logql: params.logql,
+    startTime,
+    endTime: params.endTime,
+    limit: params.limit
+  });
+  if (result.error) return result.error;
+  const header = [
+    `env=${params.env ?? "prod"}`,
+    `window=${startTime}\u2192${params.endTime ?? "now"}`,
+    ...params.level ? [`minLevel=${params.level}`] : [],
+    ...result.logql ? [`logql=${truncateLine(result.logql)}`] : [],
+    `entries=${result.entries.length}`
+  ].join(" ");
+  const lines = result.entries.map(formatLogEntryLine);
+  const oldest = result.entries.map((e) => e.timestamp).sort()[0];
+  const footer = result.hasMore ? [`-- hit the limit: older lines exist \u2014 pass endTime="${oldest}" to page further back`] : [];
+  if (lines.length === 0) {
+    return [
+      header,
+      "(no matching log entries \u2014 widen the window, lower minLevel, or drop filters)"
+    ].join("\n");
+  }
+  return [header, ...lines, ...footer].join("\n");
+}
+
+// ../shared/dist/tool-contracts/index.js
+var f = {
+  string(opts) {
+    return { kind: "string", ...opts };
+  },
+  number(opts) {
+    return { kind: "number", ...opts };
+  },
+  boolean(opts) {
+    return { kind: "boolean", ...opts };
+  },
+  enum(values, opts) {
+    return { kind: "enum", values, ...opts };
+  },
+  array(item, opts) {
+    return { kind: "array", item, ...opts };
+  },
+  object(fields, opts) {
+    return { kind: "object", fields, ...opts };
+  },
+  optional(inner) {
+    return { kind: "optional", inner };
+  },
+  nullable(inner) {
+    return { kind: "nullable", inner };
+  }
+};
+function compileString(z3, spec) {
+  let schema = z3.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(z3, spec) {
+  let schema = z3.number();
+  if (spec.int) schema = schema.int();
+  if (spec.positive) schema = schema.positive();
+  if (spec.nonnegative) schema = schema.nonnegative();
+  if (spec.min !== void 0) schema = schema.min(spec.min);
+  if (spec.max !== void 0) schema = schema.max(spec.max);
+  return schema;
+}
+function compileArray(z3, spec) {
+  let schema = z3.array(compileField(z3, spec.item));
+  if (spec.min !== void 0) schema = schema.min(spec.min);
+  if (spec.max !== void 0) schema = schema.max(spec.max);
+  return schema;
+}
+function compileBase(z3, spec) {
+  switch (spec.kind) {
+    case "string":
+      return compileString(z3, spec);
+    case "number":
+      return compileNumber(z3, spec);
+    case "boolean":
+      return z3.boolean();
+    case "enum":
+      return z3.enum([...spec.values]);
+    case "array":
+      return compileArray(z3, spec);
+    case "object":
+      return z3.object(compileShape(z3, spec.fields));
+  }
+}
+function descriptionOf(spec) {
+  if (spec.kind === "optional" || spec.kind === "nullable") return descriptionOf(spec.inner);
+  return spec.desc;
+}
+function compileUndescribed(z3, spec) {
+  if (spec.kind === "optional") {
+    return compileUndescribed(z3, spec.inner).optional();
+  }
+  if (spec.kind === "nullable") {
+    return compileUndescribed(z3, spec.inner).nullable();
+  }
+  return compileBase(z3, spec);
+}
+function compileField(z3, spec) {
+  const schema = compileUndescribed(z3, spec);
+  const desc = descriptionOf(spec);
+  return desc === void 0 ? schema : schema.describe(desc);
+}
+function compileShape(z3, fields) {
+  const shape = {};
+  for (const [key, spec] of Object.entries(fields)) {
+    shape[key] = compileField(z3, spec);
+  }
+  return shape;
+}
+function defineToolContract(contract) {
+  return contract;
+}
+var mcpProjectId = f.optional(f.string({ desc: "Target Conveyor project ID" }));
+var cardDescriptionDesc = (lead) => `${lead} \u2014 ${CARD_DESCRIPTION_FIELD_HINT}`;
+var storyPointValueDesc = "Story point value (1=Common, 2=Magic, 3=Rare, 5=Unique)";
+var priorityValueDesc = "Priority value from manage_priorities list (1 = the project's highest level; seeded defaults are 1=High, 2=Medium, 3=Low)";
+var getTaskContract = defineToolContract({
+  name: "get_task",
+  agent: {
+    description: "Look up any task by slug or ID. Returns JSON with id, slug, title, description, plan, status, branch, githubPRNumber, githubPRUrl, storyPoints. For children use list_subtasks.",
+    fields: {
+      slug_or_id: f.string({ desc: "The task slug (e.g. 'my-task') or CUID" })
+    }
+  },
+  mcp: {
+    description: "Get full task details including plan, chat history, PR info, subtasks, and build status. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({
+        // 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"
+      })
+    }
+  }
+});
+var postToChatContract = defineToolContract({
+  name: "post_to_chat",
+  agent: {
+    description: "Post a message to the task chat for the team to see. Your turn output is NOT shown in chat, so this is the only way the team sees your status, summaries, and questions. Omit task_id to post to the current task's chat; pass a child's ID to message its chat.",
+    fields: {
+      message: f.optional(f.string({ desc: "The message to post to the team" })),
+      content: f.optional(
+        f.string({
+          desc: "Alias of `message` (the external conveyor-mcp surface names this field `content`). Provide exactly one of the two."
+        })
+      ),
+      task_id: f.optional(
+        f.string({
+          desc: "Child task ID to post to. Omit to post to the current task's chat."
+        })
+      ),
+      milestone: f.optional(
+        f.enum(["plan_ready", "implementation_complete", "blocked"], {
+          desc: "Declare a narrative milestone instead of a routine update. Use SPARINGLY \u2014 only when the plan is ready (plan_ready), implementation is complete (implementation_complete), or you are parked and cannot continue until a human acts (blocked). `blocked` posts a note and enables reply delivery but pages nobody; to page a person, ask them with AskUserQuestion. Never use `blocked` for a finished plan, finished work, or a tool error you can retry. Milestones appear on the card's activity timeline and in Slack."
+        })
+      )
+    }
+  },
+  mcp: {
+    description: "Post a message to a task's chat. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The task ID" }),
+      content: f.optional(f.string({ desc: "Message content" })),
+      message: f.optional(
+        f.string({
+          desc: "Alias of `content` (the in-pod agent surface names this field `message`). Provide exactly one of the two."
+        })
+      )
+    }
+  }
+});
+var readTaskChatContract = defineToolContract({
+  name: "read_task_chat",
+  agent: {
+    description: "Read recent human/user chat messages for a task. Omit task_id for the current task; pass a child ID for a child's chat. For agent logs use get_execution_logs.",
+    fields: {
+      limit: f.optional(f.number({ desc: "Number of recent messages to fetch (default 20)" })),
+      task_id: f.optional(
+        f.string({
+          desc: "Child task ID to read chat from. Omit to read the current task's chat."
+        })
+      )
+    }
+  },
+  mcp: {
+    description: "Read messages from a task's chat. Pass projectId to target a specific project; otherwise the configured default project is used. For agent execution logs use get_task_logs.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The task ID" }),
+      limit: f.optional(f.number({ desc: "Max messages to return (default 50)" }))
+    }
+  }
+});
+var listTagsDetail = f.optional(
+  f.enum(["summary", "full"], {
+    desc: `"summary" (default) returns one compact row per tag with a contextPathCount. "full" also ships each tag's contextPaths inline (each link with its verification status). Full mode can exceed a client's tool-output budget on a large glossary; use get_tag for one term instead.`
+  })
+);
+var listTagsContract = defineToolContract({
+  name: "list_tags",
+  agent: {
+    description: "List the whole project glossary in one call. The default summary gives every tag's id, name, color, description, parent/child tag ids, whether it carries a full overview (hasOverview), its attachmentCount (files labelled as examples of the term), and its contextPathCount (the rule/doc/file/folder links it wires into agent context \u2014 `0` means none). Pass detail: \"full\" to ship the contextPaths themselves inline. Use get_tag for one term's full overview and full link verification. Use the ids with get_tag / update_tag.",
+    fields: {
+      detail: listTagsDetail
+    }
+  },
+  mcp: {
+    description: 'List all project tags in one call. The default summary gives names, IDs, colors, descriptions, hierarchy (parent/child ids), a hasOverview flag, an attachmentCount (files labelled as examples of the term \u2014 read the tiles with list_tag_attachments), and a contextPathCount (the rule/doc/file/folder links each tag wires into agent context \u2014 `0` means none). Pass detail: "full" to ship the contextPaths themselves inline. Call get_tag for one term\'s full overview and full link verification. Pass projectId to target a specific project; otherwise the configured default project is used.',
+    fields: {
+      projectId: mcpProjectId,
+      detail: listTagsDetail
+    }
+  }
+});
+var SEARCH_STATUSES = [
+  "Planning",
+  "Open",
+  "InProgress",
+  "ReviewPR",
+  "ReviewDev",
+  "ReviewLive",
+  "Complete",
+  "Cancelled"
+];
+var SEARCH_CARD_TYPES = ["task", "incident", "suggestion", "decision"];
+var searchFilterFields = {
+  tagNames: f.optional(
+    f.array(f.string(), {
+      desc: 'Tag names to filter by, e.g. ["agent", "mcp"]. Names, not ids, and matched case-insensitively. Use list_tags to see the glossary.'
+    })
+  ),
+  tagMatch: f.optional(
+    f.enum(["any", "all"], {
+      desc: 'How to combine tagNames: "any" (default) returns cards carrying at least one, "all" returns only cards carrying every one.'
+    })
+  ),
+  includeChildTags: f.optional(
+    f.boolean({
+      desc: "Also match cards carrying any descendant of the named tags in the tag hierarchy. Use this to sweep a whole area from its parent tag, e.g. cloud-build also matching release and deployment. Default false."
+    })
+  ),
+  searchQuery: f.optional(f.string({ desc: "Text search on title and description" })),
+  statusFilters: f.optional(
+    f.array(f.enum(SEARCH_STATUSES), { desc: "Filter by one or more statuses" })
+  ),
+  typeFilters: f.optional(
+    f.array(f.enum(SEARCH_CARD_TYPES), {
+      desc: 'Card types to include (default ["task"]). Pass e.g. ["incident"] or list several to search across types.'
+    })
+  ),
+  assigneeId: f.optional(f.string({ desc: "Filter by assigned user ID" })),
+  unassigned: f.optional(
+    f.boolean({
+      desc: "Only return cards with no assignee (mutually exclusive with assigneeId)"
+    })
+  ),
+  limit: f.optional(f.number({ desc: "Max results to return (default 20)" }))
+};
+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 searchTasksContract = defineToolContract({
+  name: "search_tasks",
+  agent: {
+    description: `Search this project's cards by tag, text, status, type, and/or assignment. Tags are the project's glossary, so tagNames is the fastest way to find prior work in the area you are touching \u2014 e.g. every ReviewPR card tagged "mcp". Searches the whole project, not just the current card. Defaults to type=task \u2014 pass typeFilters for incidents/suggestions. ${searchResultNote}`,
+    fields: searchFilterFields
+  },
+  mcp: {
+    description: `Search cards by tag name, text query, status, type, and/or assignment. Defaults to type=task \u2014 pass typeFilters to include incidents/suggestions. Pass projectId to target a specific project; otherwise the configured default project is used. Use tag names like 'agent-runner', not IDs. ${searchResultNote}`,
+    fields: {
+      projectId: mcpProjectId,
+      ...searchFilterFields,
+      subProjectId: f.optional(
+        f.nullable(
+          f.string({
+            desc: "Filter to a sub-project board. Omit to use the connection's default board (CONVEYOR_SUBPROJECT_ID) when set, else the whole project; pass null to force the whole project. Use list_accessible_subprojects to find board IDs."
+          })
+        )
+      )
+    }
+  }
+});
+var getConnectionContextContract = defineToolContract({
+  name: "get_connection_context",
+  agent: {
+    description: "Resolve WHAT this session is bound to \u2014 call this FIRST, before inferring anything from names or branch strings. Returns the current task (id, title, status, branch, baseBranch, whether it is a pack parent, and its parentTaskId when it is itself a child), its project (id, name), and the acting agent (id, model, mode, isAuto). This is the pod-side half of the same tool the external MCP surface exposes, so a shared skill can open with one call in both places; it reports no user account, because a pod is bound to a card rather than to a person's session.",
+    fields: {}
+  },
+  mcp: {
+    description: "Resolve WHO this connection is and WHAT project/board it points at \u2014 call this FIRST, before inferring anything from names. Returns the effective account, project, and board (sub-project) each with BOTH its immutable ID and its human-readable name/slug, the granted capabilities (read/create/update/chat/files/build), management URLs, and a one-line summary. Removes the ambiguity between a project's canonical name and a board label. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId
+    }
+  }
+});
+var tasksContracts = [
+  getTaskContract,
+  postToChatContract,
+  readTaskChatContract,
+  listTagsContract,
+  searchTasksContract,
+  getConnectionContextContract
+];
+var STATUS_ENUM = [
+  "Planning",
+  "Open",
+  "InProgress",
+  "ReviewPR",
+  "ReviewDev",
+  "ReviewLive",
+  "Complete",
+  "Cancelled"
+];
+var RISK_ENUM = ["critical", "high", "medium", "low"];
+var GITHUB_BRANCH_MEANING = "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).";
+var GITHUB_BRANCH_DESC = "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.";
+var updateTaskContract = defineToolContract({
+  name: "update_task",
+  agent: {
+    description: "Update the CURRENT task's title, description, plan, githubBranch, or status \u2014 the one tool the shared Conveyor skills use for card writes, so the same skill text works here and in a local MCP session. Pass task_id ONLY with status, to move one of this card's children (claim it InProgress, promote it to Open); every other field always applies to the current task, because the server scopes plan/title writes to this session. Status rides the same path a human or a build uses, so watchdog and board semantics hold \u2014 for an emergency override that skips those, use force_update_task_status.",
+    fields: {
+      title: f.optional(f.string({ desc: "New title" })),
+      description: f.optional(f.string({ desc: cardDescriptionDesc("New description") })),
+      plan: f.optional(f.string({ desc: "New plan (markdown)" })),
+      status: f.optional(f.enum(STATUS_ENUM, { desc: "New status" })),
+      // Not nullable here, unlike the mcp surface: the pod's underlying
+      // `updateTaskProperties` takes `githubBranch?: string` with no null
+      // branch, so a pod can RECORD a branch but cannot detach one. Offering
+      // null would advertise a write the server would silently drop.
+      githubBranch: f.optional(
+        f.string({
+          min: 1,
+          desc: `${GITHUB_BRANCH_MEANING} The pod does NOT validate this: the value is written through with no check that the ref exists on origin, and no guard against repointing the record away from the branch this pod is actually running on (which strands the compute). Push the branch first, and only name a branch this session genuinely owns. Detaching (clearing) a branch is not available from a pod \u2014 use the external MCP surface for that.`
+        })
+      ),
+      task_id: f.optional(
+        f.string({
+          // min:1 is load-bearing: "" is falsy, so an empty task_id would slip
+          // past both the refusal below and the child-routing branch, and
+          // silently update the CURRENT card — the exact mis-targeting this
+          // field's guard exists to prevent.
+          min: 1,
+          desc: "Child task ID to move. Valid ONLY alongside status \u2014 pairing it with title/description/plan/githubBranch is rejected rather than silently applied to the current card. Omit to update the current task."
+        })
+      )
+    }
+  },
+  mcp: {
+    description: "Update task fields: title, description, plan, status, risk, story points, priority, assignment, githubBranch, onHold, 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. Set onHold to park a card (true) or bring it back to the active board (false) without cancelling it. 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.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The task ID" }),
+      title: f.optional(f.string({ desc: "New title" })),
+      description: f.optional(f.string({ desc: cardDescriptionDesc("New description") })),
+      plan: f.optional(f.string({ desc: "New plan (markdown)" })),
+      status: f.optional(f.enum(STATUS_ENUM, { desc: "New status" })),
+      risk: f.optional(
+        f.nullable(
+          f.enum(RISK_ENUM, {
+            desc: "Risk level \u2014 how much important surface the task touches (critical/high/medium/low). Pass null to clear."
+          })
+        )
+      ),
+      storyPointValue: f.optional(
+        f.nullable(
+          f.number({
+            desc: `${storyPointValueDesc}. The tiers are per-project \u2014 a value the project has not configured is rejected. Pass null to clear it; a card beyond Planning with no story point is re-filled by identification.`
+          })
+        )
+      ),
+      priorityValue: f.optional(
+        f.nullable(
+          f.number({
+            desc: `${priorityValueDesc}. The levels are per-project \u2014 a value the project has not configured is rejected. Pass null to clear it.`
+          })
+        )
+      ),
+      assignedUserId: f.optional(f.nullable(f.string({ desc: "User ID to assign, or null" }))),
+      subProjectId: f.optional(
+        f.nullable(
+          f.string({
+            desc: "Assign the task to a sub-project board; null moves it back to the parent board. Omit to leave unchanged."
+          })
+        )
+      ),
+      githubBranch: f.optional(f.nullable(f.string({ desc: GITHUB_BRANCH_DESC }))),
+      onHold: f.optional(
+        f.boolean({
+          desc: "Park the card on hold (true) or return it to the active board (false). On hold hides the card from the active columns without cancelling it; a card already at an active work status is demoted to Open when parked."
+        })
+      ),
+      addTags: f.optional(
+        f.array(f.string(), {
+          desc: '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.'
+        })
+      ),
+      removeTags: f.optional(
+        f.array(f.string(), {
+          desc: "Tag names to remove from the card. Removing a tag the card doesn't have is a no-op."
+        })
+      )
+    }
+  }
+});
+var taskUpdateContracts = [updateTaskContract];
+var tagRef = f.string({
+  desc: "Tag id, or the exact tag name (case-insensitive)",
+  min: 1,
+  max: 100
+});
+var getTagContract = defineToolContract({
+  name: "get_tag",
+  agent: {
+    description: "Read one tag's full glossary entry: description, the full markdown overview (the term's spec \u2014 philosophy, mechanics, invariants), linked files/rules (each with its verified-link status \u2014 ok/stale/unchecked \u2014 from the periodic repo check), parent/child tags, active-card count, attachment count (files labelled as examples of the term), and recent revisions with their reasons. Call this whenever a chat message, plan, or tag list points at a term you need the full context for. A response with `overviewPath` set means the overview is sourced from that repo file \u2014 prefer Reading the path from your checkout (branch-correct); the served overview is materialized from the project's dev branch (the PR base; default branch when the repo has no dev branch) (`overviewSource.state`: ok/pending/stale).",
+    fields: {
+      tag: tagRef
+    }
+  },
+  mcp: {
+    description: "Read one tag's full glossary entry \u2014 description, markdown overview, context links (each with its verified-link status: ok/stale/unchecked plus last-checked provenance), parent/child tags, active-card count, attachment count (files labelled as examples of the term \u2014 read the tiles with list_tag_attachments), and recent revisions with provenance. A response with `overviewPath` set means the overview is sourced from that repo file at the project's dev branch (the PR base; default branch when the repo has no dev branch) (`overviewSource.state`: ok/pending/stale) \u2014 clients with a checkout can read the path directly for the branch-correct copy. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId,
+      tag: tagRef
+    }
+  }
+});
+var tagsContracts = [getTagContract];
+var mcpChecklistTaskId = f.string({ desc: "The task ID or slug" });
+var testStatuses = f.optional(
+  f.array(f.enum(["open", "approved", "rejected"]), {
+    desc: "Filter tests by status: open | approved | rejected"
+  })
+);
+var setManualTestItems = f.array(
+  f.object({
+    title: f.string({
+      min: 1,
+      max: MAX_MANUAL_TEST_TITLE_LENGTH,
+      desc: "One sentence a non-engineer can follow: where to go, what to do, what they should see. No commands, no code."
+    })
+  }),
+  {
+    min: 1,
+    max: MAX_MANUAL_TESTS_PER_TASK,
+    desc: `Manual tests to add. A card holds at most ${MAX_MANUAL_TESTS_PER_TASK}; most changes need 1, and a change with no user-visible behavior needs none.`
+  }
+);
+var setManualTestsBar = 'A manual test is a real user path in plain language ("Open a card with a PR: the Pull Request slat sits directly under Description"), not an engineering check. Never record lint, typecheck, unit tests, CI, curl, database, log, or deploy steps; those run automatically. Record at most 5 per card, usually 1, and none when the change has no user-visible behavior. Existing items with the same title are skipped; items that name an automated step or exceed the cap are rejected and reported back.';
+var titleToEdit = f.string({ min: 1, desc: "The current title of the manual test to edit" });
+var newTitle = f.string({ min: 1, desc: "The new title for the manual test" });
+var titleToRemove = f.string({ min: 1, desc: "The title of the manual test to remove" });
+var titleToApprove = f.string({ min: 1, desc: "The title of the manual test to approve" });
+var titleToReject = f.string({ min: 1, desc: "The title of the manual test to reject" });
+var rejectReason = f.string({
+  min: 1,
+  max: 2e3,
+  desc: "Why the test failed \u2014 what went wrong, shown to the team"
+});
+var listManualTestsContract = defineToolContract({
+  name: "list_manual_tests",
+  agent: {
+    description: "List the manual test checklist items for the current task. Use to see what manual verification steps have already been recorded.",
+    fields: {}
+  },
+  mcp: {
+    description: "List the manual test checklist items for a task. Pass projectId to target a specific project; otherwise the configured default project is used. Use to see what manual verification steps have already been recorded.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The task ID or slug (the value in a card URL, /cards/<slug>)" })
+    }
+  }
+});
+var queryManualTestsContract = defineToolContract({
+  name: "query_manual_tests",
+  agent: {
+    description: "Query manual tests across many tasks in this project, grouped by task. Filter by card status (ReviewDev, ReviewLive, Complete, ...) and/or test status (open | approved | rejected). Use to answer 'show all OPEN manual tests in ReviewDev' or 'show all REJECTED manual tests with the failing reason'. With no filters it defaults to the needs-attention view: open+rejected tests on ReviewDev/ReviewLive cards.",
+    fields: {
+      cardStatuses: f.optional(
+        f.array(f.string(), {
+          desc: 'Filter tasks by card status, e.g. ["ReviewDev", "ReviewLive"]'
+        })
+      ),
+      testStatuses
+    }
+  },
+  mcp: {
+    description: "Query manual tests across many tasks in a project, grouped by task. Filter by card status (e.g. ReviewDev, ReviewLive, Complete) and/or test status (open | approved | rejected). Use to answer questions like 'show all OPEN manual tests in ReviewDev' or 'show all REJECTED manual tests in ReviewDev/ReviewLive with the failing reason'. With no filters it defaults to the needs-attention view: open+rejected tests on ReviewDev/ReviewLive cards. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId,
+      cardStatuses: f.optional(
+        f.array(f.string(), {
+          desc: 'Filter tasks by card/column status, e.g. ["ReviewDev", "ReviewLive"]'
+        })
+      ),
+      testStatuses
+    }
+  }
+});
+var setManualTestsContract = defineToolContract({
+  name: "set_manual_tests",
+  agent: {
+    description: `Record the manual tests a person should run in the app to sign off on this card. ${setManualTestsBar}`,
+    fields: {
+      items: setManualTestItems
+    }
+  },
+  mcp: {
+    description: `Record the manual tests a person should run in the app to sign off on a card. Pass projectId to target a specific project; otherwise the configured default project is used. ${setManualTestsBar}`,
+    fields: {
+      projectId: mcpProjectId,
+      taskId: mcpChecklistTaskId,
+      items: setManualTestItems
+    }
+  }
+});
+var editManualTestContract = defineToolContract({
+  name: "edit_manual_test",
+  agent: {
+    description: "Rename an existing manual test step. Identify the test by its current title (case-insensitive); pass the new title to replace it. Use to correct or refine a recorded manual verification step.",
+    fields: {
+      title: titleToEdit,
+      newTitle
+    }
+  },
+  mcp: {
+    description: "Rename an existing manual test step on a task. Pass projectId to target a specific project; otherwise the configured default project is used. Identify the test by its current title (case-insensitive) and pass the new title to replace it.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: mcpChecklistTaskId,
+      title: titleToEdit,
+      newTitle
+    }
+  }
+});
+var removeManualTestContract = defineToolContract({
+  name: "remove_manual_test",
+  agent: {
+    description: "Remove an existing manual test step from the task checklist. Identify the test by its title (case-insensitive). Use to delete a stale or incorrect manual verification step.",
+    fields: {
+      title: titleToRemove
+    }
+  },
+  mcp: {
+    description: "Remove an existing manual test step from a task's checklist. Pass projectId to target a specific project; otherwise the configured default project is used. Identify the test by its title (case-insensitive).",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: mcpChecklistTaskId,
+      title: titleToRemove
+    }
+  }
+});
+var approveManualTestContract = defineToolContract({
+  name: "approve_manual_test",
+  agent: {
+    description: "Sign off on (approve) a manual test step on behalf of your authenticated user. Identify the test by its title (case-insensitive). Use after you have verified the step passes.",
+    fields: {
+      title: titleToApprove
+    }
+  },
+  mcp: {
+    description: "Sign off on (approve) a manual test step on a task on behalf of your authenticated user. Pass projectId to target a specific project; otherwise the configured default project is used. Identify the test by its title (case-insensitive). Use after you have verified the step passes.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: mcpChecklistTaskId,
+      title: titleToApprove
+    }
+  }
+});
+var rejectManualTestContract = defineToolContract({
+  name: "reject_manual_test",
+  agent: {
+    description: "Flag an issue with (reject) a manual test step on behalf of your authenticated user, recording the reason. Identify the test by its title (case-insensitive). Use when the step fails verification.",
+    fields: {
+      title: titleToReject,
+      reason: rejectReason
+    }
+  },
+  mcp: {
+    description: "Flag an issue with (reject) a manual test step on a task on behalf of your authenticated user, recording the reason. Pass projectId to target a specific project; otherwise the configured default project is used. Identify the test by its title (case-insensitive). Use when the step fails verification.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: mcpChecklistTaskId,
+      title: titleToReject,
+      reason: rejectReason
+    }
+  }
+});
+var checklistContracts = [
+  listManualTestsContract,
+  queryManualTestsContract,
+  setManualTestsContract,
+  editManualTestContract,
+  removeManualTestContract,
+  approveManualTestContract,
+  rejectManualTestContract
+];
+var getDependenciesContract = defineToolContract({
+  name: "get_dependencies",
+  agent: {
+    description: "Get this task's dependencies and their met/unmet status (met = merged to dev). Use to confirm blockers merged, or see why a task cannot start. For task state use get_task.",
+    fields: {}
+  },
+  mcp: {
+    description: "Get a task's dependencies and their met/unmet status (met = merged to dev). Pass projectId to target a specific project; otherwise the configured default project is used. Use to confirm blockers merged, or see why a task cannot start. For task state use get_task.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The task ID" })
+    }
+  }
+});
+var addDependencyContract = defineToolContract({
+  name: "add_dependency",
+  agent: {
+    description: "Add a blocking dependency \u2014 this task cannot start until the named task is merged to dev. For post-task follow-ups use create_follow_up_task instead.",
+    fields: {
+      depends_on_slug_or_id: f.string({ desc: "Slug or ID of the task this task depends on" })
+    }
+  },
+  mcp: {
+    description: "Add a blocking dependency \u2014 this task cannot start until the named task is merged to dev. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The task ID that will be blocked" }),
+      dependsOnSlugOrId: f.string({ desc: "Slug or ID of the task this one depends on" })
+    }
+  }
+});
+var removeDependencyContract = defineToolContract({
+  name: "remove_dependency",
+  agent: {
+    description: "Remove a previously added dependency from this task. When to use: the dependency was added in error or is no longer relevant. Returns: confirmation string.",
+    fields: {
+      depends_on_slug_or_id: f.string({ desc: "Slug or ID of the task to remove as dependency" })
+    }
+  },
+  mcp: {
+    description: "Remove a previously added dependency from a task. Pass projectId to target a specific project; otherwise the configured default project is used. The task is no longer blocked by the named task. Returns: confirmation string.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The task ID to unblock" }),
+      dependsOnSlugOrId: f.string({ desc: "Slug or ID of the dependency to remove" })
+    }
+  }
+});
+var dependenciesContracts = [
+  getDependenciesContract,
+  addDependencyContract,
+  removeDependencyContract
+];
+var SP_DESCRIPTION = storyPointValueDesc;
+var AGENT_FOLLOW_PARENT_STATUS = "Child mirrors the parent task's status automatically \u2014 for subtasks that ship on the parent's branch/PR with no build or PR of their own. Manual status writes on a follower stick only until the parent's next transition.";
+var MCP_FOLLOW_PARENT_STATUS = "When true, this subtask mirrors the parent task's status automatically \u2014 for children that ship on the parent's branch/PR and have no build or PR of their own. Manual status writes on a follower stick only until the parent's next transition.";
+var AGENT_DEPENDS_ON = "Sibling subtask ids or slugs this subtask blocks on (it won't start until they merge to dev). Set explicit dependency metadata here instead of describing order in the plan text \u2014 the pack runner schedules children off these edges. Omit / leave empty for independent children so they run in parallel.";
+var MCP_STATUS_ENUM = [
+  "Planning",
+  "Open",
+  "InProgress",
+  "ReviewPR",
+  "ReviewDev",
+  "ReviewLive",
+  "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 (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") })),
+      plan: f.optional(f.string({ desc: "Implementation plan in markdown" })),
+      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 })),
+      tags: f.optional(f.array(f.string(), { desc: AGENT_TAGS }))
+    }
+  },
+  mcp: {
+    description: "Create a subtask under a parent task. Pass projectId to target a specific project; otherwise the configured default project is used. Subtasks break a larger task into independently buildable pieces. For children that instead ship on the parent's own branch/PR (e.g. per-theme tracking cards for one bundled PR), set followParentStatus so their status rides the parent's automatically.",
+    fields: {
+      projectId: mcpProjectId,
+      parentTaskId: f.string({ desc: "The parent task ID" }),
+      title: f.string({ desc: "Subtask title" }),
+      description: f.optional(f.string({ desc: cardDescriptionDesc("Subtask description") })),
+      plan: f.optional(f.string({ desc: "Subtask implementation plan (markdown)" })),
+      ordinal: f.optional(f.number({ desc: "Ordering position among siblings" })),
+      storyPointValue: f.optional(f.number({ desc: SP_DESCRIPTION })),
+      followParentStatus: f.optional(f.boolean({ desc: MCP_FOLLOW_PARENT_STATUS })),
+      dependsOn: f.optional(
+        f.array(f.string(), {
+          desc: "Sibling subtask ids or slugs this subtask blocks on (it won't start until they merge to dev). Set explicit dependency metadata here instead of describing order in the plan text. Omit / leave empty for independent children so they run in parallel."
+        })
+      ),
+      tags: f.optional(
+        f.array(f.string(), {
+          desc: 'Tag names to assign to the subtask (e.g. ["refactor"]). Unknown names are rejected before the subtask is created, so nothing is written and a corrected retry creates exactly one subtask. Create the tag first with manage_tags. Use list_tags to see available tags.'
+        })
+      )
+    }
+  }
+});
+var updateSubtaskContract = defineToolContract({
+  name: "update_subtask",
+  agent: {
+    description: "Update an existing subtask's fields (title, description, plan, ordinal, storyPointValue, dependsOn) \u2014 and the sanctioned path to make a child buildable: promote it to status Open, assign its agent (agentIdOrName), and set story points. Setting story points does NOT auto-promote; set status explicitly. For the current task use update_task.",
+    fields: {
+      subtaskId: f.string({ desc: "The subtask ID to update" }),
+      title: f.optional(f.string()),
+      description: f.optional(f.string({ desc: cardDescriptionDesc("New description") })),
+      plan: f.optional(f.string()),
+      status: f.optional(
+        f.enum(["Planning", "Open"], {
+          desc: 'Move the child between "Planning" and "Open". "Open" marks it ready to execute \u2014 the pack runner takes Open children in dependency order. Execution statuses transition automatically.'
+        })
+      ),
+      agentIdOrName: f.optional(
+        f.string({
+          desc: "Assign a project agent to the child (agent id or exact name from the Project Agents list)."
+        })
+      ),
+      ordinal: f.optional(f.number()),
+      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} Replaces the full dependency set \u2014 pass [] to clear all, omit to leave unchanged.`
+        })
+      )
+    }
+  },
+  mcp: {
+    description: "Update a subtask's fields: title, description, plan, status, ordering, story points, or dependencies. Pass projectId to target a specific project; otherwise the configured default project is used. Moving a subtask beyond Planning auto-fills missing story points and agent assignment \u2014 don't spend turns on them.",
+    fields: {
+      projectId: mcpProjectId,
+      subtaskId: f.string({ desc: "The subtask ID" }),
+      title: f.optional(f.string({ desc: "New title" })),
+      description: f.optional(f.string({ desc: cardDescriptionDesc("New description") })),
+      plan: f.optional(f.string({ desc: "New plan (markdown)" })),
+      status: f.optional(f.enum(MCP_STATUS_ENUM, { desc: "New status" })),
+      ordinal: f.optional(f.number({ desc: "New ordering position among siblings" })),
+      storyPointValue: f.optional(f.number({ desc: SP_DESCRIPTION })),
+      followParentStatus: f.optional(f.boolean({ desc: MCP_FOLLOW_PARENT_STATUS })),
+      dependsOn: f.optional(
+        f.array(f.string(), {
+          desc: "Replace the sibling subtask ids/slugs this subtask blocks on (pass [] to clear). Omit to leave dependencies unchanged."
+        })
+      )
+    }
+  }
+});
+var deleteSubtaskContract = defineToolContract({
+  name: "delete_subtask",
+  agent: {
+    description: "Delete a subtask by id. When to use: a subtask was created in error or is no longer needed. Returns: confirmation string.",
+    fields: {
+      subtaskId: f.string({ desc: "The subtask ID to delete" })
+    }
+  },
+  mcp: {
+    description: "Delete a subtask by ID. Pass projectId to target a specific project; otherwise the configured default project is used. This is permanent \u2014 use update_subtask to set status to Cancelled if you only want to close it.",
+    fields: {
+      projectId: mcpProjectId,
+      subtaskId: f.string({ desc: "The subtask ID to delete" })
+    }
+  }
+});
+var listSubtasksContract = defineToolContract({
+  name: "list_subtasks",
+  agent: {
+    description: "List all subtasks under the current parent task. Default compact view returns per child: status, agent, story points, PR number/state, and dependencies (dependsOn + allDependenciesMet). Use to pick the next ready child and record progress; pass verbose:true only when you need full description/plan text (large). For non-child tasks use get_task.",
+    fields: {
+      verbose: f.optional(
+        f.boolean({
+          desc: "Return full task rows including description and plan text (large \u2014 can exceed tool result limits on big packs). Default: compact orchestration view."
+        })
+      )
+    }
+  },
+  mcp: {
+    description: "List all subtasks of a parent task with their status and ordering. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The parent task ID" })
+    }
+  }
+});
+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,
+  setTaskParentContract
+];
+var mcpTaskIdOrSlug = f.string({ desc: "The task ID or slug" });
+var agentTaskIdOrSlug = f.optional(
+  f.string({
+    desc: "Omit for the current card; pass a parent, sibling, or any other card in this project (id or slug) to read its files instead."
+  })
+);
+var listTaskFilesContract = defineToolContract({
+  name: "list_task_files",
+  agent: {
+    description: "List all files attached to this task with metadata. Showcase files (the card's deliverables, `showcase: true` on each row) list first; a row with `supersedesFileId` is a newer version of that file. Use before fetching a specific file to see what is available and how large each is. For file contents use get_attachment. Pass task_id to list another card's files in this project, for example the pack parent's source documents.",
+    fields: {
+      task_id: agentTaskIdOrSlug
+    }
+  },
+  mcp: {
+    description: "List all files attached to a task with metadata (no contents \u2014 fast and small). Showcase files (the card's deliverables, `showcase: true` on each row) list first; a row with `supersedesFileId` is a newer version of that file. Pass projectId to target a specific project; otherwise the configured default project is used. Use before fetching a specific file to see what is available and how large each is. For file contents use get_attachment.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: mcpTaskIdOrSlug
+    }
+  }
+});
+var getAttachmentContract = defineToolContract({
+  name: "get_attachment",
+  agent: {
+    description: "Fetch one task file by ID. Text and images under the inline size caps come back inline. Any other file (PDF, Word, Excel, zip, large logs) is saved into this pod, and the result names the local path: open it with the Read tool or Bash. A document downloadUrl answers 404 without a signed-in project member's session, so do not curl or WebFetch it. Call list_task_files first to discover IDs and sizes. Pass task_id when the file is attached to another card in this project, such as the pack parent.",
+    fields: {
+      fileId: f.string({ desc: "The file ID to retrieve" }),
+      task_id: agentTaskIdOrSlug
+    }
+  },
+  mcp: {
+    description: "Fetch one task file's content plus metadata by file ID (accepts task id or slug). Pass projectId to target a specific project; otherwise the configured default project is used. Images are returned as viewable image blocks. Large text files (logs, JSON) are returned in pages \u2014 use `offset`/`maxBytes` to read more. This tool is the way to read bytes: a document `downloadUrl` (anything that is not an image or video) answers 404 unless the request carries a signed-in project member's session, so do not curl or fetch it. Call list_task_files first to discover IDs and sizes.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: mcpTaskIdOrSlug,
+      fileId: f.string({ desc: "The file ID to fetch" }),
+      offset: f.optional(
+        f.number({
+          int: true,
+          nonnegative: true,
+          desc: "Byte offset into text content (paging). Default 0."
+        })
+      ),
+      maxBytes: f.optional(
+        f.number({
+          int: true,
+          positive: true,
+          desc: "Max bytes of text content to return from offset."
+        })
+      )
+    }
+  }
+});
+var attachmentTags = f.optional(
+  f.array(f.string(), {
+    desc: `Glossary tag names this file is a relevant example of. MUST be a JSON array of quoted strings, e.g. ["ops-hub", "platform-support"] \u2014 bare unquoted words are invalid JSON and fail the whole call before it is parsed (21 fleet calls in one week died this way). Use it when the file shows a tagged entity in a particular state: the tag's page lists its recent tagged attachments, so a reader can see what the entity looks like across the app and spot visual changes over time. Names are matched case-insensitively within the project; a name that matches no tag is reported back and never fails the upload. Max 5.`
+  })
+);
+var attachmentShowcase = f.optional(
+  f.boolean({
+    desc: "Mark this file as a showcase: the finished result of the card. Showcase files render first with a thumbnail on the card, are what a tag gallery shows, always post to chat, get a long-lived link, are kept past the 90-day purge, and are appended to the PR body under '## Showcase'. Use it for the final capture, not for scoping or before shots."
+  })
+);
+var attachmentSupersedes = f.optional(
+  f.string({
+    desc: "File id (from list_task_files) of an older file on this card that this upload replaces, e.g. the previous cut of a video. The old file loses showcase and collapses under the new one as history; the new one inherits its showcase flag and tag labels. Naming a file that already has a newer version replaces the newest one. A bad id never fails the upload \u2014 the reason comes back instead."
+  })
+);
+var uploadAttachmentContract = defineToolContract({
+  name: "upload_attachment",
+  agent: {
+    description: "Upload a file (doc, notes, data, diagram, screenshot \u2014 any file type, up to 25MB) as a task attachment AND post it to the task chat in one step \u2014 no follow-up post_to_chat call needed. This is how you deliver a file the user should keep: it attaches to the card. Never publish deliverables as an external Claude artifact. Pass `showcase: true` for the capture that shows the finished result, `supersedes` with the old file's id when this is a newer version of a file already on the card, and `tags` when the file is a good example of a glossary tag in some state.",
+    fields: {
+      path: f.string({
+        desc: "Path to the file \u2014 absolute, or relative to the workspace root"
+      }),
+      title: f.optional(
+        f.string({ desc: "Short caption posted with the file (defaults to the file name)" })
+      ),
+      comment: f.optional(
+        f.string({
+          desc: "Alias of `title` (the external conveyor-mcp surface names this field `comment`). Provide at most one of the two."
+        })
+      ),
+      tags: attachmentTags,
+      showcase: attachmentShowcase,
+      supersedes: attachmentSupersedes
+    }
+  },
+  mcp: {
+    description: "Upload a local file as a task attachment (any file type, up to 25MB). Pass projectId to target a specific project; otherwise the configured default project is used. The file appears under the task's Files. Pass `comment` to also post it to the task chat in the same step, `showcase: true` for the capture that shows the finished result (a showcase file always posts to chat), `supersedes` with the old file's id when this is a newer version of a file already on the card, and `tags` when the file is a good example of a glossary tag in some state.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: mcpTaskIdOrSlug,
+      path: f.string({ desc: "Absolute path to the local file to upload" }),
+      comment: f.optional(
+        f.string({ desc: "When set, also posts the attachment to the task chat with this text" })
+      ),
+      title: f.optional(
+        f.string({
+          desc: "Alias of `comment` (the in-pod agent surface names this field `title`). Provide at most one of the two."
+        })
+      ),
+      tags: attachmentTags,
+      showcase: attachmentShowcase,
+      supersedes: attachmentSupersedes,
+      mimeType: f.optional(
+        f.string({ desc: "Override the mime type inferred from the file extension" })
+      )
+    }
+  }
+});
+var DELETE_ATTACHMENT_WARNING = "Permanent, with no trash and no undo (unlike drive_delete_file): the file and its bytes are gone, and the chat message that announced it keeps its text but loses the attachment. Use it to remove a superseded upload once its replacement is attached. `fileId` comes from list_task_files.";
+var deleteAttachmentContract = defineToolContract({
+  name: "delete_attachment",
+  agent: {
+    description: `Delete one attachment from this task. ${DELETE_ATTACHMENT_WARNING} A pod can only delete files on its own card.`,
+    fields: {
+      fileId: f.string({ desc: "The file ID to delete" })
+    }
+  },
+  mcp: {
+    description: `Delete one attachment from a task (accepts task id or slug). ${DELETE_ATTACHMENT_WARNING} Requires Moderate on the project, the same bar as the web Files delete button. Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: {
+      projectId: mcpProjectId,
+      taskId: mcpTaskIdOrSlug,
+      fileId: f.string({ desc: "The file ID to delete" })
+    }
+  }
+});
+var SET_SHOWCASE_BEHAVIOR = "Mark an already-uploaded attachment as the card's showcase (`showcase: true`) or clear the flag (`showcase: false`) \u2014 the same flag upload_attachment sets at upload time, so promote an earlier capture here instead of uploading it again. A flip to showcase posts the file to the task chat once; a file that a chat message already carries is not posted again. `fileId` comes from list_task_files.";
+var showcaseFlag = f.boolean({
+  desc: "true marks the file as the card's showcase; false clears the flag."
+});
+var setShowcaseContract = defineToolContract({
+  name: "set_showcase",
+  agent: {
+    description: `${SET_SHOWCASE_BEHAVIOR} A pod can only change files on its own card.`,
+    fields: {
+      fileId: f.string({ desc: "The file ID to change" }),
+      showcase: showcaseFlag
+    }
+  },
+  mcp: {
+    description: `${SET_SHOWCASE_BEHAVIOR} Requires Moderate on the project, the same bar as the star on the card's Files list. Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The task ID or slug the file is attached to" }),
+      fileId: f.string({ desc: "The file ID to change" }),
+      showcase: showcaseFlag
+    }
+  }
+});
+var attachmentsContracts = [
+  listTaskFilesContract,
+  getAttachmentContract,
+  uploadAttachmentContract,
+  deleteAttachmentContract,
+  setShowcaseContract
+];
+var createSuggestionContract = defineToolContract({
+  name: "create_suggestion",
+  agent: {
+    description: "File a project suggestion (idea/improvement for maintainers to review). Duplicates are AI-deduped into an existing suggestion with an upvote. Returns the suggestion id.",
+    fields: {
+      title: f.string({ min: 1, desc: "Short title" }),
+      description: f.optional(
+        f.string({ desc: cardDescriptionDesc("What should change and why") })
+      ),
+      tag_names: f.optional(f.array(f.string(), { desc: "Tag names to categorize" }))
+    }
+  },
+  mcp: {
+    description: "Suggest a feature, improvement, rule, or idea for the project. Pass projectId to target a specific project; otherwise the configured default project is used. Duplicates are deduped and your upvote is recorded.",
+    fields: {
+      projectId: mcpProjectId,
+      title: f.string({ desc: "Suggestion title" }),
+      description: f.optional(f.string({ desc: cardDescriptionDesc("Suggestion details") })),
+      tagNames: f.optional(
+        f.array(f.string(), {
+          desc: 'Tag names to categorize the suggestion (e.g., ["agent-runner"])'
+        })
+      )
+    }
+  }
+});
+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 in full (the same JSON as get_decision, with option ids and the deadline) plus which cards were linked.`,
+    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" })
+      ),
+      raised_by_card: f.optional(
+        f.string({
+          desc: "Slug or id of the card that raised the question. A link back, not a block \u2014 use impacted_cards to block a card."
+        })
+      ),
+      deadline_at: f.optional(
+        f.string({
+          desc: "Absolute deadline as an ISO 8601 timestamp, e.g. 2026-09-25T17:00:00Z. Wins over deadline_hours when both are given; must be in the future and within 720 hours."
+        })
+      )
+    }
+  },
+  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" })
+      ),
+      raisedByCard: f.optional(
+        f.string({
+          desc: "Slug or id of the card that raised the question. A link back, not a block \u2014 use impactedCards to block a card."
+        })
+      ),
+      deadlineAt: f.optional(
+        f.string({
+          desc: "Absolute deadline (ISO 8601). Wins over deadlineHours when both are given; must be in the future and within 720 hours."
+        })
+      )
+    }
+  }
+});
+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?" Each row carries the summary, who raised it (and from which card or PR), when, and \u2014 once settled \u2014 the 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 summary and context, who raised it and from where, 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: fix the question, summary, context or tags, rewrite the options while nobody has voted, move the 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" }),
+      question: f.optional(f.string({ min: 1, desc: "New question, one plain sentence" })),
+      summary: f.optional(
+        f.string({ desc: cardDescriptionDesc("New one- or two-sentence summary") })
+      ),
+      context: f.optional(f.string({ min: 1, desc: "New markdown background" })),
+      options: f.optional(
+        f.array(agentOption, {
+          min: 2,
+          desc: "Replacement options. Accepted only while the decision has no votes \u2014 once somebody has voted, cancel it and raise a new one instead. Send default_option with it: the old default no longer exists."
+        })
+      ),
+      default_option: f.optional(
+        f.number({ int: true, min: 1, max: 3, desc: "1-based position of the new default" })
+      ),
+      tag_names: f.optional(
+        f.array(f.string(), { desc: "Replacement tag names (replaces the current set)" })
+      ),
+      deadline_hours: f.optional(f.number({ desc: "New deadline, in hours from now. 1 to 720." })),
+      deadline_at: f.optional(
+        f.string({
+          desc: "New absolute deadline (ISO 8601). Wins over deadline_hours; must be in the future and within 720 hours."
+        })
+      ),
+      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: fix the question, summary, context or tags, rewrite the options while nobody has voted, move 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" }),
+      question: f.optional(f.string({ desc: "New question" })),
+      summary: f.optional(f.string({ desc: cardDescriptionDesc("New summary") })),
+      context: f.optional(f.string({ desc: "New markdown background" })),
+      options: f.optional(
+        f.array(agentOption, {
+          min: 2,
+          desc: "Replacement options. Accepted only while the decision has no votes. Send defaultOption with it: the old default no longer exists."
+        })
+      ),
+      defaultOption: f.optional(
+        f.number({ int: true, min: 1, max: 3, desc: "1-based position of the new default" })
+      ),
+      tagNames: f.optional(f.array(f.string(), { desc: "Replacement tag names" })),
+      deadlineHours: f.optional(
+        f.number({ min: 1, max: 720, desc: "New deadline, in hours from now" })
+      ),
+      deadlineAt: f.optional(
+        f.string({ desc: "New absolute deadline (ISO 8601). Wins over deadlineHours." })
+      ),
+      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: {
+    description: "Create a GitHub PR for this task. Auto-stages, commits (commitMessage or title default), pushes to origin, then opens the PR. Always use this instead of gh CLI or raw git.",
+    fields: {
+      title: f.string({ desc: "The PR title" }),
+      body: f.string({
+        desc: "The PR description/body in markdown. If the diff changes anything a user sees rendered, the body MUST show the visual proof inline, not just point at the card: upload the capture with upload_attachment, then embed the downloadUrl it returns under a '## Screenshots' heading (![caption](url) for images, [caption](url) for video). Only image and video URLs belong in a PR body: a document downloadUrl (csv, pdf, md, \u2026) needs a signed-in project member and shows 404 to a reviewer on GitHub, so point at the card instead. Attach to the card as well \u2014 the card is the durable home, the PR body is what the reviewer reads. Showcase attachments (uploaded with `showcase: true`) are appended under '## Showcase' automatically when Conveyor creates the PR; mention them inline yourself only if you want them next to specific text."
+      }),
+      branch: f.optional(
+        f.string({
+          desc: "The head branch name for the PR. Defaults to the workspace's current checkout, which is also the branch the commits are pushed to. Pass it explicitly if you pushed to a different branch, or if the card may have been renamed (a rename can re-slug the task's stored branch away from the one you are working on)."
+        })
+      ),
+      baseBranch: f.optional(
+        f.string({
+          desc: "The base branch to target for the PR (e.g. 'main', 'develop'). Defaults to the project's configured dev branch."
+        })
+      ),
+      commitMessage: f.optional(
+        f.string({
+          desc: "Commit message for staging uncommitted changes. If not provided, a default message based on the PR title will be used."
+        })
+      ),
+      skipVerify: f.optional(
+        f.boolean({
+          desc: "Controls the local pre-push quality gate (lint/typecheck/test). Defaults to true (--no-verify): the push skips the local gate because you should run gates yourself before opening the PR and CI re-runs them on the resulting PR. Running the full gate synchronously during the push would block the agent's event loop long enough to drop the Conveyor socket connection. Pass false to force the local pre-push hook to run."
+        })
+      )
+    }
+  },
+  mcp: {
+    description: "Open a GitHub pull request for a task's existing branch (the branch must already be pushed to origin). Pass projectId to target a specific project; otherwise the configured default project is used. Moves the task to ReviewPR. Returns the PR number and URL.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The task ID whose branch should be opened as a PR" }),
+      title: f.string({ desc: "Pull request title" }),
+      body: f.string({
+        desc: "Pull request body (markdown). For a diff that changes rendered UI, embed the visual proof inline: upload the capture with upload_attachment and paste the downloadUrl it returns as ![caption](url), in addition to leaving it on the card. Showcase attachments (uploaded with `showcase: true`) are appended under '## Showcase' automatically when Conveyor creates the PR; mention them inline yourself only if you want them next to specific text."
+      }),
+      head: f.optional(
+        f.string({ desc: "Source branch for the PR (defaults to the task's branch)" })
+      ),
+      base: f.optional(
+        f.string({ desc: "Target branch for the PR (defaults to the repo default)" })
+      )
+    }
+  }
+});
+var pullRequestContracts = [createPullRequestContract];
+var REGISTRY_RULE = "Only channels an admin registered as work channels in project settings are reachable \u2014 an unregistered channel is invisible here no matter what the bot can see in the workspace, and the card-sync channels are NOT automatically included.";
+var NO_STORAGE = "Messages are fetched live from Slack/Discord on every call and are never stored by Conveyor.";
+var listProjectIntegrationsContract = defineToolContract({
+  name: "list_project_integrations",
+  agent: {
+    description: `Find out what this project is connected to before assuming a capability exists \u2014 repository forge, Slack or Discord, email, GCP, Grafana, Google Analytics, Google Drive, Cloudflare, and whether incident reporting is set up. Also lists the registered work channels you may read or post in, and how many meetings have been ingested \u2014 so you can tell whether reading meetings is worth doing before calling a meeting tool. Credential-free: every value says whether something is configured, never what the secret is. Call this when you are about to reach for an integration and want to know whether it is there, rather than trying and handling a failure.`,
+    fields: {}
+  },
+  mcp: {
+    description: `Report which integrations a project has configured \u2014 repository forge, Slack/Discord, email, GCP, Grafana, Google Analytics, Google Drive, Cloudflare, incident reporting \u2014 plus the work channels registered for agent access and the project's ingested-meeting count. Returns configuration booleans only, never credential material. Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: {
+      projectId: mcpProjectId
+    }
+  }
+});
+var listProjectChannelsContract = defineToolContract({
+  name: "list_project_channels",
+  agent: {
+    description: `List the Slack or Discord channels this project has registered as work channels, each with the admin's description of what happens there and whether you may read it and post into it. Start here before read_channel_messages \u2014 the description is what tells you which channel is worth consulting. ${REGISTRY_RULE}`,
+    fields: {}
+  },
+  mcp: {
+    description: `List a project's registered work channels: provider, channel id and name, the admin's description of what the channel is for, and the allowRead/allowPost grants. ${REGISTRY_RULE} Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: {
+      projectId: mcpProjectId
+    }
+  }
+});
+var CHANNEL_ID_DESC = "Provider channel id, exactly as list_project_channels reports it (Slack `C\u2026`, Discord a numeric id). Not the channel name.";
+var LIMIT_DESC = "How many messages to return, newest first. Defaults to 25, maximum 50. Prefer a small read plus a follow-up over one large one \u2014 channel history spends context fast.";
+var BEFORE_DESC = "Page further back: return messages older than this cursor. Pass the `olderCursor` from a previous call; a null cursor there means you have reached the start of the channel.";
+var AFTER_DESC = "Return only messages newer than this cursor. Use to catch up on a channel.";
+var THREAD_DESC = "Read one thread instead of the channel surface. Pass a `threadTs` seen on a message from a previous read.";
+var readChannelMessagesContract = defineToolContract({
+  name: "read_channel_messages",
+  agent: {
+    description: `Read recent messages from a registered work channel, newest first \u2014 to catch up on a discussion, find the context behind a decision, or check whether something was already raised. Each message reports its author, whether that author is a bot (Conveyor's own card feed posts show up here too, so check this before treating a message as a teammate's), its text, and a cursor for paging further back. ${REGISTRY_RULE} ${NO_STORAGE}`,
+    fields: {
+      channelId: f.string({ desc: CHANNEL_ID_DESC }),
+      limit: f.optional(f.number({ desc: LIMIT_DESC, int: true, min: 1, max: 50 })),
+      before: f.optional(f.string({ desc: BEFORE_DESC })),
+      after: f.optional(f.string({ desc: AFTER_DESC })),
+      threadTs: f.optional(f.string({ desc: THREAD_DESC }))
+    }
+  },
+  mcp: {
+    description: `Read recent messages from a project's registered work channel, newest first. Each message carries author name, a bot flag, text, a provider-native cursor, and a timestamp; the response carries an olderCursor for paging back. ${REGISTRY_RULE} ${NO_STORAGE} Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: {
+      projectId: mcpProjectId,
+      channelId: f.string({ desc: CHANNEL_ID_DESC }),
+      limit: f.optional(f.number({ desc: LIMIT_DESC, int: true, min: 1, max: 50 })),
+      before: f.optional(f.string({ desc: BEFORE_DESC })),
+      after: f.optional(f.string({ desc: AFTER_DESC })),
+      threadTs: f.optional(f.string({ desc: THREAD_DESC }))
+    }
+  }
+});
+var POST_TEXT_DESC = "What to say, in plain text or light markdown. An attribution footer naming you is appended automatically, so do not sign the message yourself. Channel-wide pings (@everyone, @here, <!channel>) are rendered as ordinary text and will not notify anyone.";
+var POST_THREAD_DESC = "Reply inside a thread rather than to the channel. Prefer this when responding to a specific message \u2014 pass the `threadTs` from the message you are answering.";
+var POST_WARNING = "This is visible to everyone in the channel and cannot be edited or deleted afterwards. Posting requires a per-channel grant that is OFF by default, separate from read access, so most registered channels will refuse it.";
+var postChannelMessageContract = defineToolContract({
+  name: "post_channel_message",
+  agent: {
+    description: `Post a message into a registered work channel \u2014 to answer a question aimed at you, report something the team is waiting on, or ask for input you genuinely need. ${POST_WARNING} ${REGISTRY_RULE}`,
+    fields: {
+      channelId: f.string({ desc: CHANNEL_ID_DESC }),
+      text: f.string({ desc: POST_TEXT_DESC, min: 1, max: 1800 }),
+      threadTs: f.optional(f.string({ desc: POST_THREAD_DESC }))
+    }
+  },
+  mcp: {
+    description: `Post a message into a project's registered work channel, attributed to the acting agent or user. ${POST_WARNING} ${REGISTRY_RULE} Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: {
+      projectId: mcpProjectId,
+      channelId: f.string({ desc: CHANNEL_ID_DESC }),
+      text: f.string({ desc: POST_TEXT_DESC, min: 1, max: 1800 }),
+      threadTs: f.optional(f.string({ desc: POST_THREAD_DESC }))
+    }
+  }
+});
+var ANALYTICS_RANGE = "How many days back to summarize, ending today. Defaults to 28; 90 is the maximum, because GA4 retention makes longer windows unreliable.";
+var ANALYTICS_CAMPAIGN = "Restrict to one campaign name. The campaigns breakdown is always unfiltered, so read it first to see what exists.";
+var ANALYTICS_SHAPE = "Returns headline totals (sessions, active users, new users, page views, average session duration, bounce rate) plus the top five pages, traffic sources, landing pages and campaigns. A project that has not set up GA4 answers configured:false with a reason rather than failing \u2014 that is a normal state, not an error.";
+var getAnalyticsSummaryContract = defineToolContract({
+  name: "get_analytics_summary",
+  agent: {
+    description: `Read this project's Google Analytics 4 traffic \u2014 real numbers for questions like "did that launch land" or "which pages actually get read", instead of guessing. ${ANALYTICS_SHAPE}`,
+    fields: {
+      rangeDays: f.optional(f.number({ desc: ANALYTICS_RANGE, int: true, min: 1, max: 90 })),
+      campaign: f.optional(f.string({ desc: ANALYTICS_CAMPAIGN, max: 200 }))
+    }
+  },
+  mcp: {
+    description: `Read a project's Google Analytics 4 traffic summary. ${ANALYTICS_SHAPE} Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: {
+      projectId: mcpProjectId,
+      rangeDays: f.optional(f.number({ desc: ANALYTICS_RANGE, int: true, min: 1, max: 90 })),
+      campaign: f.optional(f.string({ desc: ANALYTICS_CAMPAIGN, max: 200 }))
+    }
+  }
+});
+var integrationsContracts = [
+  listProjectIntegrationsContract,
+  listProjectChannelsContract,
+  readChannelMessagesContract,
+  postChannelMessageContract,
+  getAnalyticsSummaryContract
+];
+var MAX_CONTENT_CHARS = 1e6;
+var FILE_ID = "Drive file id, as returned by drive_list_files";
+var ROOT_DEFAULT = "Defaults to the project's connected root folder.";
+var MCP_PROJECT_TAIL = "Pass projectId to target a specific project; otherwise the configured default project is used.";
+var driveListFilesContract = defineToolContract({
+  name: "drive_list_files",
+  agent: {
+    description: "List files and folders in the project's connected Google Drive folder. Omit folderId to list the project's root folder. Returns id, name, mimeType, size, and modified time for each entry.",
+    fields: {
+      folderId: f.optional(f.string({ desc: `Folder to list. ${ROOT_DEFAULT}` })),
+      search: f.optional(f.string({ desc: "Only return names containing this text", max: 200 })),
+      limit: f.optional(
+        f.number({ desc: "Max entries (default 100)", int: true, min: 1, max: 200 })
+      )
+    }
+  },
+  mcp: {
+    description: `List files and folders in a project's connected Google Drive folder. Omit folderId to list the project's root folder. Returns id, name, mimeType, size, and modified time for each entry. ${MCP_PROJECT_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      folderId: f.optional(f.string({ desc: `Folder to list. ${ROOT_DEFAULT}` })),
+      search: f.optional(f.string({ desc: "Only return names containing this text", max: 200 })),
+      limit: f.optional(
+        f.number({ desc: "Max entries (default 100)", int: true, min: 1, max: 200 })
+      )
+    }
+  }
+});
+var driveReadFileContract = defineToolContract({
+  name: "drive_read_file",
+  agent: {
+    description: "Read a file's text content from the project's connected Google Drive folder. Google Docs, Sheets, and Slides are exported to text automatically. Content over 100 KB is truncated.",
+    fields: { fileId: f.string({ desc: FILE_ID }) }
+  },
+  mcp: {
+    description: `Read a file's text content from a project's connected Google Drive folder. Google Docs, Sheets, and Slides are exported to text automatically. Content over 100 KB is truncated. ${MCP_PROJECT_TAIL}`,
+    fields: { projectId: mcpProjectId, fileId: f.string({ desc: FILE_ID }) }
+  }
+});
+var driveCreateFileContract = defineToolContract({
+  name: "drive_create_file",
+  agent: {
+    description: "Create a new file in the project's connected Google Drive folder. Use drive_update_file to change an existing file instead.",
+    fields: {
+      name: f.string({ desc: "File name, without any path separators", min: 1, max: 255 }),
+      content: f.string({ desc: "File content, UTF-8 text", max: MAX_CONTENT_CHARS }),
+      mimeType: f.optional(f.string({ desc: "MIME type (default text/plain)" })),
+      folderId: f.optional(f.string({ desc: `Destination folder. ${ROOT_DEFAULT}` }))
+    }
+  },
+  mcp: {
+    description: `Create a new file in a project's connected Google Drive folder. Use drive_update_file to change an existing file instead. ${MCP_PROJECT_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      name: f.string({ desc: "File name, without any path separators", min: 1, max: 255 }),
+      content: f.string({ desc: "File content, UTF-8 text", max: MAX_CONTENT_CHARS }),
+      mimeType: f.optional(f.string({ desc: "MIME type (default text/plain)" })),
+      folderId: f.optional(f.string({ desc: `Destination folder. ${ROOT_DEFAULT}` }))
+    }
+  }
+});
+var driveUpdateFileContract = defineToolContract({
+  name: "drive_update_file",
+  agent: {
+    description: "Replace the content of an existing file in the project's connected Google Drive folder. This overwrites the whole file. Google-native documents cannot be overwritten.",
+    fields: {
+      fileId: f.string({ desc: FILE_ID }),
+      content: f.string({ desc: "Replacement content, UTF-8 text", max: MAX_CONTENT_CHARS }),
+      mimeType: f.optional(f.string({ desc: "MIME type (defaults to the file's current type)" }))
+    }
+  },
+  mcp: {
+    description: `Replace the content of an existing file in a project's connected Google Drive folder. This overwrites the whole file \u2014 read it first if you are editing rather than replacing. Google-native documents cannot be overwritten. ${MCP_PROJECT_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      fileId: f.string({ desc: FILE_ID }),
+      content: f.string({ desc: "Replacement content, UTF-8 text", max: MAX_CONTENT_CHARS }),
+      mimeType: f.optional(f.string({ desc: "MIME type (defaults to the file's current type)" }))
+    }
+  }
+});
+var driveDeleteFileContract = defineToolContract({
+  name: "drive_delete_file",
+  agent: {
+    description: "Move a file in the project's connected Google Drive folder to the Drive trash. The file is recoverable from the trash; it is never permanently deleted.",
+    fields: { fileId: f.string({ desc: FILE_ID }) }
+  },
+  mcp: {
+    description: `Move a file in a project's connected Google Drive folder to the Drive trash. The file is recoverable from the trash; it is never permanently deleted. ${MCP_PROJECT_TAIL}`,
+    fields: { projectId: mcpProjectId, fileId: f.string({ desc: FILE_ID }) }
+  }
+});
+var driveCreateFolderContract = defineToolContract({
+  name: "drive_create_folder",
+  agent: {
+    description: "Create a folder inside the project's connected Google Drive folder.",
+    fields: {
+      name: f.string({ desc: "Folder name, without any path separators", min: 1, max: 255 }),
+      folderId: f.optional(f.string({ desc: `Parent folder. ${ROOT_DEFAULT}` }))
+    }
+  },
+  mcp: {
+    description: `Create a folder inside a project's connected Google Drive folder. ${MCP_PROJECT_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      name: f.string({ desc: "Folder name, without any path separators", min: 1, max: 255 }),
+      folderId: f.optional(f.string({ desc: `Parent folder. ${ROOT_DEFAULT}` }))
+    }
+  }
+});
+var driveContracts = [
+  driveListFilesContract,
+  driveReadFileContract,
+  driveCreateFileContract,
+  driveUpdateFileContract,
+  driveDeleteFileContract,
+  driveCreateFolderContract
+];
+var MEETING_ID = "Meeting id, as returned by list_meetings.";
+var MCP_TAIL = "Pass projectId to target a specific project; otherwise the configured default project is used.";
+var SUMMARY_NOTE = 'A meeting whose summary is still being written reports status "processing" and a null summary \u2014 that is normal shortly after ingestion, not an error.';
+var listMeetingsContract = defineToolContract({
+  name: "list_meetings",
+  agent: {
+    description: `List this project's meetings, newest first \u2014 each with its title, date, source, status, participants, and a short summary preview. Start here when you are asked about "the meeting", "what did we decide", or "what came out of that call". ${SUMMARY_NOTE}`,
+    fields: {
+      limit: f.optional(
+        f.number({
+          desc: "How many to return (default 20, maximum 50).",
+          int: true,
+          min: 1,
+          max: 50
+        })
+      ),
+      search: f.optional(
+        f.string({ desc: "Case-insensitive match on the meeting title.", max: 200 })
+      )
+    }
+  },
+  mcp: {
+    description: `List a project's meetings, newest first, with title, date, source, status, participants, and a summary preview. ${SUMMARY_NOTE} ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      limit: f.optional(
+        f.number({
+          desc: "How many to return (default 20, maximum 50).",
+          int: true,
+          min: 1,
+          max: 50
+        })
+      ),
+      search: f.optional(
+        f.string({ desc: "Case-insensitive match on the meeting title.", max: 200 })
+      )
+    }
+  }
+});
+var getMeetingContract = defineToolContract({
+  name: "get_meeting",
+  agent: {
+    description: `Read one meeting's details and its FULL AI summary \u2014 the overview, the decisions, and the proposed next steps. **Read this before reaching for the transcript**: the summary usually answers the question, and a transcript costs far more context. Also returns the participant list, the segment count, and the meeting's web link. ${SUMMARY_NOTE}`,
+    fields: { meetingId: f.string({ desc: MEETING_ID }) }
+  },
+  mcp: {
+    description: `Read one meeting's details and full AI summary (overview, decisions, proposed next steps), plus participants, segment count, and its web link. Prefer this over the transcript \u2014 the summary usually answers the question at a fraction of the context. ${SUMMARY_NOTE} ${MCP_TAIL}`,
+    fields: { projectId: mcpProjectId, meetingId: f.string({ desc: MEETING_ID }) }
+  }
+});
+var OFFSET_DESC = "Segment index to start from (default 0). Pass the nextOffset from the previous page to continue.";
+var LIMIT_DESC2 = "Segments per page (default 200, maximum 500). A long meeting runs to thousands, so page it rather than asking for everything.";
+var readMeetingTranscriptContract = defineToolContract({
+  name: "read_meeting_transcript",
+  agent: {
+    description: `Read a page of a meeting's raw transcript as \`[hh:mm:ss] Speaker: text\` lines. Use this when you need someone's exact words \u2014 a quote, a caveat, or the reasoning behind a decision the summary only states. For "what happened in the meeting", read get_meeting instead. The response carries nextOffset when more segments remain.`,
+    fields: {
+      meetingId: f.string({ desc: MEETING_ID }),
+      offset: f.optional(f.number({ desc: OFFSET_DESC, int: true, min: 0 })),
+      limit: f.optional(f.number({ desc: LIMIT_DESC2, int: true, min: 1, max: 500 }))
+    }
+  },
+  mcp: {
+    description: `Read a page of a meeting's raw transcript as \`[hh:mm:ss] Speaker: text\` lines. Use it for exact wording; prefer get_meeting's summary for what happened. The response carries nextOffset when more segments remain. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      meetingId: f.string({ desc: MEETING_ID }),
+      offset: f.optional(f.number({ desc: OFFSET_DESC, int: true, min: 0 })),
+      limit: f.optional(f.number({ desc: LIMIT_DESC2, int: true, min: 1, max: 500 }))
+    }
+  }
+});
+var RAW_TEXT_DESC = "The transcript itself. Plain text with `Speaker: line` labels, or a WebVTT/SRT file's contents \u2014 the format is detected, and the speaker labels become the participant list. Paste the whole thing; it is stored as the meeting's record.";
+var OCCURRED_AT_DESC = "When the meeting happened, ISO 8601 (e.g. 2026-09-02T15:00:00Z). Defaults to now. Must be a real date \u2014 no earlier than 2000, and no more than 48 hours ahead.";
+var TITLE_DESC = "Meeting title. Defaults to `Meeting <date>` when you do not name one.";
+var createMeetingContract = defineToolContract({
+  name: "create_meeting",
+  agent: {
+    description: `File a transcript as a project meeting. Use this when you have the text of a call \u2014 a paste, an export, notes captured elsewhere \u2014 and it belongs in the project's record. The transcript is parsed into speaker segments and an AI summary is written straight after, so the meeting reads "processing" for a few seconds before its overview appears. This creates a MEETING, not cards: turning what was decided into work is still create_task's job.`,
+    fields: {
+      rawText: f.string({ desc: RAW_TEXT_DESC, min: 1 }),
+      title: f.optional(f.string({ desc: TITLE_DESC, max: 200 })),
+      occurredAt: f.optional(f.string({ desc: OCCURRED_AT_DESC }))
+    }
+  },
+  mcp: {
+    description: `File a transcript as a project meeting. The text is parsed into speaker segments and summarized automatically, so the meeting reports status "processing" briefly before its overview lands. Creates a meeting only \u2014 use the card tools to turn decisions into work. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      rawText: f.string({ desc: RAW_TEXT_DESC, min: 1 }),
+      title: f.optional(f.string({ desc: TITLE_DESC, max: 200 })),
+      occurredAt: f.optional(f.string({ desc: OCCURRED_AT_DESC }))
+    }
+  }
+});
+var SUMMARY_DESC = "Replace the meeting's overview with this text. Markdown, and it is what every reader sees from then on \u2014 write the whole overview, not a note about it. Writing a summary marks the meeting ready, so a later regenerate is the only thing that overwrites it.";
+var updateMeetingContract = defineToolContract({
+  name: "update_meeting",
+  agent: {
+    description: `Correct a meeting's title or date, or replace its AI summary with a better one. This is how a rewritten overview actually persists \u2014 read the transcript, write the summary you want, and pass it here. Pass at least one field; the ones you leave out are untouched.`,
+    fields: {
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.optional(f.string({ desc: TITLE_DESC, max: 200 })),
+      occurredAt: f.optional(f.string({ desc: OCCURRED_AT_DESC })),
+      summary: f.optional(f.string({ desc: SUMMARY_DESC, min: 1 }))
+    }
+  },
+  mcp: {
+    description: `Correct a meeting's title or date, or replace its AI summary with a rewritten one. Pass at least one field; omitted fields are left alone. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.optional(f.string({ desc: TITLE_DESC, max: 200 })),
+      occurredAt: f.optional(f.string({ desc: OCCURRED_AT_DESC })),
+      summary: f.optional(f.string({ desc: SUMMARY_DESC, min: 1 }))
+    }
+  }
+});
+var CHECKLIST_ITEM_TITLE = "The item's exact title, as get_meeting lists it. Matched case-insensitively.";
+var CHECKLIST_INTRO = "A meeting's checklist is its follow-ups: one line each, ticked when done, optionally pointing at the Conveyor card that carries the work. The AI summary's proposed next steps are seeded here automatically.";
+var addMeetingChecklistItemsContract = defineToolContract({
+  name: "add_meeting_checklist_items",
+  agent: {
+    description: `Add follow-up items to a meeting's checklist. ${CHECKLIST_INTRO} Use this for a step the summary missed, or one that came out of a later conversation. Items whose title already exists are skipped, so re-running this is safe.`,
+    fields: {
+      meetingId: f.string({ desc: MEETING_ID }),
+      items: f.array(
+        f.object({ title: f.string({ desc: "One follow-up, as a single line.", min: 1 }) }),
+        { desc: "The items to add, in the order they should appear." }
+      )
+    }
+  },
+  mcp: {
+    description: `Add follow-up items to a meeting's checklist. ${CHECKLIST_INTRO} Existing titles are skipped, so re-running is safe. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      meetingId: f.string({ desc: MEETING_ID }),
+      items: f.array(
+        f.object({ title: f.string({ desc: "One follow-up, as a single line.", min: 1 }) }),
+        { desc: "The items to add, in the order they should appear." }
+      )
+    }
+  }
+});
+var LINKED_TASK_DESC = "Card id or slug to attach to this item \u2014 the card that carries the work. Must be in the same project. Pass it in the same call that ticks the item when you just filed the card.";
+var checkMeetingChecklistItemContract = defineToolContract({
+  name: "check_meeting_checklist_item",
+  agent: {
+    description: `Tick or untick one of a meeting's checklist items, and optionally attach the card that carries it. This is how a next step becomes tracked work: file the card with create_task, then call this with the item's title and the new card's slug. Ticking records YOU as the person who did it. Unticking clears that, but keeps the linked card.`,
+    fields: {
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE }),
+      checked: f.boolean({ desc: "true to tick the item, false to untick it." }),
+      linkedTask: f.optional(f.string({ desc: LINKED_TASK_DESC }))
+    }
+  },
+  mcp: {
+    description: `Tick or untick a meeting checklist item, optionally attaching the card that carries it. Ticking records the acting user. Unticking clears that but keeps the link. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE }),
+      checked: f.boolean({ desc: "true to tick the item, false to untick it." }),
+      linkedTask: f.optional(f.string({ desc: LINKED_TASK_DESC }))
+    }
+  }
+});
+var editMeetingChecklistItemContract = defineToolContract({
+  name: "edit_meeting_checklist_item",
+  agent: {
+    description: `Reword one of a meeting's checklist items. Use it to sharpen a vague next step into something someone can act on; to mark it done use check_meeting_checklist_item instead.`,
+    fields: {
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE }),
+      newTitle: f.string({ desc: "The replacement text, as a single line.", min: 1 })
+    }
+  },
+  mcp: {
+    description: `Reword a meeting checklist item. To mark it done use check_meeting_checklist_item. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE }),
+      newTitle: f.string({ desc: "The replacement text, as a single line.", min: 1 })
+    }
+  }
+});
+var removeMeetingChecklistItemContract = defineToolContract({
+  name: "remove_meeting_checklist_item",
+  agent: {
+    description: `Delete one of a meeting's checklist items. For a step that turned out not to be needed. An item someone already ticked is a record that work happened \u2014 untick it or leave it rather than deleting it.`,
+    fields: {
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE })
+    }
+  },
+  mcp: {
+    description: `Delete a meeting checklist item. Prefer unticking over deleting an item someone already completed. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE })
+    }
+  }
+});
+var meetingsContracts = [
+  listMeetingsContract,
+  getMeetingContract,
+  readMeetingTranscriptContract,
+  createMeetingContract,
+  updateMeetingContract,
+  addMeetingChecklistItemsContract,
+  checkMeetingChecklistItemContract,
+  editMeetingChecklistItemContract,
+  removeMeetingChecklistItemContract
+];
+var SINCE_MINUTES = f.optional(
+  f.number({
+    desc: "Relative time window ending now, in minutes (default 60). Ignored if startTime is set.",
+    int: true,
+    min: 1,
+    max: 10080
+  })
+);
+var START_TIME = f.optional(f.string({ desc: "ISO 8601 lower bound (overrides sinceMinutes)" }));
+var END_TIME = f.optional(f.string({ desc: "ISO 8601 upper bound (default now)" }));
+var LIMIT = f.optional(
+  f.number({ desc: "Max entries per page (default 50)", int: true, min: 1, max: 200 })
+);
+var RAW_QUERY_MAX = 2e3;
+var gcpFields = {
+  env: f.optional(
+    f.enum(["prod", "dev", "claudespace"], {
+      desc: "GCP environment slot to query (default prod)"
+    })
+  ),
+  sinceMinutes: SINCE_MINUTES,
+  startTime: START_TIME,
+  endTime: END_TIME,
+  severity: f.optional(
+    f.enum(SEVERITY_ENUM, {
+      desc: "Minimum severity, inclusive \u2014 ERROR returns ERROR and above"
+    })
+  ),
+  services: f.optional(
+    f.array(f.string(), {
+      desc: "Restrict to these Cloud Run service names (prod/dev only). Defaults to all services linked in project settings."
+    })
+  ),
+  sqlInstances: f.optional(
+    f.array(f.string(), { desc: "Restrict to these Cloud SQL instance names (prod/dev only)" })
+  ),
+  allServices: f.optional(
+    f.boolean({
+      desc: "Set true to search ALL logs in the GCP project, ignoring the linked-resource scope"
+    })
+  ),
+  search: f.optional(
+    f.string({
+      desc: "Free-text search across all log fields (exact substring, not regex)",
+      max: 256
+    })
+  ),
+  filter: f.optional(
+    f.string({
+      desc: "Advanced: raw Cloud Logging filter expression, ANDed with the scope (it cannot widen it)",
+      max: RAW_QUERY_MAX
+    })
+  ),
+  limit: LIMIT,
+  pageToken: f.optional(
+    f.string({ desc: "Opaque token from a previous response to fetch the next page" })
+  ),
+  full: f.optional(
+    f.boolean({
+      desc: 'Render each entry in full: message and structured payload untruncated, multi-line. Pair with a narrow search or filter (e.g. insertId="\u2026"); full mode returns at most 10 entries.'
+    })
+  )
+};
+var GCP_SHARED_DESC = "Envs: 'prod' and 'dev' are the project's Cloud Run apps + Cloud SQL databases (scoped by default to the resources linked in project settings); 'claudespace' is the project's GKE agent-pod namespace. Start broad (severity=ERROR, sinceMinutes=60), then narrow with services/search. Returns compact lines: '<time> <SEVERITY> [<source>] <message> | key=value \u2026' (the key=value tail is the entry's structured payload \u2014 error details, service/method, actor and entity ids). When the response ends with a pageToken line, pass that token back as pageToken for the next page. To read a whole entry (long message, full payload), re-query narrowly with full=true.";
+var queryGcpLogsContract = defineToolContract({
+  name: "query_gcp_logs",
+  agent: {
+    description: `Query Google Cloud Logging for this project's linked GCP environments \u2014 use this to investigate a production or dev failure directly rather than guessing from the code. ${GCP_SHARED_DESC}`,
+    fields: gcpFields
+  },
+  mcp: {
+    description: `Query Google Cloud Logging for a project's linked GCP environments \u2014 use this to investigate production or dev issues directly ('something broke on prod'). ${GCP_SHARED_DESC} Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: { projectId: mcpProjectId, ...gcpFields }
+  }
+});
+var grafanaFields = {
+  env: f.optional(
+    f.enum(["prod", "dev"], {
+      desc: "Configured Grafana env mapping to scope by (default prod)"
+    })
+  ),
+  sinceMinutes: SINCE_MINUTES,
+  startTime: START_TIME,
+  endTime: END_TIME,
+  level: f.optional(
+    f.enum(["debug", "info", "warn", "error", "fatal"], {
+      desc: "Minimum severity, inclusive \u2014 error returns error and above"
+    })
+  ),
+  services: f.optional(
+    f.array(f.string(), { desc: "Restrict to these service_name label values" })
+  ),
+  search: f.optional(
+    f.string({ desc: "Substring line filter (exact substring, not regex)", max: 256 })
+  ),
+  logql: f.optional(
+    f.string({
+      desc: "Advanced: raw LogQL query \u2014 REPLACES env/services/level/search composition",
+      max: RAW_QUERY_MAX
+    })
+  ),
+  limit: LIMIT
+};
+var GRAFANA_SHARED_DESC = "the APPLICATION logs shipped to Grafana Cloud/Loki, complementing query_gcp_logs (GCP infrastructure logs). Start with structured filters (env, level=error, sinceMinutes=60, services), then narrow with search; pass raw LogQL via logql only when structured filters cannot express the query (it REPLACES them). The response header echoes the composed LogQL \u2014 iterate on it. Returns compact lines: '<time> <SEVERITY> [<service>] <message>'.";
+var queryGrafanaLogsContract = defineToolContract({
+  name: "query_grafana_logs",
+  agent: {
+    description: `Query this project's connected Grafana (Loki) logs \u2014 ${GRAFANA_SHARED_DESC}`,
+    fields: grafanaFields
+  },
+  mcp: {
+    description: `Query the project's connected Grafana (Loki) logs \u2014 ${GRAFANA_SHARED_DESC} Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: { projectId: mcpProjectId, ...grafanaFields }
+  }
+});
+var logsContracts = [
+  queryGcpLogsContract,
+  queryGrafanaLogsContract
+];
+var DETECTORS = ["partner", "player", "internal", "monitor", "agent", "unknown"];
+var LINK_KINDS = ["deployment", "origin", "fix"];
+var ATTRIBUTIONS = ["suspected", "confirmed"];
+var TIMESTAMP_HINT = "ISO 8601 timestamp; pass an empty string to clear it back to unknown. Never substitute card creation or closure time.";
+var DESCRIPTION = "Record an incident's outcome and attribution: impact, environment, who detected it, when the failure started, when it was detected, and when service was actually restored (alert clearance alone is not recovery). Optionally link a deployment, the origin task whose change caused it, or a fix task; attribution is 'suspected' until confirmed. remove_link_id soft-removes a wrong link (reason required). Every change is audited. Read the current record with get_task (field `incident`).";
+var updateIncidentContract = defineToolContract({
+  name: "update_incident",
+  agent: {
+    description: DESCRIPTION,
+    fields: {
+      incident_slug_or_id: f.optional(
+        f.string({
+          desc: "Incident card slug or ID. Omit when this session's card is the incident."
+        })
+      ),
+      impact: f.optional(f.string({ desc: "Who/what was affected and how badly" })),
+      environment: f.optional(f.string({ desc: "Affected environment, e.g. prod, staging, test" })),
+      detected_by: f.optional(f.enum(DETECTORS, { desc: "Who first noticed the failure" })),
+      failure_started_at: f.optional(
+        f.string({ desc: `When the failure began. ${TIMESTAMP_HINT}` })
+      ),
+      detected_at: f.optional(f.string({ desc: `When it was first detected. ${TIMESTAMP_HINT}` })),
+      service_restored_at: f.optional(
+        f.string({ desc: `When service was observed restored. ${TIMESTAMP_HINT}` })
+      ),
+      synthetic: f.optional(
+        f.boolean({ desc: "True for probe/acceptance incidents (excluded from delivery metrics)" })
+      ),
+      link_kind: f.optional(f.enum(LINK_KINDS, { desc: "Add or update a link of this kind" })),
+      link_task_slug_or_id: f.optional(
+        f.string({ desc: "Origin or fix task slug/ID (link_kind origin|fix)" })
+      ),
+      link_deployment_id: f.optional(f.string({ desc: "Deployment ID (link_kind deployment)" })),
+      attribution: f.optional(
+        f.enum(ATTRIBUTIONS, { desc: "Deployment/origin attribution; defaults to suspected" })
+      ),
+      required_immediate_intervention: f.optional(
+        f.boolean({
+          desc: "Deployment links: did the failure need a rollback, hotfix, or fix-forward?"
+        })
+      ),
+      link_note: f.optional(f.string({ desc: "Short evidence note for the link" })),
+      remove_link_id: f.optional(f.string({ desc: "ID of an existing link to remove" })),
+      reason: f.optional(f.string({ desc: "Why this changed (kept in the audit history)" }))
+    }
+  },
+  mcp: {
+    description: `${DESCRIPTION} Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The incident card ID or slug" }),
+      impact: f.optional(f.string({ desc: "Who/what was affected and how badly" })),
+      environment: f.optional(f.string({ desc: "Affected environment, e.g. prod, staging, test" })),
+      detectedBy: f.optional(f.enum(DETECTORS, { desc: "Who first noticed the failure" })),
+      failureStartedAt: f.optional(f.string({ desc: `When the failure began. ${TIMESTAMP_HINT}` })),
+      detectedAt: f.optional(f.string({ desc: `When it was first detected. ${TIMESTAMP_HINT}` })),
+      serviceRestoredAt: f.optional(
+        f.string({ desc: `When service was observed restored. ${TIMESTAMP_HINT}` })
+      ),
+      synthetic: f.optional(
+        f.boolean({ desc: "True for probe/acceptance incidents (excluded from delivery metrics)" })
+      ),
+      linkKind: f.optional(f.enum(LINK_KINDS, { desc: "Add or update a link of this kind" })),
+      linkTaskSlugOrId: f.optional(
+        f.string({ desc: "Origin or fix task slug/ID (linkKind origin|fix)" })
+      ),
+      linkDeploymentId: f.optional(f.string({ desc: "Deployment ID (linkKind deployment)" })),
+      attribution: f.optional(
+        f.enum(ATTRIBUTIONS, { desc: "Deployment/origin attribution; defaults to suspected" })
+      ),
+      requiredImmediateIntervention: f.optional(
+        f.boolean({
+          desc: "Deployment links: did the failure need a rollback, hotfix, or fix-forward?"
+        })
+      ),
+      linkNote: f.optional(f.string({ desc: "Short evidence note for the link" })),
+      removeLinkId: f.optional(f.string({ desc: "ID of an existing link to remove" })),
+      reason: f.optional(f.string({ desc: "Why this changed (kept in the audit history)" }))
+    }
+  }
+});
+var incidentsContracts = [updateIncidentContract];
+var SHA = f.optional(
+  f.string({
+    desc: "Commit sha to watch, full or abbreviated. Defaults to the head of prNumber, else this card's PR, else the tip of this card's branch.",
+    min: 7,
+    max: 40
+  })
+);
+var PR_NUMBER = f.optional(
+  f.number({
+    desc: "PR number whose current head to watch. Use this for a child's PR when orchestrating a pack.",
+    int: true,
+    positive: true
+  })
+);
+var TIMEOUT_MINUTES = f.optional(
+  f.number({
+    desc: `Give up after this many minutes (default ${DEFAULT_CI_WAIT_TIMEOUT_MINUTES}, max ${MAX_CI_WAIT_TIMEOUT_MINUTES}); you are woken with timed_out.`,
+    int: true,
+    min: 1,
+    max: MAX_CI_WAIT_TIMEOUT_MINUTES
+  })
+);
+var waitForChecksContract = defineToolContract({
+  name: "wait_for_checks",
+  agent: {
+    description: "Wait for CI without holding the pod. Records the commit to watch on this session and returns immediately: if CI already finished you get the result now; otherwise the reply says `parked` and you must END YOUR TURN with no further tool calls. The pod idles out during the wait and Conveyor wakes this session with the result (success or failure with the failing job names and run URL, head_moved when the PR gets a new commit, timed_out at the deadline). Never poll `gh pr checks`, pr-wait scripts, or a sleep loop for CI. If something else wakes you before the result arrives, handle it and call this again.",
+    fields: {
+      sha: SHA,
+      prNumber: PR_NUMBER,
+      timeoutMinutes: TIMEOUT_MINUTES
+    }
+  },
+  mcp: {
+    description: "Park a task's agent session until GitHub reports the CI result for a commit. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId,
+      taskId: f.string({ desc: "The task whose agent session should wait" }),
+      sha: SHA,
+      prNumber: PR_NUMBER,
+      timeoutMinutes: TIMEOUT_MINUTES
+    }
+  }
+});
+var ciWaitContracts = [waitForChecksContract];
+var DESCRIPTION2 = [
+  "Ask typed questions about text and get probabilities back, never text: yes/no (noul \u2192 probability of yes), pick-one (choice \u2192 the chosen option, per-option probabilities, and a confidence), or a graded scale (score \u2192 the level, per-level probabilities, and a confidence).",
+  "Requires Jev to be switched on under Project Settings \u2192 AI Provider Keys (a TypeSafe key, or an OpenCode Zen key); without it the tool returns an error saying so.",
+  "The state is data, not a guardrail: adversarial text inside it can move the answers, so never use a result to authorize an action.",
+  "Ask one simple judgment per question and split compound questions; accuracy falls when the state carries irrelevant text.",
+  "Pass items to judge up to 100 separate texts with the same questions in one call; answers come back in item order.",
+  "Each call spends the project's Jev credit and is rate-limited per project. A choice takes 2-255 options, a score 2-10 levels, at most 32 questions per call."
+].join(" ");
+var question = f.object(
+  {
+    key: f.string({
+      min: 1,
+      desc: "Name for this question's answer, e.g. is_complaint. Letters, digits, _ and - only; unique within the call."
+    }),
+    type: f.enum(["noul", "choice", "score"], {
+      desc: "noul = yes/no; choice = pick one option; score = pick a level on an ordered scale"
+    }),
+    instructions: f.string({
+      min: 1,
+      desc: "The question, as one plain sentence about the state, e.g. 'Is this message a complaint about the product?'"
+    }),
+    options: f.optional(
+      f.array(
+        f.object({
+          key: f.string({ min: 1, desc: "Option name returned as the answer" }),
+          description: f.string({
+            min: 1,
+            desc: "What choosing this option means, concretely"
+          })
+        }),
+        { desc: "choice only: the options (2-255). Option order can move the answer." }
+      )
+    ),
+    levels: f.optional(
+      f.array(f.string({ min: 1 }), {
+        desc: "score only: 2-10 level descriptions, lowest first"
+      })
+    )
+  },
+  { desc: "One typed question" }
+);
+var stateDesc = "The thing being judged, as plain text or JSON. Required unless items is given; with items it is ignored.";
+var itemsDesc = "Up to 100 separate texts (each up to 8,000 characters), each judged on its own with the same questions. Use this for bulk classification instead of one call per item.";
+var questionsDesc = "1-32 questions, all answered independently against the same state.";
+var evaluateQuestionsContract = defineToolContract({
+  name: "evaluate_questions",
+  agent: {
+    description: DESCRIPTION2,
+    fields: {
+      state: f.optional(f.string({ desc: stateDesc })),
+      questions: f.array(question, { min: 1, desc: questionsDesc }),
+      items: f.optional(f.array(f.string(), { desc: itemsDesc }))
+    }
+  },
+  mcp: {
+    description: `${DESCRIPTION2} Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: {
+      projectId: mcpProjectId,
+      state: f.optional(f.string({ desc: stateDesc })),
+      questions: f.array(question, { min: 1, desc: questionsDesc }),
+      items: f.optional(f.array(f.string(), { desc: itemsDesc }))
+    }
+  }
+});
+var evaluateContracts = [evaluateQuestionsContract];
+var listSiteAssetTargetsContract = defineToolContract({
+  name: "list_site_asset_targets",
+  agent: {
+    description: "List the registered static-site media targets this card's project may publish to.",
+    fields: {}
+  },
+  mcp: {
+    description: "List registered static-site media targets for a project.",
+    fields: { projectId: mcpProjectId }
+  }
+});
+var uploadSiteAssetsContract = defineToolContract({
+  name: "upload_site_assets",
+  agent: {
+    description: "Upload up to 50 workspace image or video files (25 MiB each) to a registered site using Conveyor identity. Call list_site_asset_targets first for the registered siteId. Returns verified immutable keys and public URLs per file.",
+    fields: {
+      siteId: f.string({ min: 1, max: 100 }),
+      paths: f.array(f.string({ min: 1 }), { min: 1, max: 50 })
+    }
+  },
+  mcp: {
+    description: "Upload up to 50 workspace image or video files (25 MiB each) to a registered site using Conveyor identity. Call list_site_asset_targets first for the registered siteId. Returns verified immutable keys and public URLs per file.",
+    fields: {
+      projectId: mcpProjectId,
+      siteId: f.string({ min: 1, max: 100 }),
+      paths: f.array(f.string({ min: 1 }), { min: 1, max: 50 })
+    }
+  }
+});
+var siteAssetsContracts = [
+  listSiteAssetTargetsContract,
+  uploadSiteAssetsContract
+];
+function validateSiteAssetResult(value, expected) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("verify returned invalid JSON");
+  const result = value;
+  for (const key of ["key", "publicUrl", "sha256", "sizeBytes", "mimeType"]) {
+    if (result[key] !== expected[key])
+      throw new Error(`verify response ${key} does not match upload capability`);
+  }
+  if (result.status !== "uploaded" && result.status !== "existing")
+    throw new Error("verify response has invalid status");
+  return { ...expected, status: result.status };
+}
+async function readReply(response) {
+  if (!response.body) throw new Error("verify returned an empty response");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let text = "";
+  let size = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      size += value.byteLength;
+      if (size > 16384) throw new Error("verify response exceeds 16KiB");
+      text += decoder.decode(value, { stream: true });
+    }
+    text += decoder.decode();
+  } finally {
+    await reader.cancel();
+    reader.releaseLock();
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error("verify returned invalid JSON");
+  }
+}
+async function transferSiteAsset(capability, bytes, expected) {
+  const options = {
+    headers: capability.headers,
+    redirect: "error",
+    signal: AbortSignal.timeout(6e4)
+  };
+  let put;
+  try {
+    put = await fetch(capability.uploadUrl, { ...options, method: "PUT", body: bytes });
+  } catch {
+    throw new Error("Upload transfer failed or timed out; retry this file");
+  }
+  await put.body?.cancel();
+  if (!put.ok) throw new Error(`upload HTTP ${put.status}; retry or check site access`);
+  let verify;
+  try {
+    verify = await fetch(`${new URL(capability.uploadUrl).origin}/_site-assets/verify`, {
+      ...options,
+      method: "POST",
+      signal: AbortSignal.timeout(6e4)
+    });
+  } catch {
+    throw new Error("Upload verification failed or timed out; retry this file");
+  }
+  if (!verify.ok) {
+    await verify.body?.cancel();
+    throw new Error(`verify HTTP ${verify.status}; retry or check site access`);
+  }
+  return {
+    ...validateSiteAssetResult(await readReply(verify), expected),
+    status: put.status === 201 ? "uploaded" : "existing"
+  };
+}
+var TOOL_CONTRACTS = Object.fromEntries(
+  [
+    ...tasksContracts,
+    ...taskUpdateContracts,
+    ...tagsContracts,
+    ...checklistContracts,
+    ...dependenciesContracts,
+    ...subtasksContracts,
+    ...attachmentsContracts,
+    ...suggestionsContracts,
+    ...decisionsContracts,
+    ...pullRequestContracts,
+    ...integrationsContracts,
+    ...driveContracts,
+    ...meetingsContracts,
+    ...logsContracts,
+    ...ciWaitContracts,
+    ...evaluateContracts,
+    ...incidentsContracts,
+    ...siteAssetsContracts
+  ].map((contract) => [contract.name, contract])
+);
+
+export {
+  DEFAULT_SONNET_MODEL,
+  DEFAULT_OPUS_MODEL,
+  DEFAULT_HAIKU_MODEL,
+  FABLE_MODEL,
+  PREVIOUS_SONNET_MODEL,
+  PREVIOUS_OPUS_MODEL,
+  formatModelId,
+  JEV_STATE_MAX_CHARS,
+  CARD_DESCRIPTION_MAX,
+  CARD_DESCRIPTION_LIMIT_MESSAGE,
+  ManualTestItemsSchema,
+  describeManualTestRejection,
+  MAX_CI_WAIT_TIMEOUT_MINUTES,
+  runQueryGcpLogs,
+  runQueryGrafanaLogs,
+  compileShape,
+  cardDescriptionDesc,
+  priorityValueDesc,
+  getTaskContract,
+  postToChatContract,
+  readTaskChatContract,
+  listTagsContract,
+  searchTasksContract,
+  getConnectionContextContract,
+  updateTaskContract,
+  getTagContract,
+  listManualTestsContract,
+  queryManualTestsContract,
+  setManualTestsContract,
+  editManualTestContract,
+  removeManualTestContract,
+  approveManualTestContract,
+  rejectManualTestContract,
+  getDependenciesContract,
+  addDependencyContract,
+  removeDependencyContract,
+  createSubtaskContract,
+  updateSubtaskContract,
+  deleteSubtaskContract,
+  listSubtasksContract,
+  setTaskParentContract,
+  listTaskFilesContract,
+  getAttachmentContract,
+  uploadAttachmentContract,
+  deleteAttachmentContract,
+  setShowcaseContract,
+  createSuggestionContract,
+  createDecisionContract,
+  listDecisionsContract,
+  getDecisionContract,
+  voteDecisionContract,
+  resolveDecisionContract,
+  updateDecisionContract,
+  createPullRequestContract,
+  listProjectIntegrationsContract,
+  listProjectChannelsContract,
+  readChannelMessagesContract,
+  postChannelMessageContract,
+  getAnalyticsSummaryContract,
+  driveListFilesContract,
+  driveReadFileContract,
+  driveCreateFileContract,
+  driveUpdateFileContract,
+  driveDeleteFileContract,
+  driveCreateFolderContract,
+  listMeetingsContract,
+  getMeetingContract,
+  readMeetingTranscriptContract,
+  createMeetingContract,
+  updateMeetingContract,
+  addMeetingChecklistItemsContract,
+  checkMeetingChecklistItemContract,
+  editMeetingChecklistItemContract,
+  removeMeetingChecklistItemContract,
+  queryGcpLogsContract,
+  queryGrafanaLogsContract,
+  updateIncidentContract,
+  evaluateQuestionsContract,
+  listSiteAssetTargetsContract,
+  uploadSiteAssetsContract,
+  transferSiteAsset
+};