@rallycry/conveyor-agent 10.13.72 → 11.0.0

package/dist/{chunk-2SN32LM6.js → chunk-PEEGCZAR.js}

@@ -30,11 +30,11 @@ import {
   statWorkspacePath,
   updateRemoteToken,
   verifyGitCredential
-} from "./chunk-LSZ2KLJY.js";
+} from "./chunk-N4WSUTGV.js";
 import {
   registerBootMilestoneSocketFallback,
   reportBootMilestone
-} from "./chunk-WMMBAKPE.js";
+} from "./chunk-GL2DIQEQ.js";
 import {
   LoopLagMonitor,
   loopStatusForRunnerStatus
@@ -78,16 +78,140 @@ import {
   sleep
 } from "./chunk-W4LZ7R6Z.js";
 
-// src/connection/auth-errors.ts
-function isPermissionDeniedError(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  return /insufficient permissions|authentication required/i.test(message);
-}
-
-// ../shared/dist/chunk-6RHVH33O.js
+// ../shared/dist/chunk-OKJPFFQI.js
 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 SEVERITY_ENUM = [
+  "DEBUG",
+  "INFO",
+  "NOTICE",
+  "WARNING",
+  "ERROR",
+  "CRITICAL",
+  "ALERT",
+  "EMERGENCY"
+];
+var MAX_LINE_CHARS = 400;
+var DEFAULT_SINCE_MINUTES = 60;
+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 {
+    return "";
+  }
+  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 formatLogEntryLine(entry) {
+  const httpPrefix = entry.httpRequest?.status ? `http ${entry.httpRequest.status} ${entry.httpRequest.method ?? ""} ${entry.httpRequest.url ?? ""}`.trim() + " \u2014 " : "";
+  return `${entry.timestamp} ${entry.severity.padEnd(7)} [${entrySource(entry)}] ${truncateLine(
+    `${httpPrefix}${entry.message}${formatPayloadSuffix(entry.payload)}`
+  )}`;
+}
+async function runQueryGcpLogs(port, params, now = Date.now) {
+  const startTime = params.startTime ?? new Date(now() - (params.sinceMinutes ?? DEFAULT_SINCE_MINUTES) * 6e4).toISOString();
+  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: params.limit,
+    pageToken: params.pageToken
+  });
+  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}`
+  ].join(" ");
+  const lines = 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/index.js
 import { z } from "zod";
@@ -97,6 +221,8 @@ import { z as z4 } from "zod";
 import { z as z5 } from "zod";
 import { z as z6 } from "zod";
 import { z as z7 } from "zod";
+import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var EXTERNAL_AGENT_MESSAGE_SOURCE = "external_agent";
 var DEFAULT_SONNET_MODEL = "claude-sonnet-5";
 var DEFAULT_OPUS_MODEL = "claude-opus-5";
@@ -282,12 +408,24 @@ var ACTIVE_WORK_STATUSES = [
   "Complete"
 ];
 var IDENTIFIED_WORK_STATUSES = ["Open", ...ACTIVE_WORK_STATUSES];
+var DEFAULT_TASK_STATUS_COLOR = "#a8a29e";
+var DEFAULT_TASK_STATUS_COLOR_INT = Number.parseInt(DEFAULT_TASK_STATUS_COLOR.slice(1), 16);
 var MAX_FILE_SIZE_BYTES = 25 * 1024 * 1024;
 var MAX_FILE_TAGS = 5;
 var MAX_FILE_TAG_LENGTH = 100;
 var EMBED_THRESHOLD_IMAGES = 5 * 1024 * 1024;
 var EMBED_THRESHOLD_TEXT = 2 * 1024 * 1024;
 var IDLE_HEARTBEAT_MS = 90 * 1e3;
+var RUNNER_MODES = [
+  "task",
+  "plan",
+  "pm",
+  "code-review",
+  "adhoc",
+  "pack",
+  "shell",
+  "serving"
+];
 var TurnEndToolCallSchema = z3.object({
   tool: z3.string(),
   input: z3.string().optional(),
@@ -845,6 +983,9 @@ var ReportReviewSpawnFailureRequestSchema = z4.object({
   reviewSessionId: z4.string(),
   error: z4.string().max(2e3).optional()
 });
+var ReportBuilderSpawnFailureRequestSchema = ReportReviewSpawnFailureRequestSchema.omit({
+  reviewSessionId: true
+}).extend({ buildSessionId: z4.string() });
 var RequestWorkspaceRecycleRequestSchema = z4.object({
   sessionId: z4.string(),
   reason: z4.string().max(2e3)
@@ -1497,12 +1638,46 @@ var CreateProjectSuggestionRequestSchema = z5.object({
   tagNames: z5.array(z5.string()).optional(),
   requestingUserId: z5.string().optional()
 });
+var ListProjectChannelsRequestSchema = z6.object({
+  projectId: z6.string()
+});
+var READ_CHANNEL_MESSAGES_MAX_LIMIT = 50;
+var ReadChannelMessagesRequestSchema = z6.object({
+  projectId: z6.string(),
+  channelId: z6.string().min(1).max(200),
+  limit: z6.number().int().min(1).max(READ_CHANNEL_MESSAGES_MAX_LIMIT).optional(),
+  /** Provider-native cursor: return messages OLDER than this one. */
+  before: z6.string().max(100).optional(),
+  /** Provider-native cursor: return messages NEWER than this one. */
+  after: z6.string().max(100).optional(),
+  /**
+   * Read one thread instead of the channel surface. Slack calls this a
+   * `thread_ts`; on Discord it is the thread channel's id. One field for both,
+   * because a caller holding a `threadTs` from a previous read should not have
+   * to know which provider produced it.
+   */
+  threadTs: z6.string().max(100).optional()
+});
+var POST_CHANNEL_MESSAGE_MAX_CHARS = 1800;
+var PostChannelMessageRequestSchema = z6.object({
+  projectId: z6.string(),
+  channelId: z6.string().min(1).max(200),
+  text: z6.string().min(1).max(POST_CHANNEL_MESSAGE_MAX_CHARS),
+  /** Reply inside a thread rather than to the channel. */
+  threadTs: z6.string().max(100).optional()
+});
+var GET_ANALYTICS_SUMMARY_MAX_RANGE_DAYS = 90;
+var GetProjectAnalyticsSummaryRequestSchema = z6.object({
+  projectId: z6.string(),
+  rangeDays: z6.number().int().min(1).max(GET_ANALYTICS_SUMMARY_MAX_RANGE_DAYS).optional(),
+  campaign: z6.string().max(200).optional()
+});
 var SHA_PATTERN = /^[0-9a-f]{40}$/i;
-var ReviewGuideFileReferenceSchema = z6.object({
-  path: z6.string().min(1).max(500),
-  startLine: z6.number().int().positive().max(1e6).optional(),
-  endLine: z6.number().int().positive().max(1e6).optional(),
-  hunkHeader: z6.string().min(1).max(300).optional()
+var ReviewGuideFileReferenceSchema = z7.object({
+  path: z7.string().min(1).max(500),
+  startLine: z7.number().int().positive().max(1e6).optional(),
+  endLine: z7.number().int().positive().max(1e6).optional(),
+  hunkHeader: z7.string().min(1).max(300).optional()
 }).strict().superRefine((value, ctx) => {
   if (value.endLine !== void 0 && value.startLine === void 0) {
     ctx.addIssue({
@@ -1519,19 +1694,19 @@ var ReviewGuideFileReferenceSchema = z6.object({
     });
   }
 });
-var ReviewGuideSectionSchema = z6.object({
-  title: z6.string().min(1).max(160),
-  explanation: z6.string().min(1).max(2e3),
-  classification: z6.enum(["core", "supporting"]).optional(),
-  files: z6.array(ReviewGuideFileReferenceSchema).min(1).max(20)
+var ReviewGuideSectionSchema = z7.object({
+  title: z7.string().min(1).max(160),
+  explanation: z7.string().min(1).max(2e3),
+  classification: z7.enum(["core", "supporting"]).optional(),
+  files: z7.array(ReviewGuideFileReferenceSchema).min(1).max(20)
 }).strict();
-var ReviewGuideContentSchema = z6.object({
-  overview: z6.string().min(1).max(3e3),
-  sections: z6.array(ReviewGuideSectionSchema).min(1).max(12)
+var ReviewGuideContentSchema = z7.object({
+  overview: z7.string().min(1).max(3e3),
+  sections: z7.array(ReviewGuideSectionSchema).min(1).max(12)
 }).strict();
 var PublishReviewGuideRequestSchema = ReviewGuideContentSchema.extend({
-  sessionId: z6.string().min(1),
-  reviewedSha: z6.string().regex(SHA_PATTERN, "reviewedSha must be a 40-character commit SHA")
+  sessionId: z7.string().min(1),
+  reviewedSha: z7.string().regex(SHA_PATTERN, "reviewedSha must be a 40-character commit SHA")
 }).strict();
 var CONTEXT_LINK_LOCATOR_MAX = 300;
 var TEST_TITLE = /\b(?:it|test|describe)(?:\.\w+)?\s*\(\s*(['"`])((?:(?!\1)[\s\S])*)\1/g;
@@ -1548,130 +1723,130 @@ function locatorMatchesContent(content, locatorType, locator) {
 var TAG_DESCRIPTION_MAX = CARD_DESCRIPTION_MAX;
 var TAG_OVERVIEW_MAX = 32e3;
 var TAG_REASON_MAX = 500;
-var ProjectTagContextPathSchema = z7.object({
-  type: z7.enum(["rule", "doc", "file", "folder"]),
-  path: z7.string().min(1).max(500),
-  label: z7.string().max(100).optional(),
+var ProjectTagContextPathSchema = z8.object({
+  type: z8.enum(["rule", "doc", "file", "folder"]),
+  path: z8.string().min(1).max(500),
+  label: z8.string().max(100).optional(),
   /** Verified-link tether — text that must keep existing in the file. */
-  locator: z7.string().min(1).max(CONTEXT_LINK_LOCATOR_MAX).regex(/^[^\r\n]*$/, "Locator cannot contain line breaks").optional(),
+  locator: z8.string().min(1).max(CONTEXT_LINK_LOCATOR_MAX).regex(/^[^\r\n]*$/, "Locator cannot contain line breaks").optional(),
   /** test = must appear in a real test/describe title; code = any substring. */
-  locatorType: z7.enum(["test", "code"]).optional()
+  locatorType: z8.enum(["test", "code"]).optional()
 }).refine((link) => link.locator === void 0 === (link.locatorType === void 0), {
   message: "locator and locatorType must be provided together"
 }).refine((link) => link.locator === void 0 || link.type !== "folder", {
   message: "folder links cannot carry a locator"
 });
-var hexColor = z7.string().regex(/^#[0-9a-fA-F]{6}$/, "Expected #RRGGBB hex color");
-var overviewPathSchema = z7.string().min(1).max(500).regex(/^[^\r\n]*$/, "Overview path cannot contain line breaks");
-var CreateProjectTagRequestSchema = z7.object({
-  projectId: z7.string(),
-  name: z7.string().min(1).max(50),
+var hexColor = z8.string().regex(/^#[0-9a-fA-F]{6}$/, "Expected #RRGGBB hex color");
+var overviewPathSchema = z8.string().min(1).max(500).regex(/^[^\r\n]*$/, "Overview path cannot contain line breaks");
+var CreateProjectTagRequestSchema = z8.object({
+  projectId: z8.string(),
+  name: z8.string().min(1).max(50),
   color: hexColor.optional(),
-  description: z7.string().max(TAG_DESCRIPTION_MAX).optional(),
-  overview: z7.string().max(TAG_OVERVIEW_MAX).optional(),
+  description: z8.string().max(TAG_DESCRIPTION_MAX).optional(),
+  overview: z8.string().max(TAG_OVERVIEW_MAX).optional(),
   /** Source the overview from this repo file (stored overview stays as the pending fallback). */
   overviewPath: overviewPathSchema.optional(),
-  contextPaths: z7.array(ProjectTagContextPathSchema).max(20).optional(),
+  contextPaths: z8.array(ProjectTagContextPathSchema).max(20).optional(),
   /** Parents to link at create time (multi-parent DAG). */
-  parentTagIds: z7.array(z7.string()).max(25).optional(),
-  requestingUserId: z7.string().optional()
+  parentTagIds: z8.array(z8.string()).max(25).optional(),
+  requestingUserId: z8.string().optional()
 });
-var UpdateProjectTagRequestSchema = z7.object({
-  projectId: z7.string(),
-  tagId: z7.string(),
-  name: z7.string().min(1).max(50).optional(),
+var UpdateProjectTagRequestSchema = z8.object({
+  projectId: z8.string(),
+  tagId: z8.string(),
+  name: z8.string().min(1).max(50).optional(),
   color: hexColor.optional(),
-  description: z7.string().max(TAG_DESCRIPTION_MAX).optional(),
+  description: z8.string().max(TAG_DESCRIPTION_MAX).optional(),
   /** Full markdown glossary body; null clears it. Rejected while overviewPath is set. */
-  overview: z7.string().max(TAG_OVERVIEW_MAX).nullable().optional(),
+  overview: z8.string().max(TAG_OVERVIEW_MAX).nullable().optional(),
   /** Repo file to source the overview from; null clears back to the stored overview. */
   overviewPath: overviewPathSchema.nullable().optional(),
   /** Full replacement of the tag's context links when provided. */
-  contextPaths: z7.array(ProjectTagContextPathSchema).max(20).optional(),
+  contextPaths: z8.array(ProjectTagContextPathSchema).max(20).optional(),
   /** Full-set replacement of the tag's parent tags (multi-parent DAG). */
-  parentTagIds: z7.array(z7.string()).max(25).optional(),
+  parentTagIds: z8.array(z8.string()).max(25).optional(),
   /** One-line revision provenance, recorded in the tag's history. */
-  reason: z7.string().max(TAG_REASON_MAX).optional(),
+  reason: z8.string().max(TAG_REASON_MAX).optional(),
   /** Card the caller was working in — stamped into the revision history. */
-  taskId: z7.string().optional(),
-  requestingUserId: z7.string().optional()
+  taskId: z8.string().optional(),
+  requestingUserId: z8.string().optional()
 });
-var PostToProjectChatRequestSchema = z7.object({
-  projectId: z7.string(),
-  content: z7.string().min(1).max(2e4),
-  requestingUserId: z7.string().optional(),
+var PostToProjectChatRequestSchema = z8.object({
+  projectId: z8.string(),
+  content: z8.string().min(1).max(2e4),
+  requestingUserId: z8.string().optional(),
   /** Marks the post so the server can persist it beyond chat (tag-audit summaries land in tag history). */
-  kind: z7.enum(["tag_audit_summary"]).optional()
-});
-var StartTagAuditRequestSchema = z7.object({
-  projectId: z7.string(),
-  requestingUserId: z7.string().optional()
-});
-var StartTaskAuditRequestSchema = z7.object({
-  projectId: z7.string(),
-  taskIds: z7.array(z7.string()).min(1).max(20),
-  requestingUserId: z7.string().optional()
-});
-var GetActiveAuditSessionsRequestSchema = z7.object({
-  projectId: z7.string()
-});
-var ReportTaskAuditResultRequestSchema = z7.object({
-  projectId: z7.string(),
-  taskId: z7.string(),
-  summary: z7.string(),
-  turnGrades: z7.array(
-    z7.object({
-      turnIndex: z7.number(),
-      phase: z7.enum(["planning", "building", "human"]),
-      grade: z7.enum(["correct", "neutral", "blunder"]),
-      reasoning: z7.string(),
-      eventType: z7.string(),
-      eventSummary: z7.string()
+  kind: z8.enum(["tag_audit_summary"]).optional()
+});
+var StartTagAuditRequestSchema = z8.object({
+  projectId: z8.string(),
+  requestingUserId: z8.string().optional()
+});
+var StartTaskAuditRequestSchema = z8.object({
+  projectId: z8.string(),
+  taskIds: z8.array(z8.string()).min(1).max(20),
+  requestingUserId: z8.string().optional()
+});
+var GetActiveAuditSessionsRequestSchema = z8.object({
+  projectId: z8.string()
+});
+var ReportTaskAuditResultRequestSchema = z8.object({
+  projectId: z8.string(),
+  taskId: z8.string(),
+  summary: z8.string(),
+  turnGrades: z8.array(
+    z8.object({
+      turnIndex: z8.number(),
+      phase: z8.enum(["planning", "building", "human"]),
+      grade: z8.enum(["correct", "neutral", "blunder"]),
+      reasoning: z8.string(),
+      eventType: z8.string(),
+      eventSummary: z8.string()
     })
   ),
-  planningAccuracy: z7.number().nullable(),
-  buildingAccuracy: z7.number().nullable(),
-  humanAccuracy: z7.number().nullable(),
-  planningCorrect: z7.number(),
-  planningNeutral: z7.number(),
-  planningBlunder: z7.number(),
-  buildingCorrect: z7.number(),
-  buildingNeutral: z7.number(),
-  buildingBlunder: z7.number(),
-  humanCorrect: z7.number(),
-  humanNeutral: z7.number(),
-  humanBlunder: z7.number(),
-  humanEvaluations: z7.array(
-    z7.object({
-      messageIndex: z7.number(),
-      rating: z7.union([z7.literal(-1), z7.literal(0), z7.literal(1)]),
-      reasoning: z7.string()
+  planningAccuracy: z8.number().nullable(),
+  buildingAccuracy: z8.number().nullable(),
+  humanAccuracy: z8.number().nullable(),
+  planningCorrect: z8.number(),
+  planningNeutral: z8.number(),
+  planningBlunder: z8.number(),
+  buildingCorrect: z8.number(),
+  buildingNeutral: z8.number(),
+  buildingBlunder: z8.number(),
+  humanCorrect: z8.number(),
+  humanNeutral: z8.number(),
+  humanBlunder: z8.number(),
+  humanEvaluations: z8.array(
+    z8.object({
+      messageIndex: z8.number(),
+      rating: z8.union([z8.literal(-1), z8.literal(0), z8.literal(1)]),
+      reasoning: z8.string()
     })
   ).optional(),
-  suggestionIds: z7.array(z7.string()),
-  auditCostUsd: z7.number().nullable(),
-  model: z7.string().nullable(),
+  suggestionIds: z8.array(z8.string()),
+  auditCostUsd: z8.number().nullable(),
+  model: z8.string().nullable(),
   /** When set, the audit is marked failed with this message instead. */
-  error: z7.string().optional()
+  error: z8.string().optional()
 });
-var GetTaskAuditsRequestSchema = z7.object({
-  projectId: z7.string(),
-  limit: z7.number().int().positive().max(200).optional().default(50)
+var GetTaskAuditsRequestSchema = z8.object({
+  projectId: z8.string(),
+  limit: z8.number().int().positive().max(200).optional().default(50)
 });
-var GetTaskAuditRequestSchema = z7.object({
-  projectId: z7.string(),
-  auditId: z7.string()
+var GetTaskAuditRequestSchema = z8.object({
+  projectId: z8.string(),
+  auditId: z8.string()
 });
-var GetTaskAuditAggregatesRequestSchema = z7.object({
-  projectId: z7.string()
+var GetTaskAuditAggregatesRequestSchema = z8.object({
+  projectId: z8.string()
 });
-var DeleteTaskAuditRequestSchema = z7.object({
-  projectId: z7.string(),
-  auditId: z7.string(),
-  requestingUserId: z7.string().optional()
+var DeleteTaskAuditRequestSchema = z8.object({
+  projectId: z8.string(),
+  auditId: z8.string(),
+  requestingUserId: z8.string().optional()
 });
-var MarkInitialPromptSubmittedRequestSchema = z7.object({
-  sessionId: z7.string()
+var MarkInitialPromptSubmittedRequestSchema = z8.object({
+  sessionId: z8.string()
 });
 var CRITICAL_AUTOMATED_SOURCES = /* @__PURE__ */ new Set([
   "ci_failure",
@@ -1684,6 +1859,52 @@ var CRITICAL_AUTOMATED_SOURCES = /* @__PURE__ */ new Set([
   // reported completed for a prior turn. Only ever sent to parent tasks.
   "parent"
 ]);
+var PACK_EXECUTIONS = ["single-pod", "fan-out"];
+var DEFAULT_PACK_EXECUTION = "single-pod";
+function parsePackExecution(value) {
+  return PACK_EXECUTIONS.includes(value ?? "") ? value : DEFAULT_PACK_EXECUTION;
+}
+var MEETING_TRANSCRIPT_MAX_CHARS = 2e6;
+var MEETING_TITLE_MAX = 200;
+var CreateMeetingFromTranscriptRequestSchema = z9.object({
+  projectId: z9.string().cuid(),
+  rawText: z9.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
+  title: z9.string().min(1).max(MEETING_TITLE_MAX).optional(),
+  /** ISO 8601. Defaults to now when the source carries no date. */
+  occurredAt: z9.string().datetime().optional(),
+  /** Override auto-detection. Rarely needed; detection handles the three formats. */
+  format: z9.enum(["text", "vtt", "srt"]).optional(),
+  source: z9.enum(["manual", "slack"]).optional()
+});
+var GetMeetingRequestSchema = z9.object({
+  projectId: z9.string().cuid(),
+  meetingId: z9.string().cuid()
+});
+var UpdateMeetingRequestSchema = z9.object({
+  projectId: z9.string().cuid(),
+  meetingId: z9.string().cuid(),
+  title: z9.string().min(1).max(MEETING_TITLE_MAX).optional(),
+  occurredAt: z9.string().datetime().optional()
+});
+var RegenerateMeetingSummaryRequestSchema = z9.object({
+  projectId: z9.string().cuid(),
+  meetingId: z9.string().cuid()
+});
+var DeleteMeetingRequestSchema = z9.object({
+  projectId: z9.string().cuid(),
+  meetingId: z9.string().cuid()
+});
+var ListMeetingsRequestSchema = z9.object({
+  projectId: z9.string().cuid(),
+  limit: z9.number().int().min(1).max(50).optional(),
+  search: z9.string().max(200).optional()
+});
+var ReadMeetingTranscriptRequestSchema = z9.object({
+  projectId: z9.string().cuid(),
+  meetingId: z9.string().cuid(),
+  offset: z9.number().int().min(0).optional(),
+  limit: z9.number().int().min(1).max(500).optional()
+});
 var AGENT_STATUS_REASON_USER_QUESTION = "user_question";
 var TASK_CHAT_HISTORY_LIMIT = 20;
 var PM_CHAT_HISTORY_LIMIT = 40;
@@ -2034,6 +2255,12 @@ var surfaceTypes = (surface) => Object.keys(CARD_TYPE_SURFACE).filter(
 var BOARD_CARD_TYPES = surfaceTypes("board");
 var REPORT_CARD_TYPES = surfaceTypes("report");
 
+// src/connection/auth-errors.ts
+function isPermissionDeniedError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return /insufficient permissions|authentication required/i.test(message);
+}
+
 // src/runner/mode-controller.ts
 var ModeController = class {
   _mode;
@@ -2041,10 +2268,46 @@ var ModeController = class {
   _pendingModeRestart = false;
   _runnerMode;
   _isAuto;
+  /**
+   * Which planner this is. Only read when `_runnerMode` is `plan`; see
+   * `effectiveMode` for the full reasoning, and `latchPlanFlavor` for why this
+   * latches toward `chat` and never away from it.
+   */
+  _planFlavor = "discovery";
   constructor(initialMode, runnerMode = "task", isAuto = false) {
     this._mode = initialMode;
     this._runnerMode = runnerMode;
     this._isAuto = isAuto;
+    this.latchPlanFlavor(initialMode);
+  }
+  /**
+   * Promote this planner to the chat flavor, once, and never demote it.
+   *
+   * It cannot be a constructor-only assignment, because the constructor usually
+   * has nothing to go on. A GKE pod's bootstrap bundle carries no agentMode, so
+   * `CONVEYOR_AGENT_MODE` is unset and `initialMode` falls back to `"building"`
+   * for EVERY pod — which is the whole reason `applyServerMode` exists. Pinning
+   * the flavor at construction alone would therefore make every chat card in the
+   * cloud a discovery planner and silently re-open the defect this replaced.
+   *
+   * One-way, and both directions matter:
+   *
+   * - Only the literal card mode `chat` promotes. The server reports `chat` only
+   *   for a card whose agentMode IS `chat`, so a discovery card can never be
+   *   talked into the build-capable flavor. The original hazard — `auto` stamped
+   *   onto a plan-less auto card's planner — is untouched, because `auto` is not
+   *   `chat`.
+   * - Nothing demotes. The Build press overwrites `Task.agentMode` to
+   *   `auto`/`building` before the server sees it, so a later stamp would
+   *   otherwise strip a live conversation's prompt and file deliverables
+   *   mid-turn.
+   *
+   * The asymmetry with `auto` is principled rather than convenient: an auto
+   * card's mode and its planner phase legitimately differ, while a chat card's
+   * mode IS what its session is, for the session's whole life.
+   */
+  latchPlanFlavor(agentMode) {
+    if (agentMode === "chat") this._planFlavor = "chat";
   }
   // ── Getters ────────────────────────────────────────────────────────
   get mode() {
@@ -2065,8 +2328,28 @@ var ModeController = class {
   set pendingModeRestart(val) {
     this._pendingModeRestart = val;
   }
-  /** Effective mode accounting for PM/task defaults */
+  /**
+   * Effective mode accounting for PM/task defaults.
+   *
+   * A `plan` runner is pinned to ONE mode for its whole life, whatever the
+   * card's own agentMode later says. That pin is what makes the planner
+   * read-only, non-build-capable, and prompted for planning — all three derive
+   * from here — and it has to be immune to `applyServerMode`, which runs AFTER
+   * boot and would otherwise stamp `auto` onto the planner of a plan-less auto
+   * card, handing it the build prompt and `--dangerously-skip-permissions`
+   * inside a session whose whole purpose is not to have them.
+   *
+   * There are TWO planner flavors, and which one this session is was decided at
+   * boot (`_planFlavor`) — never re-read from the mutable `_mode`. A chat card
+   * boots a plan session too (it is a Planner-session flavor, not a builder in
+   * disguise), and it must keep `buildChatPrompt`, its file deliverables, and
+   * the build-capable tool handler. Reading the flavor from `_mode` would put
+   * that choice back under server control and re-open the exact hole the
+   * paragraph above closes, in the other direction: a stamp of `chat` onto a
+   * discovery planner would hand it build capability.
+   */
   get effectiveMode() {
+    if (this._runnerMode === "plan") return this._planFlavor;
     if (this._mode) return this._mode;
     if (this._runnerMode === "pm") {
       return this._isAuto ? "auto" : "discovery";
@@ -2092,6 +2375,7 @@ var ModeController = class {
    * still get the correct mode.
    */
   applyServerMode(agentMode, isAuto) {
+    this.latchPlanFlavor(agentMode);
     if (agentMode) {
       this._mode = agentMode;
       this._isAuto = agentMode === "auto" || !!isAuto;
@@ -2112,6 +2396,7 @@ var ModeController = class {
       this._mode = "review";
       return this._mode;
     }
+    if (this._runnerMode === "plan") return this.effectiveMode;
     if (this._mode === "auto" && this.canBypassPlanning(context)) {
       this.transitionToBuilding(context);
       return this._mode;
@@ -2203,7 +2488,7 @@ function defineTool(name, description, schema, handler, options) {
 
 // src/harness/claude-code/index.ts
 import { query, tool, createSdkMcpServer } from "@anthropic-ai/claude-agent-sdk";
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 var ClaudeCodeHarness = class {
   /** The SDK stream is itself the structured-event source. */
   emitsStructuredEvents = true;
@@ -2236,7 +2521,7 @@ var ClaudeCodeHarness = class {
         }
       );
       if (t.strict) {
-        sdkTool.inputSchema = z8.strictObject(t.schema);
+        sdkTool.inputSchema = z10.strictObject(t.schema);
       }
       return sdkTool;
     });
@@ -3494,7 +3779,7 @@ var PtyOutputCoalescer = class {
 
 // src/harness/pty/tool-server.ts
 import { createServer as createServer2 } from "http";
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 import { writeFile as writeFile3 } from "fs/promises";
 import { join as join3 } from "path";
 import { randomBytes } from "crypto";
@@ -3551,7 +3836,7 @@ var PtyToolServer = class {
     const mcp = new McpServer({ name: this.name, version: "1.0.0" });
     const register = mcp.registerTool.bind(mcp);
     for (const tool2 of this.tools) {
-      const inputSchema = tool2.strict ? z9.strictObject(tool2.schema) : tool2.schema;
+      const inputSchema = tool2.strict ? z11.strictObject(tool2.schema) : tool2.schema;
       register(
         tool2.name,
         {
@@ -6427,13 +6712,13 @@ Respond to them with post_to_chat (your turn output is NOT shown in chat).`
   if (!context.plan?.trim()) {
     parts.push(
       `
-If this conversation turns into a development task: save a plan with update_task_plan first \u2014 that identifies the card and moves it to In Progress \u2014 then implement it and open a PR with mcp__conveyor__create_pull_request, like a normal build.`
+If this conversation turns into a development task: save a plan with update_task first \u2014 that identifies the card and moves it to In Progress \u2014 then implement it and open a PR with mcp__conveyor__create_pull_request, like a normal build.`
     );
     return parts;
   }
   parts.push(
     `
-This card has a saved plan, so it is a development task now. Implement the plan on the git branch "${context.githubBranch}", verify with \`bun run check\` and \`bun run test:affected\`, then open the PR with mcp__conveyor__create_pull_request.`
+This card has a saved plan, so it is a development task now. Implement it on the git branch "${context.githubBranch}", then run the \`/conveyor-build\` skill and follow it \u2014 the same workflow any build on this card would use, including how to verify before opening the PR.`
   );
   if (context.githubPRUrl) {
     parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
@@ -6569,7 +6854,7 @@ function buildPackRunnerSystemPrompt(context, config, setupLog) {
     ``,
     `1. Call list_subtasks to see the current state of all child tasks.`,
     `   The response includes PR info, agent assignment, **dependency info** (dependsOn array + allDependenciesMet flag), and the **packSlots** build-slot picture.`,
-    `   If list_subtasks returns NO children, this is a fresh parent card: break the work down now \u2014 explore the codebase, save a parent-level plan with update_task_plan, then create child tasks with create_subtask, each with a detailed plan (file:line citations, verification steps) and dependsOn set for any child that blocks on another. Then fire the ready children and continue the loop.`,
+    `   If list_subtasks returns NO children, this is a fresh parent card: break the work down now \u2014 explore the codebase, save a parent-level plan with update_task, then create child tasks with create_subtask, each with a detailed plan (file:line citations, verification steps) and dependsOn set for any child that blocks on another. Then fire the ready children and continue the loop.`,
     ``,
     `2. Evaluate children by status and dependency readiness:`,
     `   - "ReviewPR": Review and merge its PR with approve_and_merge_pr. (Highest priority)`,
@@ -6622,6 +6907,73 @@ function buildPackRunnerSystemPrompt(context, config, setupLog) {
   parts.push(...PACK_RUNNER_FOOTER);
   return parts.join("\n");
 }
+function buildSinglePodPackPrompt(context, config, setupLog) {
+  const packBranch = resolveMergedWorkBranch(context);
+  const parts = [
+    `You are an autonomous Pack Runner for the "${context.title}" pack, and you implement the work yourself.`,
+    ``,
+    `Run the \`/conveyor-build\` skill and follow its PACK PATH. It is the source of truth for the loop \u2014 child selection, dependency order, the reviewer-of-record pass, the finale \u2014 and it carries the pod substitution this session runs under. Do not re-derive the workflow from memory.`,
+    ``,
+    // Session-bound facts only. Everything the skill CAN know now lives there;
+    // what stays is what is true of THIS pod and this card.
+    `## This session`,
+    `- You are ALREADY bound to this parent card. There is nothing to claim.`,
+    `- One checkout, one branch: \`${packBranch}\`. Every child's work is commits on it.`,
+    `- Children get NO branches and NO pull requests here. \`create_pull_request\` always opens the PR for the card you are bound to, so calling it mid-pack opens the PARENT's PR early and strands the remaining children. One PR, at the very end, for this parent.`,
+    `- You move each child's status yourself: \`update_task(task_id: <child>, status: ...)\`. No per-child build fires, so a status you do not write is a board that silently lies. A child is "ReviewDev" once its commits are on \`${packBranch}\`.`,
+    `- \`start_child_cloud_build\` and \`stop_child_build\` belong to the fan-out model and are not available to you \u2014 you are the implementer.`,
+    `- Merge \`origin/dev\` into \`${packBranch}\` after each child, never rebase: the branch is shared with WIP refs and rewriting it breaks them.`,
+    `- Nothing will wake you to start the next child. Go idle only when genuinely blocked on something external.`,
+    ``
+  ];
+  if (context.storyPoints && context.storyPoints.length > 0) {
+    parts.push(...formatStoryPoints(context.storyPoints));
+  }
+  if (context.agents && context.agents.length > 0) {
+    parts.push(...formatProjectAgents(context.agents));
+  }
+  if (setupLog.length > 0) {
+    parts.push(``, `## Environment setup log`, "```", ...setupLog, "```");
+  }
+  if (context.agentInstructions) {
+    parts.push(``, `## Agent Instructions`, context.agentInstructions);
+  }
+  if (config.instructions) {
+    parts.push(``, `## Additional Instructions`, config.instructions);
+  }
+  parts.push(...PACK_RUNNER_FOOTER);
+  return parts.join("\n");
+}
+function buildSinglePodPackInstructions(context, scenario) {
+  const parts = [`
+## Instructions`];
+  if (scenario === "fresh") {
+    parts.push(
+      `You are the Pack Runner for this task and its subtasks, and you implement them yourself.`,
+      `Start now: call list_subtasks to see where the pack stands.`,
+      `No children yet? Break the work down first \u2014 save a parent-level plan with update_task, then create_subtask each child with a detailed plan and dependsOn set where one blocks another.`,
+      `Otherwise take the first "Open" child whose dependencies are met, claim it with update_task(task_id, status: "InProgress"), and implement it on this branch.`
+    );
+  } else if (scenario === "idle_relaunch") {
+    parts.push(
+      `You have been relaunched. Re-derive where the pack stands \u2014 call list_subtasks and check the branch, never rely on what you remember.`,
+      `A child left "InProgress" is one YOU were implementing: check the working tree and the log for what already landed before redoing any of it.`,
+      `Otherwise continue the loop: next ready child, or the finale if none remain.`
+    );
+  } else {
+    const lastAgentIdx = findLastAgentMessageIndex2(context.chatHistory);
+    const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
+    parts.push(
+      `You have been relaunched with new messages.`,
+      `
+New messages since your last run:`,
+      ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
+      `
+After addressing the feedback, resume: call list_subtasks and continue with the next ready child.`
+    );
+  }
+  return parts;
+}
 function buildPackRunnerInstructions(context, scenario) {
   const parts = [`
 ## Instructions`];
@@ -6629,7 +6981,7 @@ function buildPackRunnerInstructions(context, scenario) {
     parts.push(
       `You are the Pack Runner for this task and its subtasks.`,
       `Begin your autonomous loop immediately: call list_subtasks to assess the current state.`,
-      `If there are no children yet, create them first \u2014 save a parent-level plan with update_task_plan, then create child tasks with detailed plans and dependsOn set where one blocks on another. Then fire the ready ones.`,
+      `If there are no children yet, create them first \u2014 save a parent-level plan with update_task, then create child tasks with detailed plans and dependsOn set where one blocks on another. Then fire the ready ones.`,
       `If any child is in "ReviewPR" status, review and merge its PR first.`,
       `Then fire the next "Open" child task.`
     );
@@ -6693,39 +7045,6 @@ function baseDiffCommand(baseBranch, flags) {
   const suffix = flags ? ` ${flags}` : "";
   return `git fetch origin ${base} -q && git diff $(git merge-base origin/${base} HEAD)..HEAD${suffix}`;
 }
-function gateFailureModes() {
-  return [
-    `Reading a gate result correctly is what keeps this to ONE pass:`,
-    `- Capture AND propagate the exit code (\`<gate> > <log> 2>&1; ec=$?; echo "EXIT:$ec" >> <log>; (exit $ec)\`) \u2014 piping a gate through \`tail\` masks it, and a bare trailing \`echo "EXIT:$?"\` makes the wrapper exit 0 over a failed gate. That \`EXIT:\` line, plus turbo's final \`Tasks:\` count, is the authority on pass/fail.`,
-    `- A green gate that printed no per-suite summary (no \`Test Files\`/\`Tests\` line) is still green: \`turbo.json\` sets \`outputLogs: "errors-only"\`, so a PASSING run prints nothing per suite. Do NOT re-run a clean-exit gate to "see the counts" \u2014 if you genuinely need them, run one package's script directly (\`bun run --cwd <pkg> test\`).`,
-    `- Exit 143, or \`singleton: stopping running '<label>'\` on stderr, means a second gate you started evicted this one (on a pod the heavy gates share one lock). 143 is never a pass \u2014 but an evicted run never finished, so re-running it alone is still your one pass, not a repeat. Run one gate at a time; \`bun run check\` is not lock-wrapped, so it is safe alongside a test run.`,
-    `- Confirm every package your diff touches actually appears in the run. \`--affected\` can select nothing for a package you changed; when that happens run just that package's suite directly, e.g. \`bun run --cwd apps/api test:unit <changed test files>\` \u2014 not the whole gate again.`,
-    ...gateWaitProtocol()
-  ];
-}
-function gateWaitProtocol() {
-  return [
-    `How to wait for a gate \u2014 one gate, one wait, no polling:`,
-    `- Launch it ONCE with \`run_in_background: true\`, then END YOUR TURN. The completion notification re-invokes you. Do not read the output file, \`tail\`/\`wc\`/\`pgrep\` it, or start a second watcher on a log another run already owns \u2014 a quiet gate is still running.`,
-    `- Never wrap a gate in a foreground \`timeout\`: killing your own run at 590s produces exit 124/143 and ZERO information, and you then have to run it again unbounded. \`sleep N; <cmd>\` is hard-blocked for the same reason.`,
-    `- Never relaunch a command you just killed without changing something. State cwd explicitly in the command (\`cd /workspaces/repo && \u2026\`, \`--root\`, \`git -C\`) rather than trusting the shell's working directory.`,
-    `- The completion notification reports the WRAPPER's exit code. With the propagating idiom above, \`(exit $ec)\` makes that the gate's own code; a wrapper that ends on a bare \`echo\` reports 0 no matter what failed. Whenever the notification and the log disagree, the \`EXIT:\` line in the log is the authority.`,
-    `- Scope heavy gates to what you changed (\`--filter=<pkg>\`). An unscoped \`check:affected\` can pull a large web typecheck into scope for a diff touching no web files and get OOM-killed (exit 137) after minutes, where the scoped run takes seconds.`,
-    `- Merge the base BEFORE the gate pass, never after (see the Pre-PR Protocol). If that merge touched \`package.json\`/\`bun.lock\`, run \`bun install\` before starting the gate \u2014 a changed lockfile makes gates fail for reasons unrelated to your diff.`
-  ];
-}
-function ciTriageChecklist(baseBranch) {
-  const base = baseBranch?.trim() || "dev";
-  return [
-    `Before treating a CI failure as yours, run these four checks first \u2014 most reported reds are not caused by the diff:`,
-    `1. Is the failing run's head SHA still current? A red run against a superseded commit is stale.`,
-    `2. Is the only \`##[error]\` a cancellation ("The operation was canceled", "The runner has received a shutdown signal")? That is a reclaimed/preempted runner, not a code failure \u2014 re-run it.`,
-    `3. Is the failing file even in your diff? \`git diff origin/${base}...HEAD --stat -- <path>\` \u2014 empty output means you did not touch it. Check whether \`origin/${base}\` already fails the same way before investigating further.`,
-    `4. Is \`origin/${base}\` itself green? A semantic merge conflict on the base branch fails every open PR at once.`,
-    `Known environmental failures \u2014 recognize, do not re-diagnose: suites needing a real Elasticsearch fail without \`RC_TEST_ES_URL\` and cannot pass in a pod; exit 137 is a pod OOM, not a code error; \`gh\` returning \`HTTP 401: Bad credentials\` means the pod token aged out (~1h) \u2014 re-exporting it does not help, so use the Conveyor MCP CI-status tools instead of spending calls re-testing \`gh\`.`,
-    `A Dependabot PR showing "no checks reported" is in \`action_required\` \u2014 a maintainer must approve the workflow run. That is not "CI did not run", and you cannot unblock it yourself.`
-  ];
-}
 function formatFileSize(bytes) {
   if (bytes === void 0) return "";
   if (bytes < 1024) return `${bytes}B`;
@@ -6852,110 +7171,375 @@ function formatIncidents(incidents) {
   return parts;
 }
 
-// src/execution/tag-context-resolver.ts
-var TYPE_PRIORITY = { rule: 0, doc: 1, file: 2, folder: 3 };
-var SUMMARY_SCAN_CHARS = 4e3;
-var SUMMARY_MAX_CHARS = 160;
-var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".webp",
-  ".ico",
-  ".svg",
-  ".bmp",
-  ".mp3",
-  ".mp4",
-  ".wav",
-  ".avi",
-  ".mov",
-  ".pdf",
-  ".zip",
-  ".tar",
-  ".gz",
-  ".woff",
-  ".woff2",
-  ".ttf",
-  ".eot",
-  ".otf",
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".wasm"
-]);
-function isBinaryPath(filePath) {
-  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
-  return BINARY_EXTENSIONS.has(ext);
+// src/execution/mode-prompt.ts
+var SP_DESC_MAX_CHARS = 80;
+function truncateDescription(desc, maxChars) {
+  if (desc.length <= maxChars) return desc;
+  return desc.slice(0, maxChars) + "\u2026";
 }
-var fileSummaryCache = /* @__PURE__ */ new Map();
-var folderListingCache = /* @__PURE__ */ new Map();
-var fileReadCount = 0;
-var folderReadCount = 0;
-function deriveSummary(raw) {
-  let body = raw;
-  let frontmatter = "";
-  if (raw.startsWith("---")) {
-    const end = raw.indexOf("\n---", 3);
-    if (end !== -1) {
-      frontmatter = raw.slice(3, end);
-      const afterClose = raw.indexOf("\n", end + 1);
-      body = afterClose === -1 ? "" : raw.slice(afterClose + 1);
-    }
-  }
-  const fmDescription = frontmatter.split("\n").map((l) => l.trim()).find((l) => /^(description|title):/i.test(l));
-  if (fmDescription) {
-    const value = fmDescription.slice(fmDescription.indexOf(":") + 1).trim().replace(/^["']|["']$/g, "");
-    if (value) return truncateSummary(value);
-  }
-  for (const rawLine of body.split("\n")) {
-    const line = rawLine.trim();
-    if (!line) continue;
-    const cleaned = line.replace(/^#+\s*/, "").replace(/^[-*]\s+/, "").trim();
-    if (cleaned) return truncateSummary(cleaned);
+function formatTagWithContextPaths(tag) {
+  const desc = tag.description ? ` \u2014 ${tag.description}` : "";
+  const lines = [`- Name: "${tag.name}"${desc}`];
+  for (const link of tag.contextPaths ?? []) {
+    const label = link.label ? ` (${link.label})` : "";
+    lines.push(`    \u2192 ${link.type}: ${link.path}${label}`);
   }
-  return null;
+  return lines;
 }
-function truncateSummary(text) {
-  const collapsed = text.replace(/\s+/g, " ").trim();
-  return collapsed.length > SUMMARY_MAX_CHARS ? collapsed.slice(0, SUMMARY_MAX_CHARS - 1).trimEnd() + "\u2026" : collapsed;
+function buildEstimateReassessmentLines(context) {
+  const currentSp = context.taskStoryPointValue ?? "unset";
+  const currentRisk = context.taskRiskLevel ?? "unset";
+  return [
+    `Story points and risk are LIVING estimates, not one-time labels. Reassess them at every phase \u2014 planning, building, review \u2014 against your current understanding, and adjust in EITHER direction: work that looks big early is often small once scoped, and vice versa. Lowering an inflated estimate is as valuable as raising an underestimate; a stale value is worse than a changed one.`,
+    `Current values: story points ${currentSp}, risk ${currentRisk}.`,
+    ``,
+    `Risk levels (how much important surface the change touches):`,
+    `- critical: foundational surface \u2014 auth, billing, data integrity, migrations`,
+    `- high: important surface with broad blast radius`,
+    `- medium: moderate, contained surface area`,
+    `- low: small or isolated change`
+  ];
 }
-async function readFileSummary(filePath) {
-  try {
-    if (isBinaryPath(filePath)) return null;
-    const st = await statWorkspacePath(filePath);
-    if (!st.exists) return null;
-    const mtimeMs = st.mtimeMs;
-    const cached = fileSummaryCache.get(filePath);
-    if (cached && cached.mtimeMs === mtimeMs) {
-      return cached.summary;
+function buildPropertyInstructions(context, runnerMode) {
+  const isTask = runnerMode === "task";
+  const parts = [];
+  parts.push(
+    ``,
+    `### Proactive Property Management`,
+    `As you work this task, proactively keep task properties accurate:`,
+    `- Use update_task_properties to set any combination of: title, story points, risk, and tags`,
+    `- You can update all properties at once or just one at a time as needed`,
+    `- Icons are assigned automatically during identification \u2014 do not set icons manually`,
+    ``,
+    ...buildEstimateReassessmentLines(context),
+    ``,
+    `Don't wait for the user to ask \u2014 keep these accurate as the work takes shape.`,
+    `If scope changes materially at any point, update the properties to match.`
+  );
+  if (context.storyPoints && context.storyPoints.length > 0) {
+    parts.push(``, `Available story point tiers:`);
+    for (const sp of context.storyPoints) {
+      const desc = sp.description ? ` \u2014 ${truncateDescription(sp.description, SP_DESC_MAX_CHARS)}` : "";
+      parts.push(`- Value ${sp.value}: "${sp.name}"${desc}`);
     }
-    const raw = await readWorkspaceFile(filePath);
-    fileReadCount++;
-    const summary = deriveSummary(raw.slice(0, SUMMARY_SCAN_CHARS));
-    fileSummaryCache.set(filePath, { mtimeMs, summary });
-    return summary;
-  } catch {
-    return null;
   }
-}
-async function readFolderListing(folderPath) {
-  try {
-    const st = await statWorkspacePath(folderPath);
-    if (!st.exists) return null;
-    const mtimeMs = st.mtimeMs;
-    const cached = folderListingCache.get(folderPath);
-    if (cached && cached.mtimeMs === mtimeMs) {
-      return cached.listing;
+  if (context.projectTags && context.projectTags.length > 0) {
+    const assignedIds = new Set(context.taskTagIds ?? []);
+    const assigned = context.projectTags.filter((t) => assignedIds.has(t.id));
+    const unassigned = context.projectTags.filter((t) => !assignedIds.has(t.id));
+    if (assigned.length > 0) {
+      parts.push(``, `Assigned tags:`);
+      for (const tag of assigned) parts.push(...formatTagWithContextPaths(tag));
     }
-    const entries = await readWorkspaceDir(folderPath);
-    folderReadCount++;
-    const listing = `Files: ${entries.join(", ")}`;
-    folderListingCache.set(folderPath, { mtimeMs, listing });
-    return listing;
-  } catch {
-    return null;
+    if (!isTask && unassigned.length > 0) {
+      parts.push(``, `Available project tags:`);
+      for (const tag of unassigned) parts.push(...formatTagWithContextPaths(tag));
+    }
+    parts.push(
+      ``,
+      `Tags are the project glossary. call get_tag("<name>") for a term's full spec (overview, linked files, hierarchy) whenever a tag is assigned to this card or mentioned (@[tag:id]) in chat/plans. To mention a tag yourself, write @[tag:<name>] with the tag's exact name \u2014 the server rewrites it to the id token when it stores the text, so you never need the id. An unknown name is left as plain text. When your work changes how a tagged system behaves, update that tag's overview via update_tag with a short reason \u2014 your card is stamped into the revision history.`
+    );
+  }
+  return parts;
+}
+function buildPlanRevisionSection() {
+  return [
+    ``,
+    `### The plan can change while you sleep`,
+    `If a turn opens with "The plan changed since this build was dispatched", honor it BEFORE your next Write or Edit:`,
+    `1. Call get_current_plan and read the current plan in full.`,
+    `2. Compare it against the plan you were launched with \u2014 the current plan wins.`,
+    `3. Drop or redo whatever the revision supersedes, and say so with post_to_chat if it invalidates work you already committed.`,
+    `Building on a superseded plan is the most expensive mistake a resumed card can make.`
+  ];
+}
+function buildSkillInvocation(skill) {
+  return [
+    `Run the \`${skill}\` skill and follow it. It is the source of truth for how this work is done \u2014 do not re-derive the workflow from memory.`,
+    `Two things it cannot know, because they are true of this session rather than of the workflow:`,
+    `- You are ALREADY bound to this card. There is nothing to resolve or claim, and no card argument to ask for \u2014 the task context above is it.`,
+    `- Your plan belongs on the card (\`update_task\`), and your PR goes through \`create_pull_request\`. Do not hand-edit card status to fake a transition.`
+  ];
+}
+function buildEnforcedToolContracts() {
+  return [
+    ``,
+    `### Contracts this environment enforces`,
+    `- Full coding access (read, write, edit, bash, git). Destructive operations are BLOCKED at the tool layer: use \`--force-with-lease\`, never \`--force\`; no \`git reset --hard\`, no \`rm -rf /\`.`,
+    `- A tool error or "MCP server unavailable" is almost always a transient socket reconnect: RETRY the same call. Do not stop work, go idle, or treat it as a reason to end your turn.`,
+    `- Repeating an identical call is interrupted every 4th time. That is a loop breaker, not a denial of the work \u2014 change something about the call rather than repeating it.`
+  ];
+}
+function buildHarnessContracts(context) {
+  return [
+    ...buildEnforcedToolContracts(),
+    ...buildPlanRevisionSection(),
+    ...context?.baseBranch ? [
+      ``,
+      `This card's base branch is \`${context.baseBranch}\` \u2014 pass it explicitly when you open the PR.`
+    ] : []
+  ];
+}
+function buildDiscoveryPrompt(context, runnerMode) {
+  const parts = [
+    `
+## Mode: Discovery`,
+    `You are in Discovery mode \u2014 planning and scoping this card WITH the team.`,
+    ...buildSkillInvocation("/conveyor-plan"),
+    ...context?.isParentTask ? [
+      `- This card is a pack parent: the deliverable is child cards with real plans and \`dependsOn\` edges, not an implementation plan for yourself.`
+    ] : [],
+    ``,
+    `### Contracts this environment enforces`,
+    `- You are READ-ONLY. File writes are denied outside \`.claude/plans/\`, and so are the commands that would start the work: git commit/push/merge/rebase/checkout, git apply, gh pr create, package publish. Everything else runs without an approval prompt \u2014 the pod is a sandbox, so investigate freely (build, test, query the dev DB, read logs).`,
+    `- A plan file on disk is NOT the plan. Only \`update_task\` saves it to the card.`,
+    `- **ExitPlanMode is the LAST step and it validates.** It fails until the card has a plan, story points, risk, and a title \u2014 the plan comes from \`update_task\`, and story points, risk and title from \`update_task_properties\`. Calling it early wastes a turn on a denial.`,
+    `- ExitPlanMode does NOT start building. It parks this session for human review; the team decides when to build.`,
+    ...runnerMode === "plan" ? [
+      `- You are the Planner half of this card's lifecycle. When the team presses Build, a separate **Builder** session starts on THIS pod and takes over \u2014 you never become it. So the plan has to stand on its own: the Builder inherits this repo checkout, but none of your reasoning.`
+    ] : [],
+    `- A tool error or "MCP server unavailable" is almost always a transient socket reconnect: RETRY the same call rather than ending your turn.`
+  ];
+  if (context) parts.push(...buildPropertyInstructions(context, runnerMode));
+  return parts.join("\n");
+}
+function buildAutoPrompt(context, runnerMode) {
+  const parts = [
+    `
+## Mode: Auto`,
+    `You are in Auto mode \u2014 plan this card, then build it, without stopping for approval.`,
+    `Run \`/conveyor-plan\` FIRST to produce the plan and save it to the card, then run \`/conveyor-build\` to implement it. Both are sources of truth; do not re-derive them.`,
+    ...buildSkillInvocation("/conveyor-build"),
+    ``,
+    `### What "auto" changes`,
+    `- There is no plan-approval step and no read-only phase. The plan is a RECORD for the team, not a gate \u2014 save it, then immediately write the code. A card whose only output is a plan (or a plan-only PR) has not been built.`,
+    `- Decide independently. Escalate only when genuinely blocked: ambiguous requirements, missing access, conflicting instructions. Everything else is yours to call.`,
+    `- Skip \`/conveyor-plan\` only if the card already carries a plan you are not materially diverging from.`,
+    ...buildHarnessContracts(context)
+  ];
+  if (context) parts.push(...buildPropertyInstructions(context, runnerMode));
+  return parts.join("\n");
+}
+function buildBuildingPrompt(context) {
+  const parts = [
+    `
+## Mode: Building`,
+    `You are in Building mode \u2014 executing this card's plan.`,
+    ...buildSkillInvocation("/conveyor-build"),
+    ...context?.isParentTask ? [`- This card is a pack parent. \`/conveyor-build\` routes to its pack path; follow that.`] : [],
+    ...buildHarnessContracts(context)
+  ];
+  if (context) parts.push(...buildPropertyInstructions(context));
+  return parts.join("\n");
+}
+function buildModePrompt(agentMode, context, runnerMode) {
+  switch (agentMode) {
+    case "discovery":
+      return buildDiscoveryPrompt(context, runnerMode);
+    case "building":
+      return buildBuildingPrompt(context);
+    case "review":
+      return buildReviewPrompt(context);
+    case "auto":
+      return buildAutoPrompt(context, runnerMode);
+    case "chat":
+      return buildChatPrompt(context);
+    default:
+      return null;
+  }
+}
+function buildChatPrompt(context) {
+  const base = context?.baseBranch?.trim() || "dev";
+  return [
+    `
+## Mode: Chat`,
+    `You are in Chat mode \u2014 a conversational assistant working directly with the user on this card.`,
+    `- Respond conversationally to the user in chat. Ask clarifying questions when useful; this is a back-and-forth, not an autonomous build.`,
+    `- You have full read/write access to the workspace and can run non-destructive shell commands, so you CAN create files (notes, scripts, docs, data, diagrams, etc.) when they help the user.`,
+    `- This card starts Unidentified. That is correct \u2014 it stays a conversation until the work becomes a development task (see below).`,
+    ``,
+    `### Deliverables \u2014 attach files to the card`,
+    `- When you create a file the user should keep, attach it to the card with the \`upload_attachment\` tool so it shows up on the card. Mention in chat what you attached.`,
+    `- \`upload_attachment\` accepts any file type (markdown, PDF, HTML, text, data, images) up to 25MB \u2014 this is how docs are delivered. Do NOT publish deliverables as a Claude artifact or any other off-platform link; the card is the system of record.`,
+    `- For conversational work, attachments are the deliverable. Do NOT open a PR to hand over a document or an answer.`,
+    ``,
+    `### Turning into a development task`,
+    `- If the conversation becomes a request to change the code, escalate the card first: save a plan with \`update_task\`. That first plan identifies the card and moves it to In Progress.`,
+    `- The plan is also the gate on your PR path: \`create_pull_request\`, \`git push\` and \`gh pr\` are DENIED until a plan is saved, and allowed afterwards. Do not try to work around a denial \u2014 save the plan.`,
+    `- Once the plan is saved, it IS a normal build: run the \`/conveyor-build\` skill and follow it, including how to sync \`${base}\` and verify before opening the PR. Do not re-derive that workflow here.`,
+    `- Keep talking to the user while you build \u2014 this is still their card.`,
+    ``,
+    `### Finishing the conversation`,
+    `- When the user indicates they are done (or explicitly asks to wrap up / close the card), call \`force_update_task_status\` with status \`"Complete"\`. It works from either status, so a card still sitting Unidentified can be completed the same way as one that reached In Progress.`,
+    `- If you opened a PR, do NOT complete the card \u2014 the PR review flow takes it from there.`,
+    `- If the user is still engaged, keep helping \u2014 only complete the card once the interaction has concluded.`,
+    `- Do not complete the card while you still owe the user a response or an attachment.`
+  ].join("\n");
+}
+function buildReviewTagSection(context) {
+  const assignedIds = new Set(context?.taskTagIds ?? []);
+  const assigned = (context?.projectTags ?? []).filter((t) => assignedIds.has(t.id));
+  if (assigned.length === 0) return [];
+  const parts = [
+    `### Card Tags & Domain Context`,
+    `This card carries these project glossary tags:`
+  ];
+  for (const tag of assigned) parts.push(...formatTagWithContextPaths(tag));
+  parts.push(
+    ``,
+    `A tag's rules and overview define the conventions the code under review must follow. Use them when you judge Pattern Consistency:`,
+    `- Read the tag entries that match the files in this diff. The "Reference Guides" section of the task brief lists the same tags with a one-line summary of each linked doc.`,
+    `- Call get_tag("<name>") for a term's full spec (overview, linked files, hierarchy) when the linked docs are not enough.`,
+    `- A change that contradicts a tagged system's documented conventions is a review finding, even when it reads fine on its own.`,
+    `- Skip the tags this diff does not touch \u2014 do not read them all up front.`,
+    `- If the diff changes how a tagged system behaves and the tag's overview is now wrong, say so in your review.`,
+    ``
+  );
+  return parts;
+}
+function buildReviewPrompt(context) {
+  if (context?.isParentTask) return buildParentReviewPrompt();
+  return [
+    `
+## Mode: Review`,
+    ...buildSkillInvocation("/conveyor-review"),
+    ``,
+    // Everything below is harness-bound: the skill cannot know this session's
+    // resolved branch, and the verdict tool names differ per surface (the skill
+    // documents both pairs; this names the one that exists here).
+    `### This session`,
+    `- The diff under review: \`${baseDiffCommand(context?.baseBranch)}\``,
+    `- Your verdict tools on this pod are \`approve_code_review\` and \`request_code_changes\`. The local conveyor-mcp pair does not exist here.`,
+    ...buildEnforcedToolContracts(),
+    ...buildReviewTagSection(context)
+  ].join("\n");
+}
+function buildParentReviewPrompt() {
+  return [
+    `
+## Mode: Review`,
+    `### Parent Task Review`,
+    `You are reviewing and coordinating child tasks.`,
+    `- Use \`list_subtasks\` to see current child task state and progress.`,
+    `- For children in ReviewPR status: review their code quality and merge with \`approve_and_merge_pr\`.`,
+    `- For children with failing CI: check with \`get_execution_logs(childTaskId)\` and escalate if stuck.`,
+    `- Fire next child builds with \`start_child_cloud_build\` when ready.`,
+    `- Create follow-up tasks for issues discovered during review.`,
+    ``,
+    `### Coordination Workflow`,
+    `1. Check child task statuses with \`list_subtasks\``,
+    `2. Review completed children \u2014 check PRs, run tests if needed`,
+    `3. Approve and merge passing PRs`,
+    `4. Fire builds for children that are ready`,
+    `5. Create follow-up tasks for anything out of scope`,
+    `6. As children complete, correct their story points with update_subtask (storyPointValue) when the actual work diverged from the estimate \u2014 either direction`
+  ].join("\n");
+}
+
+// src/execution/tag-context-resolver.ts
+var TYPE_PRIORITY = { rule: 0, doc: 1, file: 2, folder: 3 };
+var SUMMARY_SCAN_CHARS = 4e3;
+var SUMMARY_MAX_CHARS = 160;
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".webp",
+  ".ico",
+  ".svg",
+  ".bmp",
+  ".mp3",
+  ".mp4",
+  ".wav",
+  ".avi",
+  ".mov",
+  ".pdf",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".wasm"
+]);
+function isBinaryPath(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+var fileSummaryCache = /* @__PURE__ */ new Map();
+var folderListingCache = /* @__PURE__ */ new Map();
+var fileReadCount = 0;
+var folderReadCount = 0;
+function deriveSummary(raw) {
+  let body = raw;
+  let frontmatter = "";
+  if (raw.startsWith("---")) {
+    const end = raw.indexOf("\n---", 3);
+    if (end !== -1) {
+      frontmatter = raw.slice(3, end);
+      const afterClose = raw.indexOf("\n", end + 1);
+      body = afterClose === -1 ? "" : raw.slice(afterClose + 1);
+    }
+  }
+  const fmDescription = frontmatter.split("\n").map((l) => l.trim()).find((l) => /^(description|title):/i.test(l));
+  if (fmDescription) {
+    const value = fmDescription.slice(fmDescription.indexOf(":") + 1).trim().replace(/^["']|["']$/g, "");
+    if (value) return truncateSummary(value);
+  }
+  for (const rawLine of body.split("\n")) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const cleaned = line.replace(/^#+\s*/, "").replace(/^[-*]\s+/, "").trim();
+    if (cleaned) return truncateSummary(cleaned);
+  }
+  return null;
+}
+function truncateSummary(text) {
+  const collapsed = text.replace(/\s+/g, " ").trim();
+  return collapsed.length > SUMMARY_MAX_CHARS ? collapsed.slice(0, SUMMARY_MAX_CHARS - 1).trimEnd() + "\u2026" : collapsed;
+}
+async function readFileSummary(filePath) {
+  try {
+    if (isBinaryPath(filePath)) return null;
+    const st = await statWorkspacePath(filePath);
+    if (!st.exists) return null;
+    const mtimeMs = st.mtimeMs;
+    const cached = fileSummaryCache.get(filePath);
+    if (cached && cached.mtimeMs === mtimeMs) {
+      return cached.summary;
+    }
+    const raw = await readWorkspaceFile(filePath);
+    fileReadCount++;
+    const summary = deriveSummary(raw.slice(0, SUMMARY_SCAN_CHARS));
+    fileSummaryCache.set(filePath, { mtimeMs, summary });
+    return summary;
+  } catch {
+    return null;
+  }
+}
+async function readFolderListing(folderPath) {
+  try {
+    const st = await statWorkspacePath(folderPath);
+    if (!st.exists) return null;
+    const mtimeMs = st.mtimeMs;
+    const cached = folderListingCache.get(folderPath);
+    if (cached && cached.mtimeMs === mtimeMs) {
+      return cached.listing;
+    }
+    const entries = await readWorkspaceDir(folderPath);
+    folderReadCount++;
+    const listing = `Files: ${entries.join(", ")}`;
+    folderListingCache.set(folderPath, { mtimeMs, listing });
+    return listing;
+  } catch {
+    return null;
   }
 }
 async function resolveEntry(entry) {
@@ -7182,7 +7766,7 @@ function buildPmAutoPlanningRelaunchParts() {
   return [
     `
 You are in auto mode. Continue building autonomously.`,
-    `No plan is saved on this card yet \u2014 save a concise plan with update_task_plan before writing further code; never pause or wait for approval.`,
+    `No plan is saved on this card yet \u2014 save a concise plan with update_task before writing further code; never pause or wait for approval.`,
     `Do NOT wait for team input \u2014 proceed autonomously.`
   ];
 }
@@ -7210,491 +7794,6 @@ function buildPmRelaunchParts(context, lastAgentIdx, isAuto, agentMode) {
 // src/execution/system-prompt.ts
 import { readFileSync } from "fs";
 import { join as join11 } from "path";
-
-// src/execution/mode-prompt.ts
-var SP_DESC_MAX_CHARS = 80;
-function truncateDescription(desc, maxChars) {
-  if (desc.length <= maxChars) return desc;
-  return desc.slice(0, maxChars) + "\u2026";
-}
-function formatTagWithContextPaths(tag) {
-  const desc = tag.description ? ` \u2014 ${tag.description}` : "";
-  const lines = [`- Name: "${tag.name}"${desc}`];
-  for (const link of tag.contextPaths ?? []) {
-    const label = link.label ? ` (${link.label})` : "";
-    lines.push(`    \u2192 ${link.type}: ${link.path}${label}`);
-  }
-  return lines;
-}
-function buildEstimateReassessmentLines(context) {
-  const currentSp = context.taskStoryPointValue ?? "unset";
-  const currentRisk = context.taskRiskLevel ?? "unset";
-  return [
-    `Story points and risk are LIVING estimates, not one-time labels. Reassess them at every phase \u2014 planning, building, review \u2014 against your current understanding, and adjust in EITHER direction: work that looks big early is often small once scoped, and vice versa. Lowering an inflated estimate is as valuable as raising an underestimate; a stale value is worse than a changed one.`,
-    `Current values: story points ${currentSp}, risk ${currentRisk}.`,
-    ``,
-    `Risk levels (how much important surface the change touches):`,
-    `- critical: foundational surface \u2014 auth, billing, data integrity, migrations`,
-    `- high: important surface with broad blast radius`,
-    `- medium: moderate, contained surface area`,
-    `- low: small or isolated change`
-  ];
-}
-function buildPropertyInstructions(context, runnerMode) {
-  const isTask = runnerMode === "task";
-  const parts = [];
-  parts.push(
-    ``,
-    `### Proactive Property Management`,
-    `As you work this task, proactively keep task properties accurate:`,
-    `- Use update_task_properties to set any combination of: title, story points, risk, and tags`,
-    `- You can update all properties at once or just one at a time as needed`,
-    `- Icons are assigned automatically during identification \u2014 do not set icons manually`,
-    ``,
-    ...buildEstimateReassessmentLines(context),
-    ``,
-    `Don't wait for the user to ask \u2014 keep these accurate as the work takes shape.`,
-    `If scope changes materially at any point, update the properties to match.`
-  );
-  if (context.storyPoints && context.storyPoints.length > 0) {
-    parts.push(``, `Available story point tiers:`);
-    for (const sp of context.storyPoints) {
-      const desc = sp.description ? ` \u2014 ${truncateDescription(sp.description, SP_DESC_MAX_CHARS)}` : "";
-      parts.push(`- Value ${sp.value}: "${sp.name}"${desc}`);
-    }
-  }
-  if (context.projectTags && context.projectTags.length > 0) {
-    const assignedIds = new Set(context.taskTagIds ?? []);
-    const assigned = context.projectTags.filter((t) => assignedIds.has(t.id));
-    const unassigned = context.projectTags.filter((t) => !assignedIds.has(t.id));
-    if (assigned.length > 0) {
-      parts.push(``, `Assigned tags:`);
-      for (const tag of assigned) parts.push(...formatTagWithContextPaths(tag));
-    }
-    if (!isTask && unassigned.length > 0) {
-      parts.push(``, `Available project tags:`);
-      for (const tag of unassigned) parts.push(...formatTagWithContextPaths(tag));
-    }
-    parts.push(
-      ``,
-      `Tags are the project glossary. call get_tag("<name>") for a term's full spec (overview, linked files, hierarchy) whenever a tag is assigned to this card or mentioned (@[tag:id]) in chat/plans. To mention a tag yourself, write @[tag:<name>] with the tag's exact name \u2014 the server rewrites it to the id token when it stores the text, so you never need the id. An unknown name is left as plain text. When your work changes how a tagged system behaves, update that tag's overview via update_tag with a short reason \u2014 your card is stamped into the revision history.`
-    );
-  }
-  return parts;
-}
-function buildPlanDocumentationSection(context) {
-  const hasPlan = !!context?.plan?.trim();
-  return [
-    ``,
-    `### Plan first, then BUILD \u2014 the plan is a step, NOT the deliverable`,
-    `- The card is already In Progress and advances automatically (In Progress \u2192 Review PR when you open the PR). There is no plan-approval step.`,
-    ...hasPlan ? [
-      `- A plan is already saved on the card. Keep it current with update_task_plan if your approach diverges materially \u2014 then IMPLEMENT it in code. The saved plan is not the deliverable; the working implementation is.`
-    ] : [
-      `- No plan is saved yet: BEFORE writing any code, investigate briefly (search first, read only critical files) and save a concise implementation plan with update_task_plan (file:line citations). Saving the plan is a planning step, not the goal \u2014 immediately move on to WRITING THE CODE that implements it; never pause for approval.`
-    ],
-    `- Your goal is to BUILD the change, not to produce a plan. After the plan is posted, actually implement it: edit source files, make the change work, then verify. Do NOT stop, go idle, or open a PR the moment the plan exists.`,
-    `- Your pull request MUST contain the actual code implementation. Never open a plan-only or empty-diff PR \u2014 a PR that just records the plan is never the goal of auto mode unless the task explicitly asks ONLY for a plan. (If the task genuinely needs no code changes, don't open a PR at all \u2014 finish per the section below.)`,
-    `- Identification auto-fills title, story points, and icon with quick AI guesses. After exploring, refine the title, story points, and risk with update_task_properties whenever they no longer match what the work actually is \u2014 adjust in either direction. Icons are automatic \u2014 never set them.`
-  ];
-}
-function buildPlanRevisionSection() {
-  return [
-    ``,
-    `### The plan can change while you sleep`,
-    `If a turn opens with "The plan changed since this build was dispatched", honor it BEFORE your next Write or Edit:`,
-    `1. Call get_current_plan and read the current plan in full.`,
-    `2. Compare it against the plan you were launched with \u2014 the current plan wins.`,
-    `3. Drop or redo whatever the revision supersedes, and say so with post_to_chat if it invalidates work you already committed.`,
-    `Building on a superseded plan is the most expensive mistake a resumed card can make.`
-  ];
-}
-function buildNoPrWhenNoCodeSection(baseBranch) {
-  const diffCommand = baseDiffCommand(baseBranch);
-  return [
-    ``,
-    `### A PR is NOT required \u2014 only open one for actual code changes`,
-    `\`create_pull_request\` is for tasks that change code in the repo. Many tasks don't: support requests, config/credential help, answering a question, investigations, or research whose deliverable is an answer or a file rather than a diff.`,
-    `- If you finish the work with NO code changes (an empty \`${diffCommand}\`), do NOT open a PR. An empty or throwaway PR just to "complete" the workflow is wrong \u2014 a human then has to close it.`,
-    `- Deliver the result where it belongs: post the answer/config/findings with \`post_to_chat\`, and attach any files the user should keep with \`upload_attachment\` (any file type, up to 25MB). Never publish a deliverable as a Claude artifact or off-platform link \u2014 it belongs on the card.`,
-    `- Then complete the card directly with \`force_update_task_status("Complete")\` \u2014 there is no PR or review step for a no-code task.`,
-    `- When in doubt, check \`${diffCommand}\`: a real diff means open a PR; no diff means finish in chat and mark Complete.`
-  ];
-}
-function buildAttachArtifactsSection() {
-  return [
-    ``,
-    `### Screenshots & recordings \u2014 attach to the card AND embed in the PR description`,
-    `If your diff changes anything a user sees rendered (e.g. \`apps/web/**\`, \`apps/sandbox/**\`, \`*.tsx\`/\`*.jsx\`, or styling), capture visual proof BEFORE you open the PR \u2014 a **screenshot** for a static change, or a short **screen recording** (\`.mp4\`/\`.webm\`/\`.gif\`, \u226425MB) for an interaction, animation, or multi-step flow. For a changed screen, capture before AND after. This is part of finishing UI work \u2014 do it unprompted, not only when a human asks. (Non-visual diffs and other documenting files \u2014 diagrams, generated reports \u2014 follow the same pattern when useful.)`,
-    `Capture against the running preview: every pod ships headless Playwright chromium baked at \`~/.cache/ms-playwright/\`. Point it at the dev-server preview URL \u2014 \`page.screenshot({ path })\` for an image, a browser context \`recordVideo\` for a \`.webm\`.`,
-    `Then attach it with \`upload_attachment\` (pass a workspace path): it reads the codespace-local file and hosts it on the card. It accepts images AND video (\`.mp4\`/\`.webm\`/\`.gif\`), up to 25MB.`,
-    `- There is NO "separate pod / no filesystem access" limitation, and it is NOT images-only. Never tell the team a screenshot or recording "could not be hosted" \u2014 attach it.`,
-    `- Pass \`tags\` when the capture is a good example of a glossary tag in some state \u2014 a screenshot of the tags page tagged \`tag\`, a board capture tagged \`task\`. Each tag's page lists its recent tagged attachments, so the label turns your screenshot into a living example of that entity and makes visual drift easy to spot. An unmatched name is reported back and never fails the upload.`,
-    ``,
-    `**The PR description must show the visual proof, not just point at it.** \`upload_attachment\` returns a \`downloadUrl\` for every file it stores, plus a ready-to-paste markdown line. Copy that line into the \`body\` you pass to \`create_pull_request\`:`,
-    `- Images embed inline: \`![before \u2014 task board](<downloadUrl>)\`. Write a real caption in the alt text \u2014 "before"/"after", or what the shot demonstrates.`,
-    `- Video and other non-image files do not render inline on GitHub. Link them instead: \`[interaction recording](<downloadUrl>)\`.`,
-    `- Put them under a \`## Screenshots\` heading in the PR body, with before/after side by side (or one after the other) when you changed an existing screen.`,
-    `- The URL is a signed capability our API serves; GitHub fetches and caches the image through its own proxy when the description renders, so it keeps working after the capability expires. Do NOT paste codespace-local file paths (\`/workspaces/repo/shot.png\`) \u2014 reviewers cannot open those.`,
-    `- Keep attaching to the card as well. The card is the durable home for the capture and the only place \`tags\` apply; the PR description is what the reviewer actually reads. Do both \u2014 neither one replaces the other.`,
-    `- If \`upload_attachment\` returns no \`downloadUrl\`, still attach to the card, and say plainly in the PR body that the embed URL was unavailable. Never silently ship a UI PR with no visual proof.`
-  ];
-}
-function buildPrGuideSection() {
-  return [
-    ``,
-    `### PR Guide \u2014 publish when you open the PR, refresh it on every push`,
-    `Once your PR is open, publish a structured guide that walks a reviewer through the change with \`publish_review_guide\`. This is part of opening a PR: call it right after \`create_pull_request\` succeeds, and again whenever you push more commits to the branch.`,
-    `- The head SHA is resolved from the local repo for you, so never hand-expand an abbreviated hash from commit output or plan text. Publish AFTER the push that created/updated the PR has landed on the branch.`,
-    `- \`sections\` is a real top-level array ARGUMENT, not prose inside \`overview\`. Keep \`overview\` under 3000 characters \u2014 a short intro only \u2014 and put the walkthrough in \`sections\`, ordered with core behavior first and tests, migrations, generated files, and configuration later unless they are central.`,
-    `- Explain each section's purpose and effect in plain language, and reference ONLY files this PR's diff actually changed \u2014 never context files you merely read or discussed.`,
-    `- Anchors are optional and strict: the safest \`files\` entry is \`{"path": "..."}\` alone. If you anchor, \`hunkHeader\` must be the byte-exact full line from \`git diff <base>..HEAD -- <file> | grep '^@@'\` INCLUDING the trailing context text after the second \`@@\`, and \`startLine\`/\`endLine\` must overlap one real hunk's new-file range. When in doubt, omit the anchor fields.`,
-    `- After any later push, call \`publish_review_guide\` again for the NEW head SHA \u2014 the card shows a "stale" banner until you republish for the current head.`,
-    `- Best-effort: if publication fails after one corrected retry, continue. It never blocks opening or updating the PR.`
-  ];
-}
-function buildPrePrProtocolSection(context) {
-  const base = context?.baseBranch?.trim() || "dev";
-  return [
-    `### Pre-PR Protocol \u2014 sync the base first, then ONE verification pass`,
-    `CI runs the FULL suite (lint, typecheck, all test shards) on every PR \u2014 do not duplicate it locally. Local gates run ONCE, in this order:`,
-    `1. Finish the implementation and commit it.`,
-    `2. **Sync the base FIRST**: \`git fetch origin ${base} && git merge origin/${base} --no-edit\`. Run \`bun install\` afterwards only if the merge touched \`package.json\`/\`bun.lock\`. Merging before the gates is what makes one pass sufficient \u2014 merging after them is what forces a second run.`,
-    `3. **One verification pass**: \`bun run check\` (lint + typecheck, fast, not lock-wrapped) then \`bun run test:affected\` (runs only the tests your diff can affect \u2014 apps/api diffs are expected to run unit tests only since CI covers the int shards; \`packages/shared\`/\`packages/db\`/root-config diffs escalate to the full suite automatically, which is still one pass, not a repeat). Selection is a heuristic \u2014 confirm it actually ran the packages you changed.`,
-    `4. **Open the PR immediately** with \`mcp__conveyor__create_pull_request\`. Do NOT re-merge the base and do NOT re-run a gate that already passed. If \`${base}\` moved while the gates were running, open the PR anyway \u2014 CI validates against the merged base.`,
-    `Docs/markdown/\`.claude\`-only diffs skip steps 2-3 entirely \u2014 open the PR and let CI validate.`,
-    ``,
-    `**When a gate fails: fix, re-run only the failing tests, confirm once.**`,
-    `- Iterate on the failures directly with the package-local script \u2014 \`bun run --cwd <pkg> test:unit <files>\` (or \`test <files>\`). It skips turbo's dep-build and the singleton lock, so it costs seconds instead of minutes. Do NOT re-run the whole gate on each iteration.`,
-    `- Pick that file set deliberately: \`rg <ComponentName>\` across \`__tests__\` to find every suite that transitively mounts what you changed, so the targeted loop is not blind to indirect mounters.`,
-    `- Once the targeted files pass, run the full scoped gate ONE more time as final confirmation, then open the PR. That single confirmation run \u2014 not a full gate per iteration \u2014 is what catches a suite your targeted set missed.`,
-    `- Do NOT open a PR with a known failing gate.`,
-    ...gateFailureModes(),
-    ``,
-    `Also before you open the PR (neither one needs a gate re-run):`,
-    `- Reassess story points and risk against the ACTUAL diff \u2014 the estimate was made at planning time; now you know what the work really was. Correct them with \`update_task_properties\` in either direction.`,
-    `- **UI/UX diffs:** if you changed anything rendered (\`apps/web\`, \`apps/sandbox\`, \`*.tsx\`/\`*.jsx\`, styling), capture a screenshot (static change) or short screen recording (interaction/animation), attach it to the card with \`upload_attachment\`, and **embed the returned \`downloadUrl\` in the PR description** \u2014 both, not either \u2014 see "Screenshots & recordings" below. Skip only when the diff has no visual effect.`,
-    `- For refactors: run \`${baseDiffCommand(context?.baseBranch)}\` and confirm the public API surface (exports, function signatures) has no unintended breaking changes.`,
-    ``,
-    `### Triaging a CI failure`,
-    ...ciTriageChecklist(context?.baseBranch)
-  ];
-}
-function buildExplorationMethodology() {
-  return [
-    ``,
-    `### Exploration Methodology`,
-    `Investigate efficiently \u2014 do not read files aimlessly:`,
-    `- Search first, read second: use grep/glob to locate relevant code, then read only the files that matter`,
-    `- Never re-read a file already in your context \u2014 you have a large context window, scroll up instead`,
-    `- Start with 3-5 critical files, form a hypothesis about the approach, then validate with targeted reads`,
-    `- Stop exploring when you can cite specific \`file.ts:line\` locations and function names for every step in your plan \u2014 that's enough`
-  ];
-}
-function buildPlanCitationFormat() {
-  return [
-    ``,
-    `### Plan Citation Format`,
-    `Plans must ground each change in the code. For every step that touches code:`,
-    `- Cite the exact location as \`path/from/repo/root.ts:lineNumber\` (e.g. \`packages/conveyor-agent/src/execution/mode-prompt.ts:129\`).`,
-    `- Name the specific function, class, constant, or JSX element being touched.`,
-    `- When behavior hinges on a short piece of code, quote 1\u20133 lines inline instead of paraphrasing.`,
-    `- Ranges are fine for larger edits (\`foo.ts:120-145\`). Do not cite whole files without a line.`,
-    `- If a file doesn't exist yet, write \`NEW: path/to/new-file.ts\` and describe the surrounding module it fits into.`
-  ];
-}
-function buildDiscoveryPrompt(context, runnerMode) {
-  const parts = [
-    `
-## Mode: Discovery`,
-    `You are in Discovery mode \u2014 helping plan and scope this task.`,
-    `- You have read-only codebase access (can read files, run git commands, search code)`,
-    `- Shell commands run without asking for approval \u2014 the pod is a sandbox, so investigate freely (build, test, query the dev DB, read logs). Only commands that would start the work are denied: git commit/push/merge/rebase/checkout, git apply, gh pr create, and package publish`,
-    `- You can write plan files in .claude/plans/ only \u2014 no other file writes. Plan files on disk are NOT synced to the task; save the plan via update_task_plan`,
-    `- Do NOT attempt to edit, write, or modify source code files \u2014 these operations will be denied`,
-    `- If you identify code changes needed, describe them in the plan instead of implementing them`,
-    `- You can create and manage subtasks`,
-    `- Goal: collaborate with the user to create a clear plan`,
-    `- Proactively fill task properties (SP, tags) as the plan takes shape`,
-    ``,
-    `### Planning Checklist (complete ALL before calling ExitPlanMode)`,
-    `Your PRIMARY goal is to create a thorough plan. Complete these steps in order:`,
-    `1. Read the task description and chat history \u2014 respond to what's been discussed`,
-    `2. Investigate the codebase using the methodology below \u2014 search first, read targeted files`,
-    `3. Save a detailed plan via \`update_task_plan\``,
-    `4. Set story points, risk, tags, and title via \`update_task_properties\` (icon is set automatically)`,
-    `5. Discuss the plan with the team if they're engaged, incorporate feedback`,
-    `6. THEN call ExitPlanMode \u2014 it is the LAST step, not the first`,
-    ...buildExplorationMethodology(),
-    ...buildPlanCitationFormat(),
-    ``,
-    `### Self-Identification Tools`,
-    `Use these MCP tools to set your own task properties:`,
-    `- \`update_task_plan\` \u2014 save your plan and description`,
-    `- \`update_task_properties\` \u2014 set title, story points, risk, and tags (any combination)`,
-    `Note: Icons are assigned automatically during identification after planning is complete.`,
-    ``,
-    `### Tags & Context`,
-    `- Early in discovery, identify relevant project tags that match this task's domain`,
-    `- Add matching tags using \`update_task_properties\` \u2014 this links relevant documentation and rules that help you plan more effectively`,
-    `- Tags accelerate discovery by surfacing domain-specific context automatically`,
-    ``,
-    ...context?.isParentTask ? [
-      `### Parent Task Coordination`,
-      `You are a parent task with child tasks. Focus on breaking work into child tasks with detailed plans, not planning implementation for yourself.`,
-      `- Use \`list_subtasks\` to review existing children. Create or update child tasks using \`create_subtask\` / \`update_subtask\`.`,
-      `- Each child task should be a self-contained unit of work with a clear plan.`,
-      `- Set ordering as explicit **card metadata**, not prose: pass \`dependsOn\` (sibling ids/slugs) on \`create_subtask\` for any child that blocks on another. Leave independent children with no dependencies so the pack runner fans them out in parallel. Do NOT encode "do X after Y" only in the plan text \u2014 the runner schedules off dependsOn, not narrative.`
-    ] : [
-      `### Self-Update vs Subtasks`,
-      `- If the work fits in a single task (1-3 SP), update YOUR OWN plan and properties \u2014 do not create subtasks`,
-      `- Only create subtasks when the work genuinely requires multiple independent pieces (e.g., Pack-tier work, 8+ SP)`
-    ],
-    ``,
-    `### Subtask Plan Requirements`,
-    `When creating subtasks, each MUST include a detailed \`plan\` field:`,
-    `- Plans should be multi-step implementation guides, not vague descriptions`,
-    `- Include concrete \`file.ts:line\` citations, function/symbol names, and short code snippets where relevant`,
-    `- Reference existing implementations when relevant (e.g., "follow the pattern in src/services/foo.ts")`,
-    `- Include testing requirements and acceptance criteria`,
-    `- Set \`storyPointValue\` based on estimated complexity`,
-    `- Express cross-child ordering as \`dependsOn\` (sibling ids/slugs) on \`create_subtask\` \u2014 explicit dependency metadata, not "after task 2" phrasing in the plan. Independent children get no dependencies so they run in parallel.`,
-    ``,
-    `### Plan Verification Requirements`,
-    `Every plan MUST include a **Testing / Verification** section so the build agent has a clear definition of "done". Enumerate:`,
-    `- The scoped verification for the change: \`bun run check\` (lint + typecheck) plus \`bun run test:affected\` \u2014 name the specific package suites the diff will touch. Docs-only plans should state that no local gates are needed (CI validates on the PR).`,
-    `- Any task-specific end-to-end checks (manual UI walk-through, API smoke test, migration dry-run, etc.)`,
-    `You are NOT expected to run these gates yourself \u2014 discovery is read-only. Just describe them in the plan.`,
-    ``,
-    `### Completing Planning`,
-    `Once ALL checklist items above are done, call the **ExitPlanMode** tool.`,
-    `- Required before ExitPlanMode will succeed: **plan** (via update_task_plan), **story points**, **risk**, and **title** (via update_task_properties)`,
-    `- ExitPlanMode validates these properties and marks planning as complete`,
-    `- It does NOT start building \u2014 the team controls when to switch to Build mode`,
-    `- Do NOT call ExitPlanMode until you have thoroughly explored the codebase and saved a detailed plan`
-  ];
-  if (context) parts.push(...buildPropertyInstructions(context, runnerMode));
-  return parts.join("\n");
-}
-function buildAutoPrompt(context, runnerMode) {
-  const parts = [
-    `
-## Mode: Auto`,
-    `You are in Auto mode \u2014 operating autonomously through building \u2192 PR.`,
-    `- You have full coding access (read, write, edit, bash, git) from the start \u2014 there is no read-only planning phase`,
-    `- Safety rules: no destructive operations, use --force-with-lease instead of --force`,
-    ...buildPlanDocumentationSection(context),
-    ``,
-    `### Subtask Plan Requirements`,
-    `When creating subtasks, each MUST include a detailed \`plan\` field:`,
-    `- Plans should be multi-step implementation guides, not vague descriptions`,
-    `- Include concrete \`file.ts:line\` citations, function/symbol names, and short code snippets where relevant`,
-    `- Reference existing implementations when relevant`,
-    `- Include testing requirements and acceptance criteria`,
-    `- Set \`storyPointValue\` based on estimated complexity`,
-    `- Express cross-child ordering as \`dependsOn\` (sibling ids/slugs) on \`create_subtask\` \u2014 explicit dependency metadata, not "after task 2" phrasing in the plan. Independent children get no dependencies so they run in parallel.`,
-    ``,
-    ...buildPlanCitationFormat(),
-    ``,
-    ...context?.isParentTask ? [
-      ``,
-      `### Parent Task Guidance`,
-      `You are a parent task \u2014 coordinate child tasks instead of implementing directly.`,
-      `If no children exist yet, break the work down now: save a parent-level plan with update_task_plan, then create child tasks with create_subtask (each with a detailed plan).`,
-      `Child task status lifecycle: Open \u2192 InProgress \u2192 ReviewPR \u2192 ReviewDev \u2192 Complete.`,
-      `Set child ordering with \`dependsOn\` (sibling ids/slugs) on \`create_subtask\` \u2014 explicit metadata the pack runner schedules off, not order described in plan text. Independent children get none and run in parallel.`
-    ] : [
-      ...buildAttachArtifactsSection(),
-      ...buildPrGuideSection(),
-      ...buildNoPrWhenNoCodeSection(context?.baseBranch)
-    ],
-    ...buildPlanRevisionSection(),
-    ``,
-    `### Autonomous Guidelines:`,
-    `- Make decisions independently \u2014 do not ask the team for approval at each step`,
-    `- Only escalate when genuinely blocked (ambiguous requirements, missing access, conflicting instructions)`,
-    `- Investigate efficiently: search (grep/glob) to locate code, read only critical files, form a hypothesis, validate, then plan`
-  ];
-  if (context) parts.push(...buildPropertyInstructions(context, runnerMode));
-  return parts.join("\n");
-}
-function buildBuildingPrompt(context) {
-  const parts = [
-    `
-## Mode: Building`,
-    `You are in Building mode \u2014 executing the plan.`,
-    `- You have full coding access (read, write, edit, bash, git)`,
-    `- Safety rules: no destructive operations, use --force-with-lease instead of --force`,
-    ...context?.isParentTask ? [
-      `- You are a parent task. Use \`list_subtasks\`, \`start_child_cloud_build\`, and subtask management tools to coordinate children.`,
-      `- Do NOT implement code directly \u2014 fire child builds and review their work.`,
-      `- Goal: coordinate child task execution and ensure all children complete successfully`
-    ] : [
-      `- If this is a leaf task (no children): execute the plan directly`,
-      `- Goal: implement the plan, run scoped verification once, open a PR when done`,
-      ``,
-      ...buildPrePrProtocolSection(context),
-      ...buildAttachArtifactsSection(),
-      ...buildPrGuideSection(),
-      ...buildNoPrWhenNoCodeSection(context?.baseBranch),
-      ...context?.isAuto || !context?.plan?.trim() ? buildPlanDocumentationSection(context) : []
-    ],
-    ...buildPlanRevisionSection()
-  ];
-  if (context) parts.push(...buildPropertyInstructions(context));
-  return parts.join("\n");
-}
-function buildModePrompt(agentMode, context, runnerMode) {
-  switch (agentMode) {
-    case "discovery":
-      return buildDiscoveryPrompt(context, runnerMode);
-    case "building":
-      return buildBuildingPrompt(context);
-    case "review":
-      return buildReviewPrompt(context);
-    case "auto":
-      return buildAutoPrompt(context, runnerMode);
-    case "chat":
-      return buildChatPrompt(context);
-    default:
-      return null;
-  }
-}
-function buildChatPrompt(context) {
-  const base = context?.baseBranch?.trim() || "dev";
-  return [
-    `
-## Mode: Chat`,
-    `You are in Chat mode \u2014 a conversational assistant working directly with the user on this card.`,
-    `- Respond conversationally to the user in chat. Ask clarifying questions when useful; this is a back-and-forth, not an autonomous build.`,
-    `- You have full read/write access to the workspace and can run non-destructive shell commands, so you CAN create files (notes, scripts, docs, data, diagrams, etc.) when they help the user.`,
-    `- This card starts Unidentified. That is correct \u2014 it stays a conversation until the work becomes a development task (see below).`,
-    ``,
-    `### Deliverables \u2014 attach files to the card`,
-    `- When you create a file the user should keep, attach it to the card with the \`upload_attachment\` tool so it shows up on the card. Mention in chat what you attached.`,
-    `- \`upload_attachment\` accepts any file type (markdown, PDF, HTML, text, data, images) up to 25MB \u2014 this is how docs are delivered. Do NOT publish deliverables as a Claude artifact or any other off-platform link; the card is the system of record.`,
-    `- For conversational work, attachments are the deliverable. Do NOT open a PR to hand over a document or an answer.`,
-    ``,
-    `### Turning into a development task`,
-    `- If the conversation becomes a request to change the code, escalate the card first: save a plan with \`update_task_plan\`. That first plan identifies the card and moves it to In Progress.`,
-    `- The plan is also the gate on your PR path: \`create_pull_request\`, \`git push\` and \`gh pr\` are DENIED until a plan is saved, and allowed afterwards. Do not try to work around a denial \u2014 save the plan.`,
-    `- Once the plan is saved, work like a normal build: implement it, then run ONE verification pass (\`bun run check\` plus \`bun run test:affected\`) after syncing the base (\`git fetch origin ${base} && git merge origin/${base} --no-edit\`), then open the PR with \`mcp__conveyor__create_pull_request\`.`,
-    `- Keep talking to the user while you build \u2014 this is still their card.`,
-    ``,
-    `### Finishing the conversation`,
-    `- When the user indicates they are done (or explicitly asks to wrap up / close the card), call \`force_update_task_status\` with status \`"Complete"\`. It works from either status, so a card still sitting Unidentified can be completed the same way as one that reached In Progress.`,
-    `- If you opened a PR, do NOT complete the card \u2014 the PR review flow takes it from there.`,
-    `- If the user is still engaged, keep helping \u2014 only complete the card once the interaction has concluded.`,
-    `- Do not complete the card while you still owe the user a response or an attachment.`
-  ].join("\n");
-}
-function buildReviewTagSection(context) {
-  const assignedIds = new Set(context?.taskTagIds ?? []);
-  const assigned = (context?.projectTags ?? []).filter((t) => assignedIds.has(t.id));
-  if (assigned.length === 0) return [];
-  const parts = [`### Card Tags & Domain Context`, `This card carries these project glossary tags:`];
-  for (const tag of assigned) parts.push(...formatTagWithContextPaths(tag));
-  parts.push(
-    ``,
-    `A tag's rules and overview define the conventions the code under review must follow. Use them when you judge Pattern Consistency:`,
-    `- Read the tag entries that match the files in this diff. The "Reference Guides" section of the task brief lists the same tags with a one-line summary of each linked doc.`,
-    `- Call get_tag("<name>") for a term's full spec (overview, linked files, hierarchy) when the linked docs are not enough.`,
-    `- A change that contradicts a tagged system's documented conventions is a review finding, even when it reads fine on its own.`,
-    `- Skip the tags this diff does not touch \u2014 do not read them all up front.`,
-    `- If the diff changes how a tagged system behaves and the tag's overview is now wrong, say so in your review.`,
-    ``
-  );
-  return parts;
-}
-function buildReviewPrompt(context) {
-  const parts = [
-    `
-## Mode: Review`,
-    `You are in Review mode \u2014 performing code review with fix capability.`,
-    `- You have full write access \u2014 you can audit code, make fixes, push changes, and run tests`,
-    `- Safety rules: no destructive operations, use --force-with-lease instead of --force`,
-    ``
-  ];
-  if (context?.isParentTask) {
-    parts.push(
-      `### Parent Task Review`,
-      `You are reviewing and coordinating child tasks.`,
-      `- Use \`list_subtasks\` to see current child task state and progress.`,
-      `- For children in ReviewPR status: review their code quality and merge with \`approve_and_merge_pr\`.`,
-      `- For children with failing CI: check with \`get_execution_logs(childTaskId)\` and escalate if stuck.`,
-      `- Fire next child builds with \`start_child_cloud_build\` when ready.`,
-      `- Create follow-up tasks for issues discovered during review.`,
-      ``,
-      `### Coordination Workflow`,
-      `1. Check child task statuses with \`list_subtasks\``,
-      `2. Review completed children \u2014 check PRs, run tests if needed`,
-      `3. Approve and merge passing PRs`,
-      `4. Fire builds for children that are ready`,
-      `5. Create follow-up tasks for anything out of scope`,
-      `6. As children complete, correct their story points with update_subtask (storyPointValue) when the actual work diverged from the estimate \u2014 either direction`
-    );
-  } else {
-    const tagSection = buildReviewTagSection(context);
-    const patternConsistency = tagSection.length ? `- **Pattern Consistency**: Does the code follow existing patterns in the codebase? Check nearby files AND the card's tag rules/overviews (see "Card Tags & Domain Context" below).` : `- **Pattern Consistency**: Does the code follow existing patterns in the codebase? Check nearby files.`;
-    parts.push(
-      `### Code Review Process`,
-      `1. Run \`${baseDiffCommand(context?.baseBranch)}\` to see all changes in this PR`,
-      `2. Read the task plan to understand the intended changes`,
-      `3. Explore the surrounding codebase to verify pattern consistency`,
-      `4. Review against the criteria below`,
-      ``,
-      `### Review Criteria`,
-      `- **Correctness**: Does the code do what the plan says? Logic errors, off-by-one, race conditions?`,
-      patternConsistency,
-      `- **Security**: No hardcoded secrets, no injection vulnerabilities, proper input validation at boundaries.`,
-      `- **Performance**: No unnecessary loops, no N+1 queries, no blocking in async contexts.`,
-      `- **Error Handling**: Appropriate error handling at system boundaries. No swallowed errors.`,
-      `- **Test Coverage**: Are new code paths tested? Edge cases covered?`,
-      `- **TypeScript Best Practices**: Proper typing (no unnecessary \`any\`), correct React patterns, proper async/await.`,
-      `- **Naming & Readability**: Clear names, no misleading comments, self-documenting code.`,
-      ``,
-      `### Fix Capability`,
-      `You have full write access. If you find issues:`,
-      `- **Small fixes**: Make the fix directly, commit, and push. Then re-review.`,
-      `- **Larger issues**: Use \`request_code_changes\` to flag them for the team.`,
-      `- After pushing fixes, wait for CI to pass before approving.`,
-      ``,
-      `### Output \u2014 You MUST do exactly ONE of:`,
-      ``,
-      `#### If code passes review (or after you've fixed all issues):`,
-      `Use the \`approve_code_review\` tool with a brief summary of what looks good.`,
-      ``,
-      `#### If changes are needed that you cannot fix:`,
-      `Use the \`request_code_changes\` tool with specific issues:`,
-      `- Reference specific files and line numbers`,
-      `- Explain what's wrong and suggest fixes`,
-      `- Focus on substantive issues, not style nitpicks (linting handles that)`,
-      ``,
-      `#### Risk level (required on BOTH tools):`,
-      `Every verdict MUST include a \`risk\` level \u2014 judge it by the surface area the change touches:`,
-      `- \`critical\`: touches critical/foundational surface (auth, billing, data integrity, migrations)`,
-      `- \`high\`: touches important surface with broad blast radius`,
-      `- \`medium\`: moderate, contained surface area`,
-      `- \`low\`: small or isolated change`,
-      `The task may already have a risk level set. If your review makes you disagree with it, set the level you believe is correct \u2014 you have the authority to override it in either direction.`,
-      ``,
-      `#### Story points (correct if wrong):`,
-      `You can see the full final diff \u2014 if the story-point estimate no longer matches the actual size of the work, correct it with update_task_properties (storyPointValue), in either direction. The card should record what the work actually was, not what it looked like at planning time.`,
-      ``,
-      ...tagSection,
-      `### Previous Review Feedback`,
-      `If previous review feedback is present in the chat history, verify those specific issues were addressed before raising new concerns.`,
-      ``,
-      `### Rules`,
-      `- Do NOT re-review things CI already validates (formatting, lint rules).`,
-      `- Be concise \u2014 actionable specifics over general observations.`,
-      `- Max 5-7 issues per review. Prioritize the most important ones.`
-    );
-  }
-  return parts.join("\n");
-}
-
-// src/execution/system-prompt.ts
 function repoHasScript(workspaceDir, script) {
   try {
     const pkg = JSON.parse(readFileSync(join11(workspaceDir, "package.json"), "utf8"));
@@ -7722,7 +7821,7 @@ Environment (ready, no setup required):`,
     `
 Workflow:`,
     `- You can draft and iterate on plans in .claude/plans/*.md, but files on disk are NOT synced to the task.`,
-    `- Save the plan to the task with update_task_plan \u2014 this is the only way the plan is persisted.`,
+    `- Save the plan to the task with update_task \u2014 this is the only way the plan is persisted.`,
     `- After saving the plan, call post_to_chat with a short summary for the team (your turn output is NOT posted to chat \u2014 they only see what you post), then end your turn. Do NOT attempt to execute the plan yourself.`,
     `- A separate task agent will handle execution after the team reviews and approves your plan.`
   ];
@@ -7749,7 +7848,7 @@ function buildActivePreamble(context, workspaceDir) {
     `You are an AI project manager in ACTIVE mode for the "${context.title}" project.`,
     `You have direct coding access to the repository at ${workspaceDir}.`,
     `You can edit files, run tests, and make commits.`,
-    `You still have access to all PM tools (subtasks, update_task_plan, chat).`,
+    `You still have access to all PM tools (subtasks, update_task, chat).`,
     `
 Environment (ready, no setup required):`,
     `- Repository is cloned at your current working directory.`,
@@ -7804,12 +7903,15 @@ Git:`,
     `- If \`git push\` is rejected as non-fast-forward, run \`git push --force-with-lease origin ${context.githubBranch}\`. This branch is exclusively yours, so force-with-lease is safe.`
   ];
 }
+function buildPackPrompt(mode, context, config, setupLog) {
+  return mode === "pack" && config.packExecution !== "fan-out" ? buildSinglePodPackPrompt(context, config, setupLog) : buildPackRunnerSystemPrompt(context, config, setupLog);
+}
 function buildSystemPrompt(mode, context, config, setupLog, agentMode) {
   const isPm = mode === "pm";
   const isPmActive = isPm && agentMode === "building";
   const isPackRunner = mode === "pack" || isPm && !!config.isAuto && !!context.isParentTask;
   if (isPackRunner) {
-    return buildPackRunnerSystemPrompt(context, config, setupLog);
+    return buildPackPrompt(mode, context, config, setupLog);
   }
   const parts = isPmActive ? buildActivePreamble(context, config.workspaceDir) : isPm ? buildPmPreamble(context) : buildTaskAgentPreamble(context, config.workspaceDir);
   if (setupLog.length > 0) {
@@ -7869,6 +7971,19 @@ function detectRelaunchScenario(context, trustChatHistory = false) {
   const hasNewUserMessages = messagesAfterAgent.some((m) => m.role === "user");
   return hasNewUserMessages ? "feedback_relaunch" : "idle_relaunch";
 }
+function branchRule(context, forReview = false) {
+  return forReview ? `Work on the git branch "${context.githubBranch}". Stay on this branch for the entire review. Do not checkout or create other branches.` : `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`;
+}
+function newMessagesBlock(messages) {
+  return [
+    `
+New messages since your last run:`,
+    ...messages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`)
+  ];
+}
+function pullRequestLine(context) {
+  return context.githubPRUrl ? `An existing PR is open at ${context.githubPRUrl} \u2014 push to the same branch to update it. Do NOT create a new PR.` : `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`;
+}
 function buildRelaunchWithSession(mode, context, agentMode, isAuto) {
   const scenario = detectRelaunchScenario(context);
   const hasPriorTurn = !!context.lastSeenMessageId || !!context.claudeSessionId;
@@ -7891,27 +8006,17 @@ function buildRelaunchWithSession(mode, context, agentMode, isAuto) {
     const newMessages = allNew.filter((m) => m.role === "user");
     parts.push(
       `You have been relaunched with new feedback.`,
-      `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
-      `
-New messages since your last run:`,
-      ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
+      branchRule(context),
+      ...newMessagesBlock(newMessages),
       `
 Address the requested changes. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 review the feedback and implement the changes directly.`,
-      `Commit and push your updates.`
+      `Commit and push your updates.`,
+      pullRequestLine(context)
     );
-    if (context.githubPRUrl) {
-      parts.push(
-        `An existing PR is open at ${context.githubPRUrl} \u2014 push to the same branch. Do NOT create a new PR.`
-      );
-    } else {
-      parts.push(
-        `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI.`
-      );
-    }
   } else {
     parts.push(
       `You were relaunched but no new instructions have been given since your last run.`,
-      `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+      branchRule(context),
       `Run \`git log --oneline -10\` to review what you already committed.`,
       `Review the current state of the codebase and verify everything is working correctly.`
     );
@@ -8022,9 +8127,9 @@ function buildFreshInstructions(isPm, isAutoMode, context, agentMode) {
   if (isPm && agentMode === "building") {
     return [
       `Your plan has been approved. Begin implementing it now.`,
-      `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+      branchRule(context),
       `Start by reading the relevant source files mentioned in the plan, then write code.`,
-      `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI.`,
+      pullRequestLine(context),
       `
 CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or go idle without making code changes.`,
       `Your FIRST action must be reading source files from the plan, then immediately writing code.`,
@@ -8044,7 +8149,7 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
     return [
       `You are operating autonomously. No plan is saved on this card yet.`,
       `1. Search the codebase (grep/glob) to locate relevant files, then read the critical ones`,
-      `2. Save a concise plan with update_task_plan BEFORE writing any code \u2014 the plan is a record for the team, not a gate; never pause or wait for approval`,
+      `2. Save a concise plan with update_task BEFORE writing any code \u2014 the plan is a record for the team, not a gate; never pause or wait for approval`,
       `3. Implement the work, keeping the plan current if your approach changes materially`,
       `4. Refine story points, tags, and title (update_task_properties) if they look like placeholders`,
       `Do NOT wait for team input \u2014 proceed autonomously.`
@@ -8056,7 +8161,7 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
       `Review existing subtasks via \`list_subtasks\` and the chat history before taking action.`,
       `Read the task description and chat history carefully \u2014 the team has provided the initial context below. Acknowledge what they've asked for and respond in chat before taking silent tool actions.`,
       `Start planning now \u2014 explore the codebase, ask clarifying questions if needed, and propose a subtask breakdown. Do not wait for additional team input before engaging.`,
-      `When you finish planning, save the plan with update_task_plan, post a short summary for the team with post_to_chat (your turn output is NOT shown in chat), then end your turn.`
+      `When you finish planning, save the plan with update_task, post a short summary for the team with post_to_chat (your turn output is NOT shown in chat), then end your turn.`
     ];
   }
   if (isPm) {
@@ -8065,20 +8170,20 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
       `Your job right now is to help the team turn this request into a clear, well-scoped plan. Be a helpful planning partner: think out loud, surface trade-offs, and keep the human in the loop.`,
       `Read the task description and chat history carefully \u2014 the team has provided the initial context below. Acknowledge what they've asked for and respond in chat before taking silent tool actions.`,
       `Start planning now \u2014 explore the codebase, ask clarifying questions if anything is ambiguous, and draft a plan. Do not wait for additional team input before engaging; the initial message IS the team engaging.`,
-      `When you finish planning, save the plan with update_task_plan, post a summary of the plan for the team with post_to_chat (your turn output is NOT shown in chat), then end your turn. A separate task agent will execute the plan after review.`
+      `When you finish planning, save the plan with update_task, post a summary of the plan for the team with post_to_chat (your turn output is NOT shown in chat), then end your turn. A separate task agent will execute the plan after review.`
     ];
   }
   return buildFreshLeafInstructions(context, isAutoMode);
 }
 function buildFreshLeafInstructions(context, isAutoMode) {
   const parts = context.plan?.trim() ? [`Start now by reading the source files the plan names, then writing code.`] : [
-    `No plan is saved on this card yet. Investigate the task briefly (search first, read only critical files), then save a concise implementation plan with update_task_plan (file:line citations) BEFORE you start writing code.`,
+    `No plan is saved on this card yet. Investigate the task briefly (search first, read only critical files), then save a concise implementation plan with update_task (file:line citations) BEFORE you start writing code.`,
     `The plan is a step, not the goal: the moment it's posted, IMPLEMENT it in code \u2014 do NOT pause, wait for approval, or treat the posted plan as the deliverable. The card is already In Progress and advances automatically.`
   ];
   const base = context.baseBranch?.trim() || "dev";
   parts.push(
     `Post to chat when you begin implementing and again when the PR is ready.`,
-    `Follow the **Pre-PR Protocol** in your system prompt: commit, then sync the base (\`git fetch origin ${base} && git merge origin/${base} --no-edit\`), then ONE verification pass \u2014 \`bun run check\` (lint + typecheck) plus \`bun run test:affected\` (tests scoped to your diff; docs-only changes need no local gates) \u2014 then open the PR. Do NOT re-merge the base or re-run a gate that already passed.`,
+    `Pre-PR order (\`/conveyor-build\` has the detail): commit, then sync the base (\`git fetch origin ${base} && git merge origin/${base} --no-edit\`), then ONE verification pass \u2014 \`bun run check\` (lint + typecheck) plus \`bun run test:affected\` (tests scoped to your diff; docs-only changes need no local gates) \u2014 then open the PR. Do NOT re-merge the base or re-run a gate that already passed.`,
     `If a gate fails, iterate on just the failing test files (\`bun run --cwd <pkg> test:unit <files>\`) and confirm with a single final scoped-gate run. Do NOT open a PR with known failing gates.`,
     `Open the PR with mcp__conveyor__create_pull_request when the work is done and the gates are green.`
   );
@@ -8095,19 +8200,7 @@ CRITICAL: You are in Auto mode. Your job is to BUILD the change, not to produce
   return parts;
 }
 function buildFreshCodeReviewInstructions(context) {
-  const parts = [
-    `Perform the automated code review for this PR.`,
-    `Work on the git branch "${context.githubBranch}". Stay on this branch for the entire review. Do not checkout or create other branches.`,
-    `Start by establishing what you are actually reviewing${context.githubPRUrl ? `: \`gh pr view ${context.githubPRUrl} --json state,baseRefName,headRefOid,files\`` : ` \u2014 the PR's own base ref, head SHA and changed-file list`}. Do this BEFORE any git diff: the PR's base is often not the project default branch, and asking the PR costs one call instead of six.`,
-    `Then inspect the submitted changes with \`${baseDiffCommand(context.baseBranch)}\`. If that disagrees with the PR's file list, trust the PR: diff the head SHA directly (\`git diff <headSha>^ <headSha>\`) and review that.`,
-    `Your checkout can be stale, and so can the remote branch tip \u2014 a merged PR's commit may be reachable only by SHA. If the PR reports state MERGED or CLOSED, say so and review the recorded head SHA rather than assuming your working tree matches it.`,
-    `Read the code under review out of the PR's commit, NOT the working tree: \`git show <sha>:<path>\` and \`git grep <pattern> <sha>\`. Grepping the working tree when the PR is based elsewhere returns confident, wrong answers \u2014 it has produced false review findings.`,
-    `Review for correctness, security, performance, error handling, test coverage, and consistency with existing patterns.`,
-    `Consult the card's tag Reference Guides in the brief above for the domain rules that apply to this diff \u2014 they are the conventions the change must follow, and a contradiction of them is a review finding.`,
-    `If small fixes are needed, make them directly, commit, push, and re-review the result.`,
-    `Use approve_code_review when the PR passes review.`,
-    `Use request_code_changes when substantive issues remain that you cannot fix directly.`
-  ];
+  const parts = [...buildSkillInvocation("/conveyor-review"), branchRule(context, true)];
   if (context.githubPRUrl) {
     parts.push(`The PR under review is ${context.githubPRUrl}. Do not create a new PR.`);
   }
@@ -8120,22 +8213,20 @@ function buildFeedbackInstructions(context, isPm, agentMode, isAuto) {
     const parts2 = [
       `You were relaunched with new feedback since your last run.`,
       `You are the project manager for this task.`,
-      `
-New messages since your last run:`,
-      ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`)
+      ...newMessagesBlock(newMessages)
     ];
     if (isAuto && (agentMode === "building" || agentMode === "review")) {
       parts2.push(
         `
 Your plan has been approved. Address the feedback above, then begin implementing.`,
-        `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+        branchRule(context),
         `Start by reading the relevant source files mentioned in the plan, then write code.`,
-        `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI.`
+        pullRequestLine(context)
       );
     } else if (isAuto) {
       parts2.push(
         `
-You are in auto mode. Address the feedback above and continue building \u2014 update the saved plan with update_task_plan if the feedback changes your approach.`,
+You are in auto mode. Address the feedback above and continue building \u2014 update the saved plan with update_task if the feedback changes your approach.`,
         `Do NOT wait for additional team input \u2014 the messages above ARE the team's input. Proceed autonomously.`
       );
     } else {
@@ -8148,28 +8239,18 @@ Review these messages and wait for the team to provide instructions before takin
   }
   const parts = [
     `You have been relaunched to address feedback on your previous work.`,
-    `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+    branchRule(context),
     `Start by running \`${baseDiffCommand(context.baseBranch, "--stat")}\` to review what you already committed on this branch.`,
-    `
-New messages since your last run:`,
-    ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
+    ...newMessagesBlock(newMessages),
     `
 Address the requested changes directly. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 go straight to implementing the feedback.`,
     // Scoped to what the follow-up actually changed. An unconditional full
     // re-verify on every relaunch made a one-line or docs-only follow-up cost
     // the same gate time as the original build.
     `Re-verify in proportion to what THIS follow-up changed, not the whole branch: a docs/\`.claude\`-only change needs no local gates; a code change runs \`bun run check\` plus the directly-affected test files (\`bun run --cwd <pkg> test:unit <files>\`); escalate to a full \`bun run test:affected\` only when the follow-up touched \`packages/shared\`, \`packages/db\`, or root config, or when no gate has ever run on this branch. Fix any failures before pushing \u2014 relaunches are the most common place verification gets skipped.`,
-    `Implement your updates and open a PR when finished.`
+    `Implement your updates and open a PR when finished.`,
+    pullRequestLine(context)
   ];
-  if (context.githubPRUrl) {
-    parts.push(
-      `An existing PR is open at ${context.githubPRUrl} \u2014 push to the same branch to update it. Do NOT create a new PR.`
-    );
-  } else {
-    parts.push(
-      `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
-    );
-  }
   return parts;
 }
 function buildIdleRelaunchInstructions(context, isPm, agentMode, isAuto) {
@@ -8183,7 +8264,7 @@ function buildIdleRelaunchInstructions(context, isPm, agentMode, isAuto) {
     }
     return [
       `You were relaunched in auto mode. Continue building autonomously.`,
-      `No plan is saved on this card yet \u2014 save a concise plan with update_task_plan before writing further code; never pause or wait for approval.`,
+      `No plan is saved on this card yet \u2014 save a concise plan with update_task before writing further code; never pause or wait for approval.`,
       `Do NOT wait for instructions or go idle \u2014 you are in auto mode.`
     ];
   }
@@ -8197,7 +8278,7 @@ function buildIdleRelaunchInstructions(context, isPm, agentMode, isAuto) {
   const isAutoMode = agentMode === "auto" || agentMode === "building" || isAuto;
   const parts = [
     `You were relaunched but no new instructions have been given since your last run.`,
-    `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
+    branchRule(context),
     `Run \`git log --oneline -10\` to review what you already committed, then verify the current state is correct.`
   ];
   if (isAutoMode) {
@@ -8252,7 +8333,7 @@ function buildInstructions(mode, context, scenario, agentMode, isAuto) {
   parts.push(...buildFeedbackInstructions(context, isPm, agentMode, isAuto));
   return parts;
 }
-async function buildInitialPrompt(mode, context, isAuto, agentMode) {
+async function buildInitialPrompt(mode, context, isAuto, agentMode, packExecution) {
   const isPackRunner = mode === "pack" || mode === "pm" && !!isAuto && !!context.isParentTask;
   if (!isPackRunner) {
     const sessionRelaunch = buildRelaunchWithSession(mode, context, agentMode, isAuto);
@@ -8266,12 +8347,13 @@ async function buildInitialPrompt(mode, context, isAuto, agentMode) {
     scenario = "fresh";
   }
   const body = await buildTaskBody(context, mode);
-  const instructions = isPackRunner ? buildPackRunnerInstructions(context, scenario) : buildInstructions(mode, context, scenario, agentMode, isAuto);
+  const singlePodPack = mode === "pack" && packExecution !== "fan-out";
+  const instructions = isPackRunner ? singlePodPack ? buildSinglePodPackInstructions(context, scenario) : buildPackRunnerInstructions(context, scenario) : buildInstructions(mode, context, scenario, agentMode, isAuto);
   return [...body, ...instructions].join("\n");
 }
 
 // src/tools/task-context-tools.ts
-import { z as z11 } from "zod";
+import { z as z13 } from "zod";
 
 // ../shared/dist/tool-contracts/index.js
 var f = {
@@ -8300,14 +8382,14 @@ var f = {
     return { kind: "nullable", inner };
   }
 };
-function compileString(z19, spec) {
-  let schema = z19.string();
+function compileString(z20, spec) {
+  let schema = z20.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(z19, spec) {
-  let schema = z19.number();
+function compileNumber(z20, spec) {
+  let schema = z20.number();
   if (spec.int) schema = schema.int();
   if (spec.positive) schema = schema.positive();
   if (spec.nonnegative) schema = schema.nonnegative();
@@ -8315,41 +8397,49 @@ function compileNumber(z19, spec) {
   if (spec.max !== void 0) schema = schema.max(spec.max);
   return schema;
 }
-function compileArray(z19, spec) {
-  let schema = z19.array(compileField(z19, spec.item));
+function compileArray(z20, spec) {
+  let schema = z20.array(compileField(z20, spec.item));
   if (spec.min !== void 0) schema = schema.min(spec.min);
   return schema;
 }
-function compileBase(z19, spec) {
+function compileBase(z20, spec) {
   switch (spec.kind) {
     case "string":
-      return compileString(z19, spec);
+      return compileString(z20, spec);
     case "number":
-      return compileNumber(z19, spec);
+      return compileNumber(z20, spec);
     case "boolean":
-      return z19.boolean();
+      return z20.boolean();
     case "enum":
-      return z19.enum([...spec.values]);
+      return z20.enum([...spec.values]);
     case "array":
-      return compileArray(z19, spec);
+      return compileArray(z20, spec);
     case "object":
-      return z19.object(compileShape(z19, spec.fields));
+      return z20.object(compileShape(z20, spec.fields));
   }
 }
-function compileField(z19, spec) {
+function descriptionOf(spec) {
+  if (spec.kind === "optional" || spec.kind === "nullable") return descriptionOf(spec.inner);
+  return spec.desc;
+}
+function compileUndescribed(z20, spec) {
   if (spec.kind === "optional") {
-    return compileField(z19, spec.inner).optional();
+    return compileUndescribed(z20, spec.inner).optional();
   }
   if (spec.kind === "nullable") {
-    return compileField(z19, spec.inner).nullable();
+    return compileUndescribed(z20, spec.inner).nullable();
   }
-  const schema = compileBase(z19, spec);
-  return spec.desc === void 0 ? schema : schema.describe(spec.desc);
+  return compileBase(z20, spec);
 }
-function compileShape(z19, fields) {
+function compileField(z20, spec) {
+  const schema = compileUndescribed(z20, spec);
+  const desc = descriptionOf(spec);
+  return desc === void 0 ? schema : schema.describe(desc);
+}
+function compileShape(z20, fields) {
   const shape = {};
   for (const [key, spec] of Object.entries(fields)) {
-    shape[key] = compileField(z19, spec);
+    shape[key] = compileField(z20, spec);
   }
   return shape;
 }
@@ -8537,14 +8627,118 @@ var approveAndMergePrContract = defineToolContract({
     }
   }
 });
+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,
-  approveAndMergePrContract
+  approveAndMergePrContract,
+  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, assignment, githubBranch, or tags. Set status to claim a card (InProgress), triage it (Open), or cancel it (Cancelled); for review approvals prefer approve_task / request_changes, which guard against stale-state races. Tags are additive/subtractive \u2014 pass addTags/removeTags with tag names (not a replace-set). Pass projectId to target a specific project; otherwise the configured default project is used. Moving a task beyond Planning auto-fills any missing icon, story points, and agent assignment \u2014 don't spend turns on them; pass storyPointValue only to correct the sizing yourself. For subtasks use update_subtask.",
+    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.`
+          })
+        )
+      ),
+      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 }))),
+      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,
@@ -8835,7 +9029,7 @@ var createSubtaskContract = defineToolContract({
 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_plan.",
+    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()),
@@ -8900,7 +9094,7 @@ var deleteSubtaskContract = defineToolContract({
 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, dependencies, and holdsBuildSlot \u2014 plus packSlots (in-flight environments vs the PACK_CHILD_LIMIT cap, and which children hold the slots). Use to coordinate child work; pass verbose:true only when you need full description/plan text (large). For non-child tasks use get_task.",
+    description: "List all subtasks under the current parent task. Default compact view returns per child: status, agent, story points, PR number/state, and dependencies. On a FAN-OUT pack it also returns holdsBuildSlot per child plus a packSlots summary (in-flight environments vs the PACK_CHILD_LIMIT cap, and which children hold the slots); both are omitted on the default single-pod path, where one pod implements every child and nothing holds a slot. Use to coordinate child work; 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({
@@ -9103,41 +9297,448 @@ var createPullRequestContract = defineToolContract({
     }
   },
   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."
-      }),
-      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)" })
-      )
-    }
+    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."
+      }),
+      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 meetingsContracts = [
+  listMeetingsContract,
+  getMeetingContract,
+  readMeetingTranscriptContract
+];
+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" })
+  )
+};
+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.";
+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 pullRequestContracts = [createPullRequestContract];
+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 TOOL_CONTRACTS = Object.fromEntries(
   [
     ...tasksContracts,
+    ...taskUpdateContracts,
     ...tagsContracts,
     ...checklistContracts,
     ...dependenciesContracts,
     ...subtasksContracts,
     ...attachmentsContracts,
     ...suggestionsContracts,
-    ...pullRequestContracts
+    ...pullRequestContracts,
+    ...integrationsContracts,
+    ...driveContracts,
+    ...meetingsContracts,
+    ...logsContracts
   ].map((contract) => [contract.name, contract])
 );
 
 // src/tools/contract-tool.ts
-import { z as z10 } from "zod";
+import { z as z12 } from "zod";
 function agentShape(surface) {
-  return compileShape(z10, surface.fields);
+  return compileShape(z12, surface.fields);
 }
 function defineContractTool(contract, handler, options) {
   return {
@@ -9222,6 +9823,54 @@ ${plan}` : plan
     { annotations: { readOnlyHint: true } }
   );
 }
+function buildGetConnectionContextTool(connection) {
+  return defineContractTool(
+    getConnectionContextContract,
+    async () => {
+      try {
+        const ctx = await connection.call("getTaskContext", {
+          sessionId: connection.sessionId,
+          peekPlanRevision: true
+        });
+        return textResult(
+          JSON.stringify(
+            {
+              task: {
+                id: ctx.id,
+                title: ctx.title,
+                status: ctx.status,
+                branch: ctx.githubBranch,
+                baseBranch: ctx.baseBranch,
+                isParentTask: ctx.isParentTask ?? false,
+                parentTaskId: ctx.parentTaskId,
+                // Safe to report BECAUSE we peeked: the marker is still there
+                // for get_current_plan to consume and banner properly.
+                planRevisedAt: ctx.planRevisedAt ?? null
+              },
+              project: { id: ctx.projectId, name: ctx.projectName ?? null },
+              agent: {
+                id: ctx.agentId,
+                model: ctx.model,
+                mode: ctx.agentMode ?? null,
+                isAuto: ctx.isAuto ?? false
+              },
+              // Said plainly so a shared skill does not go looking for an
+              // account here: a pod is bound to a card, not to a person.
+              summary: `Pod session bound to task ${ctx.id} on branch ${ctx.githubBranch ?? "(none yet)"} (base ${ctx.baseBranch ?? "(none)"}) in project ${ctx.projectName ?? ctx.projectId}. No user account is attached to a pod session.`
+            },
+            null,
+            2
+          )
+        );
+      } catch (error) {
+        return textResult(
+          `Failed to resolve connection context: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
 function buildGetTaskTool(connection) {
   return defineContractTool(
     getTaskContract,
@@ -9246,11 +9895,11 @@ function buildGetExecutionLogsTool(connection) {
     "get_execution_logs",
     "Read CLI execution logs \u2014 agent reasoning, tool calls, and setup/dev-server output. Filter via source='agent' or 'application'. For human chat use read_task_chat.",
     {
-      task_id: z11.string().optional().describe(
+      task_id: z13.string().optional().describe(
         "Task ID or slug. Omit to read logs from the current task. Only the current task or one of its child tasks can be read."
       ),
-      source: z11.enum(["agent", "application"]).optional().describe("Filter by log source. Omit for all logs."),
-      limit: z11.number().optional().describe("Max number of log entries to return (default 50, max 500).")
+      source: z13.enum(["agent", "application"]).optional().describe("Filter by log source. Omit for all logs."),
+      limit: z13.number().optional().describe("Max number of log entries to return (default 50, max 500).")
     },
     async ({ task_id, source, limit }) => {
       try {
@@ -9336,6 +9985,7 @@ function buildTaskContextTools(connection) {
   return [
     buildReadTaskChatTool(connection),
     buildGetCurrentPlanTool(connection),
+    buildGetConnectionContextTool(connection),
     buildGetTaskTool(connection),
     buildGetExecutionLogsTool(connection),
     buildListTaskFilesTool(connection),
@@ -9344,7 +9994,7 @@ function buildTaskContextTools(connection) {
 }
 
 // src/tools/dependency-suggestion-tools.ts
-import { z as z12 } from "zod";
+import { z as z14 } from "zod";
 function buildGetDependenciesTool(connection) {
   return defineContractTool(
     getDependenciesContract,
@@ -9368,10 +10018,10 @@ function buildGetSuggestionsTool(connection) {
     "get_suggestions",
     "List project suggestions sorted by vote score. Filter by status or cap with limit (default 20). Suggestions are project-level ideas, not tasks \u2014 use get_task for tasks.",
     {
-      status: z12.string().optional().describe(
+      status: z14.string().optional().describe(
         "Filter by status: Planning, Open, InProgress, ReviewPR, ReviewDev, ReviewLive, Complete, Cancelled"
       ),
-      limit: z12.number().int().min(1).max(100).optional().describe("Max results (default 20)")
+      limit: z14.number().int().min(1).max(100).optional().describe("Max results (default 20)")
     },
     async ({ status, limit }) => {
       try {
@@ -9395,7 +10045,7 @@ function buildGetSuggestionsTool(connection) {
 }
 
 // src/tools/mutation-tools.ts
-import { z as z13 } from "zod";
+import { z as z15 } from "zod";
 
 // src/runner/refresh-verify-heal.ts
 async function refreshAndVerifyGithubCredential(cwd, mint) {
@@ -9527,7 +10177,7 @@ function buildForceUpdateTaskStatusTool(connection) {
     "force_update_task_status",
     "EMERGENCY ONLY: force-override a task's Kanban status. Use when an automatic transition failed and the task is wedged. Normal flow transitions status automatically.",
     {
-      status: z13.enum([
+      status: z15.enum([
         "Planning",
         "Open",
         "InProgress",
@@ -9537,7 +10187,7 @@ function buildForceUpdateTaskStatusTool(connection) {
         "Complete",
         "Cancelled"
       ]).describe("The new status for the task"),
-      task_id: z13.string().optional().describe("Child task ID to update. Omit to update the current task.")
+      task_id: z15.string().optional().describe("Child task ID to update. Omit to update the current task.")
     },
     async ({ status, task_id }) => {
       try {
@@ -9690,10 +10340,10 @@ function buildCreateFollowUpTaskTool(connection) {
     "create_follow_up_task",
     "Create a follow-up task that depends on the current task. The new card is a SIBLING of this one (same parent) and is blocked until this task merges \u2014 it is NOT a child of this card. To break this card into child cards that build as a pack, use create_subtask. For blockers use add_dependency.",
     {
-      title: z13.string().describe("Follow-up task title"),
-      description: z13.string().optional().describe(cardDescriptionDesc("Brief description of the follow-up work")),
-      plan: z13.string().optional().describe("Implementation plan if known"),
-      story_point_value: z13.number().optional().describe("Story point estimate (1=Common, 2=Magic, 3=Rare, 5=Unique)")
+      title: z15.string().describe("Follow-up task title"),
+      description: z15.string().optional().describe(cardDescriptionDesc("Brief description of the follow-up work")),
+      plan: z15.string().optional().describe("Implementation plan if known"),
+      story_point_value: z15.number().optional().describe("Story point estimate (1=Common, 2=Magic, 3=Rare, 5=Unique)")
     },
     async ({ title, description, plan, story_point_value }) => {
       try {
@@ -9720,11 +10370,11 @@ function buildCreateSuggestionTool(connection) {
     "create_suggestion",
     "Suggest a feature, improvement, rule, or idea for the project. Duplicates are deduped and your upvote is recorded. For actionable work on this task open a follow-up task.",
     {
-      title: z13.string().describe("Short title for the suggestion"),
-      description: z13.string().optional().describe(
+      title: z15.string().describe("Short title for the suggestion"),
+      description: z15.string().optional().describe(
         "1-2 sentence description of what should change and why. Keep concise and project-focused."
       ),
-      tag_names: z13.array(z13.string()).optional().describe("Tag names to categorize the suggestion")
+      tag_names: z15.array(z15.string()).optional().describe("Tag names to categorize the suggestion")
     },
     async ({ title, description, tag_names }) => {
       try {
@@ -9753,8 +10403,8 @@ function buildVoteSuggestionTool(connection) {
     "vote_suggestion",
     "Vote +1 or -1 on a project suggestion. Use to express support or disagreement with a specific suggestion returned by get_suggestions.",
     {
-      suggestion_id: z13.string().describe("The suggestion ID to vote on"),
-      value: z13.number().refine((v) => v === 1 || v === -1, { message: "Value must be 1 or -1" }).describe("+1 to upvote, -1 to downvote")
+      suggestion_id: z15.string().describe("The suggestion ID to vote on"),
+      value: z15.number().refine((v) => v === 1 || v === -1, { message: "Value must be 1 or -1" }).describe("+1 to upvote, -1 to downvote")
     },
     async ({ suggestion_id, value }) => {
       try {
@@ -10135,14 +10785,81 @@ function buildCommonTools(connection, config) {
 }
 
 // src/tools/pm-tools.ts
-import { z as z14 } from "zod";
+import { z as z16 } from "zod";
+
+// src/tools/task-update-tools.ts
+var CURRENT_TASK_ONLY = ["title", "description", "plan", "githubBranch"];
+function presentCurrentTaskFields(input) {
+  return CURRENT_TASK_ONLY.filter((key) => input[key] !== void 0);
+}
+function rejectionFor(input, present) {
+  if (input.task_id && present.length > 0) {
+    return `Cannot update ${present.join(", ")} on another task: task_id is only valid with status. Call update_task again without task_id to change the current task, and use a separate call with task_id to move the child.`;
+  }
+  if (present.length === 0 && input.status === void 0) {
+    return "No fields to update. Pass at least one of: title, description, plan, status, githubBranch.";
+  }
+  return null;
+}
+async function applyToCurrentTask(connection, input, applied) {
+  if (input.plan !== void 0 || input.description !== void 0) {
+    await connection.call("updateTaskFields", {
+      sessionId: connection.sessionId,
+      plan: input.plan,
+      description: input.description
+    });
+    if (input.plan !== void 0) applied.push("plan");
+    if (input.description !== void 0) applied.push("description");
+  }
+  if (input.title !== void 0 || input.githubBranch !== void 0) {
+    await connection.call("updateTaskProperties", {
+      sessionId: connection.sessionId,
+      title: input.title,
+      githubBranch: input.githubBranch
+    });
+    if (input.title !== void 0) applied.push("title");
+    if (input.githubBranch !== void 0) applied.push("githubBranch");
+  }
+  if (input.status !== void 0) {
+    await connection.call("updateTaskStatus", {
+      sessionId: connection.sessionId,
+      status: input.status
+    });
+    applied.push(`status: ${input.status}`);
+  }
+}
+function buildTaskUpdateTool(connection) {
+  return defineContractTool(updateTaskContract, async (input) => {
+    const rejection = rejectionFor(input, presentCurrentTaskFields(input));
+    if (rejection) return textResult(rejection);
+    const applied = [];
+    try {
+      if (input.task_id) {
+        await connection.call("updateChildStatus", {
+          sessionId: connection.sessionId,
+          childTaskId: input.task_id,
+          status: input.status
+        });
+        return textResult(`Child task ${input.task_id} status updated to ${input.status}.`);
+      }
+      await applyToCurrentTask(connection, input, applied);
+      return textResult(`Task updated \xB7 ${applied.join(", ")}`);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message : String(error);
+      const partial = applied.length > 0 ? ` Already applied: ${applied.join(", ")}.` : "";
+      return textResult(`Failed to update task: ${detail}.${partial}`);
+    }
+  });
+}
+
+// src/tools/pm-tools.ts
 function buildUpdateTaskTool(connection) {
   return defineTool(
     "update_task_plan",
     "Save the plan and/or description to the current task. In auto/building mode, save the plan BEFORE writing code and keep it current as the approach evolves \u2014 post it, then build; never pause the build waiting for approval. For children use update_subtask; for title/tags/PR use update_task_properties.",
     {
-      plan: z14.string().optional().describe("The task plan in markdown"),
-      description: z14.string().optional().describe(cardDescriptionDesc("Updated task description"))
+      plan: z16.string().optional().describe("The task plan in markdown"),
+      description: z16.string().optional().describe(cardDescriptionDesc("Updated task description"))
     },
     async ({ plan, description }) => {
       try {
@@ -10163,12 +10880,12 @@ function buildUpdateTaskTool(connection) {
 function buildHandoffTool(connection) {
   return defineTool(
     "handoff_to_agent",
-    "Hand this task off to an implementer agent for the build phase \u2014 mid-conversation, same session, no restart. Call this once the plan is compiled and saved (update_task_plan). The server swaps this task to the difficulty-sized implementer agent (which may run at a different model level), announces the handoff in the activity log + chat, and switches you into build mode to start implementing. Size the work with the storyPoints arg (or set it first via update_task_properties). Returns the implementer's name + model.",
+    "Hand this task off to an implementer agent for the build phase \u2014 mid-conversation, same session, no restart. Call this once the plan is compiled and saved (update_task). The server swaps this task to the difficulty-sized implementer agent (which may run at a different model level), announces the handoff in the activity log + chat, and switches you into build mode to start implementing. Size the work with the storyPoints arg (or set it first via update_task_properties). Returns the implementer's name + model.",
     {
-      storyPoints: z14.number().int().positive().optional().describe(
+      storyPoints: z16.number().int().positive().optional().describe(
         "Difficulty sizing (1=Common, 2=Magic, 3=Rare, 5=Unique, 8=Pack) \u2014 picks which implementer agent takes over. Omit to use the task's current story points."
       ),
-      message: z14.string().optional().describe("Optional kickoff note posted to the chat alongside the handoff notice.")
+      message: z16.string().optional().describe("Optional kickoff note posted to the chat alongside the handoff notice.")
     },
     async ({ storyPoints, message }) => {
       try {
@@ -10319,7 +11036,7 @@ function buildPackTools(connection) {
       "start_child_cloud_build",
       "Start a cloud build (codespace) for a child task. Preconditions: child status is `Open`, story points set, and an agent assigned \u2014 satisfy all three with update_subtask (status/agentIdOrName/storyPointValue) first; none happen automatically. A PACK_CHILD_LIMIT error is backpressure, not failure: check list_subtasks packSlots for which children hold the in-flight slots, merge/stop one, then retry. On a feature-branch pack, dev is merged into the pack branch first so the child branches from a fresh base; a conflict is reported in the result and never blocks the launch.",
       {
-        childTaskId: z14.string().describe("The child task ID to start a cloud build for")
+        childTaskId: z16.string().describe("The child task ID to start a cloud build for")
       },
       async ({ childTaskId }) => {
         try {
@@ -10348,7 +11065,7 @@ Base sync: dev \u2192 ${sync.branch} failed \u2014 ${sync.error}. The child was
       "stop_child_build",
       "Send a graceful stop signal to a running child build's agent. Not a force-kill \u2014 the agent may take a moment to wind down. Stopping a child eventually frees its PACK_CHILD_LIMIT build slot (see list_subtasks packSlots).",
       {
-        childTaskId: z14.string().describe("The child task ID whose build should be stopped")
+        childTaskId: z16.string().describe("The child task ID whose build should be stopped")
       },
       async ({ childTaskId }) => {
         try {
@@ -10389,6 +11106,13 @@ Base sync: dev \u2192 ${sync.branch} failed \u2014 ${sync.error}. The child was
 function buildPmTools(connection, options) {
   const tools = [
     buildUpdateTaskTool(connection),
+    // The shared-skill vocabulary alongside the split legacy tools above.
+    // Both stay REGISTERED, but the migration this comment used to defer has
+    // now happened (A2-5/A2-6): no prompt names `update_task_plan` any more, so
+    // it left ALWAYS_LOADED_TOOLS and is reachable via ToolSearch instead.
+    // `update_task_properties` deliberately stayed hot — it is the only pod tool
+    // carrying storyPointValue and risk, which ExitPlanMode requires.
+    buildTaskUpdateTool(connection),
     buildCreateSubtaskTool(connection),
     buildSetTaskParentTool(connection),
     buildUpdateSubtaskTool(connection),
@@ -10400,7 +11124,7 @@ function buildPmTools(connection, options) {
 }
 
 // src/tools/discovery-tools.ts
-import { z as z15 } from "zod";
+import { z as z17 } from "zod";
 var SP_DESCRIPTION2 = "Story point value (1=Common, 2=Magic, 3=Rare, 5=Unique). The key is 'storyPointValue' \u2014 not 'storyPoints'.";
 var VALID_PROPERTY_KEYS = "title, storyPointValue, tagNames, githubPRUrl, githubBranch, risk";
 function describeUpdatedFields(p) {
@@ -10419,12 +11143,12 @@ function buildDiscoveryTools(connection) {
       "update_task_properties",
       "Set one or more task properties in a single call. Valid keys: title, storyPointValue, tagNames, githubPRUrl, githubBranch, risk. All are optional \u2014 include only the ones you want to update (at least one). Unknown keys are rejected.",
       {
-        title: z15.string().optional().describe("The new task title"),
-        storyPointValue: z15.number().optional().describe(SP_DESCRIPTION2),
-        tagNames: z15.array(z15.string()).optional().describe("Array of tag names to assign"),
-        githubPRUrl: z15.string().url().optional().describe("GitHub pull request URL to link to this task"),
-        githubBranch: z15.string().optional().describe("Set the GitHub branch name for this task (e.g. 'conveyor/my-feature-abc123')"),
-        risk: z15.enum(["critical", "high", "medium", "low"]).nullable().optional().describe(
+        title: z17.string().optional().describe("The new task title"),
+        storyPointValue: z17.number().optional().describe(SP_DESCRIPTION2),
+        tagNames: z17.array(z17.string()).optional().describe("Array of tag names to assign"),
+        githubPRUrl: z17.string().url().optional().describe("GitHub pull request URL to link to this task"),
+        githubBranch: z17.string().optional().describe("Set the GitHub branch name for this task (e.g. 'conveyor/my-feature-abc123')"),
+        risk: z17.enum(["critical", "high", "medium", "low"]).nullable().optional().describe(
           "Risk level \u2014 how much important surface the task touches (critical/high/medium/low). Pass null to clear."
         )
       },
@@ -10464,7 +11188,7 @@ function buildDiscoveryTools(connection) {
 }
 
 // src/tools/project-tools.ts
-import { z as z16 } from "zod";
+import { z as z18 } from "zod";
 
 // src/execution/context-path-verifier.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -10542,16 +11266,16 @@ function formatContextPathProblems(problems) {
 }
 
 // src/tools/project-tools.ts
-var CONTEXT_PATH_SHAPE = z16.object({
-  type: z16.enum(["rule", "doc", "file", "folder"]).describe(
+var CONTEXT_PATH_SHAPE = z18.object({
+  type: z18.enum(["rule", "doc", "file", "folder"]).describe(
     "Link kind \u2014 all paths are repo-relative; doc marks a synced project doc, which resolves from the workspace like rule/file"
   ),
-  path: z16.string().min(1).max(500).describe("Repo-relative path"),
-  label: z16.string().max(100).optional(),
-  locator: z16.string().min(1).max(CONTEXT_LINK_LOCATOR_MAX).regex(/^[^\r\n]*$/, "Locator cannot contain line breaks").optional().describe(
+  path: z18.string().min(1).max(500).describe("Repo-relative path"),
+  label: z18.string().max(100).optional(),
+  locator: z18.string().min(1).max(CONTEXT_LINK_LOCATOR_MAX).regex(/^[^\r\n]*$/, "Locator cannot contain line breaks").optional().describe(
     'Verified-link tether: text that must keep existing in the file. With locatorType "test" it must appear inside a real it/test/describe TITLE; with "code" anywhere in the file. Validated at write time against the checkout and re-checked by the periodic sweep \u2014 a rename/delete flags the link stale. Locators containing <> are placeholders and never checked.'
   ),
-  locatorType: z16.enum(["test", "code"]).optional().describe("How the locator must match \u2014 required iff locator is set; not valid on folder links")
+  locatorType: z18.enum(["test", "code"]).optional().describe("How the locator must match \u2014 required iff locator is set; not valid on folder links")
 }).refine((link) => link.locator === void 0 === (link.locatorType === void 0), {
   message: "locator and locatorType must be provided together"
 }).refine((link) => link.locator === void 0 || link.type !== "folder", {
@@ -10598,15 +11322,15 @@ function buildCreateTagTool(connection, projectId, workspaceDir) {
     "create_tag",
     "Create a project tag. Include a crisp description (\u2264255 chars \u2014 the summary) and contextPaths (rule/doc/file/folder links agents auto-load when working on matching tasks); put the full spec in overview. Set parentTagIds to place the tag in the hierarchy right away. Every contextPath is checked against the repo checkout \u2014 a path that does not exist, or whose type does not match what is on disk, rejects the whole call. Fails if the name already exists.",
     {
-      name: z16.string().min(1).max(50),
-      color: z16.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe("#RRGGBB (default gray)"),
-      description: z16.string().max(TAG_DESCRIPTION_MAX).optional(),
-      overview: z16.string().max(TAG_OVERVIEW_MAX).optional().describe("Full markdown glossary body \u2014 the term's spec"),
-      overviewPath: z16.string().min(1).max(500).optional().describe(
+      name: z18.string().min(1).max(50),
+      color: z18.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe("#RRGGBB (default gray)"),
+      description: z18.string().max(TAG_DESCRIPTION_MAX).optional(),
+      overview: z18.string().max(TAG_OVERVIEW_MAX).optional().describe("Full markdown glossary body \u2014 the term's spec"),
+      overviewPath: z18.string().min(1).max(500).optional().describe(
         "Repo file to source the overview from (base-branch content is served everywhere). A not-yet-merged path is fine \u2014 the tag serves the stored overview as fallback until the file lands."
       ),
-      parentTagIds: z16.array(z16.string()).max(25).optional().describe("Parent tag ids from list_tags (multi-parent DAG) to link at create time"),
-      contextPaths: z16.array(CONTEXT_PATH_SHAPE).max(20).optional()
+      parentTagIds: z18.array(z18.string()).max(25).optional().describe("Parent tag ids from list_tags (multi-parent DAG) to link at create time"),
+      contextPaths: z18.array(CONTEXT_PATH_SHAPE).max(20).optional()
     },
     async ({ name, color, description, overview, overviewPath, parentTagIds, contextPaths }) => {
       const rejection = await rejectBadContextPaths(contextPaths, workspaceDir);
@@ -10634,19 +11358,19 @@ function buildUpdateTagTool(connection, projectId, taskId, workspaceDir) {
     "update_tag",
     "Update a tag's name, color, description (\u2264255), markdown overview, parent tags, or contextPaths. contextPaths and parentTagIds are FULL replacements \u2014 include what you want to keep. ALWAYS pass a short reason; it lands in the tag's revision history (with your current card auto-stamped) so the team sees why the glossary changed. Every contextPath is checked against the repo checkout \u2014 a path that does not exist, or whose type does not match what is on disk, rejects the whole call and nothing is written.",
     {
-      tagId: z16.string().describe("Tag id from list_tags"),
-      name: z16.string().min(1).max(50).optional(),
-      color: z16.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
-      description: z16.string().max(TAG_DESCRIPTION_MAX).optional(),
-      overview: z16.string().max(TAG_OVERVIEW_MAX).nullable().optional().describe(
+      tagId: z18.string().describe("Tag id from list_tags"),
+      name: z18.string().min(1).max(50).optional(),
+      color: z18.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
+      description: z18.string().max(TAG_DESCRIPTION_MAX).optional(),
+      overview: z18.string().max(TAG_OVERVIEW_MAX).nullable().optional().describe(
         "Full markdown glossary body; null clears it. REJECTED while overviewPath is set \u2014 edit the sourced file in the repo instead"
       ),
-      overviewPath: z16.string().min(1).max(500).nullable().optional().describe(
+      overviewPath: z18.string().min(1).max(500).nullable().optional().describe(
         "Repo file to source the overview from (null clears back to the stored overview). A not-yet-merged path is fine \u2014 the stored overview serves as fallback until the file lands on the base branch."
       ),
-      parentTagIds: z16.array(z16.string()).max(25).optional().describe("Full-set replacement of the tag's parent tags (multi-parent DAG)"),
-      reason: z16.string().max(TAG_REASON_MAX).optional().describe("One line on why \u2014 shown in the tag's revision history"),
-      contextPaths: z16.array(CONTEXT_PATH_SHAPE).max(20).optional()
+      parentTagIds: z18.array(z18.string()).max(25).optional().describe("Full-set replacement of the tag's parent tags (multi-parent DAG)"),
+      reason: z18.string().max(TAG_REASON_MAX).optional().describe("One line on why \u2014 shown in the tag's revision history"),
+      contextPaths: z18.array(CONTEXT_PATH_SHAPE).max(20).optional()
     },
     async ({
       tagId,
@@ -10704,8 +11428,8 @@ function buildPostToProjectChatTool(connection, projectId) {
     "post_to_project_chat",
     "Post a markdown message to the PROJECT chat \u2014 use once at the end of an audit for the summary the team reads.",
     {
-      message: z16.string().min(1).max(2e4),
-      kind: z16.enum(["tag_audit_summary"]).optional().describe(
+      message: z18.string().min(1).max(2e4),
+      kind: z18.enum(["tag_audit_summary"]).optional().describe(
         "Set to 'tag_audit_summary' when posting a tag-audit summary so it is also saved to the persistent tag history"
       )
     },
@@ -10724,7 +11448,7 @@ function buildGetProjectTaskTool(connection, projectId) {
     "get_project_task",
     "Fetch any task in the project by id or slug: title, description, plan, status, and metadata. The audit evidence trail starts here.",
     {
-      taskId: z16.string().describe("Task id or slug")
+      taskId: z18.string().describe("Task id or slug")
     },
     async ({ taskId }) => {
       try {
@@ -10742,8 +11466,8 @@ function buildReadProjectTaskChatTool(connection, projectId) {
     "read_project_task_chat",
     "Read any project task's chat messages (newest last). role 'user' rows are HUMAN turns; 'assistant'/'system' rows are agent posts and activity-log entries.",
     {
-      taskId: z16.string().describe("Task id or slug"),
-      limit: z16.number().int().min(1).max(200).optional().describe("Messages to fetch (default 50)")
+      taskId: z18.string().describe("Task id or slug"),
+      limit: z18.number().int().min(1).max(200).optional().describe("Messages to fetch (default 50)")
     },
     async ({ taskId, limit }) => {
       try {
@@ -10765,9 +11489,9 @@ function buildGetProjectTaskLogsTool(connection, projectId) {
     "get_project_task_logs",
     "Read any project task's persisted agent event stream (message / tool_use / turn_end / error / completed). Turn boundaries are turn_end events. Entries are truncated to ~2KB each; max 500 per call.",
     {
-      taskId: z16.string().describe("Task id or slug"),
-      limit: z16.number().int().min(1).max(500).optional().describe("Entries to fetch (default 50)"),
-      source: z16.enum(["agent", "application"]).optional().describe("Filter: 'agent' = model events (default useful for grading)")
+      taskId: z18.string().describe("Task id or slug"),
+      limit: z18.number().int().min(1).max(500).optional().describe("Entries to fetch (default 50)"),
+      source: z18.enum(["agent", "application"]).optional().describe("Filter: 'agent' = model events (default useful for grading)")
     },
     async ({ taskId, limit, source }) => {
       try {
@@ -10785,44 +11509,44 @@ function buildGetProjectTaskLogsTool(connection, projectId) {
     { annotations: { readOnlyHint: true } }
   );
 }
-var TURN_GRADE_SHAPE = z16.object({
-  turnIndex: z16.number().int().min(0),
-  phase: z16.enum(["planning", "building", "human"]),
-  grade: z16.enum(["correct", "neutral", "blunder"]),
-  reasoning: z16.string(),
-  eventType: z16.string().describe('e.g. "message", "tool_use", "human_message"'),
-  eventSummary: z16.string().max(200).describe("\u2264120 chars of what happened this turn")
+var TURN_GRADE_SHAPE = z18.object({
+  turnIndex: z18.number().int().min(0),
+  phase: z18.enum(["planning", "building", "human"]),
+  grade: z18.enum(["correct", "neutral", "blunder"]),
+  reasoning: z18.string(),
+  eventType: z18.string().describe('e.g. "message", "tool_use", "human_message"'),
+  eventSummary: z18.string().max(200).describe("\u2264120 chars of what happened this turn")
 });
-var HUMAN_EVAL_SHAPE = z16.object({
-  messageIndex: z16.number().int().min(0).describe("Index into the task's human messages, oldest first"),
-  rating: z16.number().int().min(-1).max(1),
-  reasoning: z16.string()
+var HUMAN_EVAL_SHAPE = z18.object({
+  messageIndex: z18.number().int().min(0).describe("Index into the task's human messages, oldest first"),
+  rating: z18.number().int().min(-1).max(1),
+  reasoning: z18.string()
 });
 function buildReportTaskAuditResultTool(connection, projectId) {
   return defineTool(
     "report_task_audit_result",
     "Persist one audited task's grades (call once per task after grading it). Pass error instead to mark the audit failed when the evidence is unusable.",
     {
-      taskId: z16.string().describe("The audited task's id (NOT slug)"),
-      summary: z16.string().describe("3-6 sentences: what went well, what was wasted"),
-      turnGrades: z16.array(TURN_GRADE_SHAPE),
-      planningAccuracy: z16.number().min(0).max(1).nullable(),
-      buildingAccuracy: z16.number().min(0).max(1).nullable(),
-      humanAccuracy: z16.number().min(0).max(1).nullable(),
-      planningCorrect: z16.number().int().min(0),
-      planningNeutral: z16.number().int().min(0),
-      planningBlunder: z16.number().int().min(0),
-      buildingCorrect: z16.number().int().min(0),
-      buildingNeutral: z16.number().int().min(0),
-      buildingBlunder: z16.number().int().min(0),
-      humanCorrect: z16.number().int().min(0),
-      humanNeutral: z16.number().int().min(0),
-      humanBlunder: z16.number().int().min(0),
-      humanEvaluations: z16.array(HUMAN_EVAL_SHAPE).optional(),
-      suggestionIds: z16.array(z16.string()).describe("Suggestion ids filed for this task, or []"),
-      auditCostUsd: z16.number().nullable(),
-      model: z16.string().nullable().describe("The model you are running as"),
-      error: z16.string().optional().describe("Set ONLY to mark this task's audit failed")
+      taskId: z18.string().describe("The audited task's id (NOT slug)"),
+      summary: z18.string().describe("3-6 sentences: what went well, what was wasted"),
+      turnGrades: z18.array(TURN_GRADE_SHAPE),
+      planningAccuracy: z18.number().min(0).max(1).nullable(),
+      buildingAccuracy: z18.number().min(0).max(1).nullable(),
+      humanAccuracy: z18.number().min(0).max(1).nullable(),
+      planningCorrect: z18.number().int().min(0),
+      planningNeutral: z18.number().int().min(0),
+      planningBlunder: z18.number().int().min(0),
+      buildingCorrect: z18.number().int().min(0),
+      buildingNeutral: z18.number().int().min(0),
+      buildingBlunder: z18.number().int().min(0),
+      humanCorrect: z18.number().int().min(0),
+      humanNeutral: z18.number().int().min(0),
+      humanBlunder: z18.number().int().min(0),
+      humanEvaluations: z18.array(HUMAN_EVAL_SHAPE).optional(),
+      suggestionIds: z18.array(z18.string()).describe("Suggestion ids filed for this task, or []"),
+      auditCostUsd: z18.number().nullable(),
+      model: z18.string().nullable().describe("The model you are running as"),
+      error: z18.string().optional().describe("Set ONLY to mark this task's audit failed")
     },
     async (input) => {
       try {
@@ -10879,21 +11603,13 @@ function buildProjectTools(connection, projectId, workspaceDir) {
 }
 
 // src/tools/drive-tools.ts
-import { z as z17 } from "zod";
-var MAX_CONTENT_CHARS = 1e6;
 var MAX_READ_CHARS = 1e5;
 function errText2(prefix, error) {
   return textResult(`${prefix}: ${error instanceof Error ? error.message : "Unknown error"}`);
 }
 function buildDriveListFilesTool(connection, projectId) {
-  return defineTool(
-    "drive_list_files",
-    "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.",
-    {
-      folderId: z17.string().optional().describe("Folder to list. Defaults to the project's connected root folder."),
-      search: z17.string().max(200).optional().describe("Only return names containing this text"),
-      limit: z17.number().int().min(1).max(200).optional().describe("Max entries (default 100)")
-    },
+  return defineContractTool(
+    driveListFilesContract,
     async ({ folderId, search, limit }) => {
       try {
         const result = await connection.call("listProjectDriveFiles", {
@@ -10911,10 +11627,8 @@ function buildDriveListFilesTool(connection, projectId) {
   );
 }
 function buildDriveReadFileTool(connection, projectId) {
-  return defineTool(
-    "drive_read_file",
-    "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.",
-    { fileId: z17.string().describe("Drive file id, as returned by drive_list_files") },
+  return defineContractTool(
+    driveReadFileContract,
     async ({ fileId }) => {
       try {
         const result = await connection.call("readProjectDriveFile", { projectId, fileId });
@@ -10936,15 +11650,8 @@ ${content}`);
   );
 }
 function buildDriveCreateFileTool(connection, projectId) {
-  return defineTool(
-    "drive_create_file",
-    "Create a new file in the project's connected Google Drive folder. Use drive_update_file to change an existing file instead.",
-    {
-      name: z17.string().min(1).max(255).describe("File name, without any path separators"),
-      content: z17.string().max(MAX_CONTENT_CHARS).describe("File content, UTF-8 text"),
-      mimeType: z17.string().optional().describe("MIME type (default text/plain)"),
-      folderId: z17.string().optional().describe("Destination folder. Defaults to the project's connected root folder.")
-    },
+  return defineContractTool(
+    driveCreateFileContract,
     async ({ name, content, mimeType, folderId }) => {
       try {
         const file = await connection.call("createProjectDriveFile", {
@@ -10962,14 +11669,8 @@ function buildDriveCreateFileTool(connection, projectId) {
   );
 }
 function buildDriveUpdateFileTool(connection, projectId) {
-  return defineTool(
-    "drive_update_file",
-    "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.",
-    {
-      fileId: z17.string().describe("Drive file id, as returned by drive_list_files"),
-      content: z17.string().max(MAX_CONTENT_CHARS).describe("Replacement content, UTF-8 text"),
-      mimeType: z17.string().optional().describe("MIME type (defaults to the file's current type)")
-    },
+  return defineContractTool(
+    driveUpdateFileContract,
     async ({ fileId, content, mimeType }) => {
       try {
         const file = await connection.call("updateProjectDriveFile", {
@@ -10986,10 +11687,8 @@ function buildDriveUpdateFileTool(connection, projectId) {
   );
 }
 function buildDriveDeleteFileTool(connection, projectId) {
-  return defineTool(
-    "drive_delete_file",
-    "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.",
-    { fileId: z17.string().describe("Drive file id, as returned by drive_list_files") },
+  return defineContractTool(
+    driveDeleteFileContract,
     async ({ fileId }) => {
       try {
         const result = await connection.call("deleteProjectDriveFile", { projectId, fileId });
@@ -11001,13 +11700,8 @@ function buildDriveDeleteFileTool(connection, projectId) {
   );
 }
 function buildDriveCreateFolderTool(connection, projectId) {
-  return defineTool(
-    "drive_create_folder",
-    "Create a folder inside the project's connected Google Drive folder.",
-    {
-      name: z17.string().min(1).max(255).describe("Folder name, without any path separators"),
-      folderId: z17.string().optional().describe("Parent folder. Defaults to the project's connected root folder.")
-    },
+  return defineContractTool(
+    driveCreateFolderContract,
     async ({ name, folderId }) => {
       try {
         const folder = await connection.call("createProjectDriveFolder", {
@@ -11033,10 +11727,209 @@ function buildDriveTools(connection, projectId) {
   ];
 }
 
+// src/tools/integration-tools.ts
+function errText3(prefix, error) {
+  return textResult(`${prefix}: ${error instanceof Error ? error.message : "Unknown error"}`);
+}
+function buildListProjectIntegrationsTool(connection, projectId) {
+  return defineContractTool(listProjectIntegrationsContract, async () => {
+    try {
+      const res = await connection.call("listProjectIntegrations", { projectId });
+      return textResult(JSON.stringify(res, null, 2));
+    } catch (error) {
+      return errText3("Failed to list integrations", error);
+    }
+  });
+}
+function buildListProjectChannelsTool(connection, projectId) {
+  return defineContractTool(listProjectChannelsContract, async () => {
+    try {
+      const channels = await connection.call("listProjectChannels", { projectId });
+      if (channels.length === 0) {
+        return textResult(
+          "No work channels are registered for this project. An admin registers them in project settings; until then no channel is readable, whatever the bot can see in the workspace."
+        );
+      }
+      return textResult(JSON.stringify(channels, null, 2));
+    } catch (error) {
+      return errText3("Failed to list work channels", error);
+    }
+  });
+}
+function buildReadChannelMessagesTool(connection, projectId) {
+  return defineContractTool(readChannelMessagesContract, async (input) => {
+    try {
+      const res = await connection.call("readChannelMessages", {
+        projectId,
+        channelId: input.channelId,
+        limit: input.limit,
+        before: input.before,
+        after: input.after,
+        threadTs: input.threadTs
+      });
+      return textResult(JSON.stringify(res, null, 2));
+    } catch (error) {
+      return errText3("Failed to read channel messages", error);
+    }
+  });
+}
+function buildPostChannelMessageTool(connection, projectId) {
+  return defineContractTool(postChannelMessageContract, async (input) => {
+    try {
+      const res = await connection.call("postChannelMessage", {
+        projectId,
+        channelId: input.channelId,
+        text: input.text,
+        threadTs: input.threadTs
+      });
+      return textResult(`Posted to ${res.channelId} (message ${res.messageId}).`);
+    } catch (error) {
+      return errText3("Failed to post to channel", error);
+    }
+  });
+}
+function buildAnalyticsSummaryTool(connection, projectId) {
+  return defineContractTool(getAnalyticsSummaryContract, async (input) => {
+    try {
+      const res = await connection.call("getProjectAnalyticsSummary", {
+        projectId,
+        rangeDays: input.rangeDays,
+        campaign: input.campaign
+      });
+      if (!res.configured) {
+        return textResult(res.message ?? "Google Analytics is not configured for this project.");
+      }
+      return textResult(JSON.stringify(res, null, 2));
+    } catch (error) {
+      return errText3("Failed to read the analytics summary", error);
+    }
+  });
+}
+function buildChannelTools(connection, projectId) {
+  return [
+    buildListProjectChannelsTool(connection, projectId),
+    buildReadChannelMessagesTool(connection, projectId),
+    buildPostChannelMessageTool(connection, projectId)
+  ];
+}
+
+// src/tools/log-tools.ts
+function portsFor(connection, projectId) {
+  return {
+    queryGcpLogs: (params) => connection.call("queryProjectGcpLogs", { ...params, projectId }),
+    queryGrafanaLogs: (params) => connection.call("queryProjectGrafanaLogs", { ...params, projectId })
+  };
+}
+function buildQueryGcpLogsTool(connection, projectId) {
+  return defineContractTool(queryGcpLogsContract, async (input) => {
+    try {
+      return textResult(await runQueryGcpLogs(portsFor(connection, projectId), input));
+    } catch (error) {
+      return textResult(
+        `Failed to query GCP logs: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  });
+}
+function buildQueryGrafanaLogsTool(connection, projectId) {
+  return defineContractTool(queryGrafanaLogsContract, async (input) => {
+    try {
+      return textResult(await runQueryGrafanaLogs(portsFor(connection, projectId), input));
+    } catch (error) {
+      return textResult(
+        `Failed to query Grafana logs: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  });
+}
+
+// src/tools/meeting-tools.ts
+function errText4(prefix, error) {
+  return textResult(`${prefix}: ${error instanceof Error ? error.message : "Unknown error"}`);
+}
+function buildMeetingTools(connection, projectId) {
+  return [
+    defineContractTool(
+      listMeetingsContract,
+      async (input) => {
+        try {
+          const res = await connection.call("listMeetings", {
+            projectId,
+            limit: input.limit,
+            search: input.search
+          });
+          if (res.meetings.length === 0) {
+            return textResult(
+              input.search ? `No meetings match "${input.search}". Try list_meetings with no search to see what exists.` : "This project has no meetings yet. They are added by pasting a transcript in the Meetings tab, or from Slack."
+            );
+          }
+          return textResult(JSON.stringify(res.meetings, null, 2));
+        } catch (error) {
+          return errText4("Failed to list meetings", error);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    defineContractTool(
+      getMeetingContract,
+      async (input) => {
+        try {
+          const res = await connection.call("getMeeting", {
+            projectId,
+            meetingId: input.meetingId
+          });
+          return textResult(JSON.stringify(res, null, 2));
+        } catch (error) {
+          return errText4("Failed to read the meeting", error);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    defineContractTool(
+      readMeetingTranscriptContract,
+      async (input) => {
+        try {
+          const res = await connection.call("readMeetingTranscript", {
+            projectId,
+            meetingId: input.meetingId,
+            offset: input.offset,
+            limit: input.limit
+          });
+          const header = `${res.title} \u2014 segments ${res.offset + 1}-${res.offset + res.lines.length} of ${res.segmentCount}`;
+          const footer = res.nextOffset === void 0 ? "" : `
+
+-- more remains: pass offset=${res.nextOffset} to continue`;
+          return textResult(`${header}
+
+${res.lines.join("\n")}${footer}`);
+        } catch (error) {
+          return errText4("Failed to read the transcript", error);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    )
+  ];
+}
+
+// src/tools/connected-tools.ts
+function connectedToolsFor(connection, context) {
+  const projectId = context?.projectId;
+  if (!projectId) return [];
+  return [
+    ...context.googleDriveConnected ? buildDriveTools(connection, projectId) : [],
+    buildListProjectIntegrationsTool(connection, projectId),
+    ...context.chatChannelsConfigured ? buildChannelTools(connection, projectId) : [],
+    ...context.meetingsAvailable ? buildMeetingTools(connection, projectId) : [],
+    ...context.googleAnalyticsConfigured ? [buildAnalyticsSummaryTool(connection, projectId)] : [],
+    ...context.gcpLogsConfigured ? [buildQueryGcpLogsTool(connection, projectId)] : [],
+    ...context.grafanaLogsConfigured ? [buildQueryGrafanaLogsTool(connection, projectId)] : []
+  ];
+}
+
 // src/tools/code-review-tools.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 async function endReviewSession(connection, reason) {
   await connection.call("endReviewSession", {
     sessionId: connection.sessionId,
@@ -11044,26 +11937,26 @@ async function endReviewSession(connection, reason) {
   });
 }
 var RISK_LEVELS2 = ["critical", "high", "medium", "low"];
-var reviewedShaSchema = z18.string().regex(/^[0-9a-f]{40}$/i).describe("REQUIRED. The full 40-character commit SHA this verdict reviews.");
+var reviewedShaSchema = z19.string().regex(/^[0-9a-f]{40}$/i).describe("REQUIRED. The full 40-character commit SHA this verdict reviews.");
 var riskDescription = "REQUIRED. The risk level this change carries, judged by the surface area it touches: critical = touches critical/foundational surface, high = important surface, medium = moderate, low = small/isolated. Set this on every verdict. You have authority to override a risk level already set on the task if you disagree with it.";
-var ReviewGuideToolSchema = z18.strictObject({
-  reviewedSha: z18.string().regex(/^[0-9a-f]{40}$/i).describe(
+var ReviewGuideToolSchema = z19.strictObject({
+  reviewedSha: z19.string().regex(/^[0-9a-f]{40}$/i).describe(
     "REQUIRED. The PR's current head as a full 40-char SHA. Run `git rev-parse HEAD` immediately before this call \u2014 never extend an abbreviated hash into 40 characters."
   ),
-  overview: z18.string().min(1).max(6e4).describe("REQUIRED. Plain-text walkthrough intro, max 3000 characters. Keep it short."),
-  sections: z18.array(
-    z18.strictObject({
-      title: z18.string().min(1).max(160),
-      explanation: z18.string().min(1).max(2e3),
-      classification: z18.enum(["core", "supporting"]).optional(),
-      files: z18.array(
-        z18.strictObject({
-          path: z18.string().min(1).max(500).describe(
+  overview: z19.string().min(1).max(6e4).describe("REQUIRED. Plain-text walkthrough intro, max 3000 characters. Keep it short."),
+  sections: z19.array(
+    z19.strictObject({
+      title: z19.string().min(1).max(160),
+      explanation: z19.string().min(1).max(2e3),
+      classification: z19.enum(["core", "supporting"]).optional(),
+      files: z19.array(
+        z19.strictObject({
+          path: z19.string().min(1).max(500).describe(
             "A file the PR's diff actually changed. Context files you merely read are rejected."
           ),
-          startLine: z18.number().int().positive().max(1e6).optional(),
-          endLine: z18.number().int().positive().max(1e6).optional(),
-          hunkHeader: z18.string().min(1).max(300).optional().describe(
+          startLine: z19.number().int().positive().max(1e6).optional(),
+          endLine: z19.number().int().positive().max(1e6).optional(),
+          hunkHeader: z19.string().min(1).max(300).optional().describe(
             "Optional anchor, matched byte-exactly against the full hunk header line from `git diff` INCLUDING the context text after the second @@. Copy it verbatim from `git diff <base>..HEAD -- <file> | grep '^@@'`, or omit anchors entirely (path-only entries always validate)."
           )
         })
@@ -11147,8 +12040,8 @@ function buildApproveCodeReviewTool(connection) {
     "Approve the code review and exit. Use when the diff passes all review criteria. Requires a summary and a risk level \u2014 for changes, use request_code_changes with a structured issues[] list.",
     {
       reviewedSha: reviewedShaSchema,
-      summary: z18.string().describe("Brief summary of what was reviewed and why it looks good"),
-      risk: z18.enum(RISK_LEVELS2).describe(riskDescription)
+      summary: z19.string().describe("Brief summary of what was reviewed and why it looks good"),
+      risk: z19.enum(RISK_LEVELS2).describe(riskDescription)
     },
     async ({ reviewedSha, summary, risk }) => {
       const content = `**Code Review: Approved** :white_check_mark:
@@ -11179,16 +12072,16 @@ function buildRequestCodeChangesTool(connection) {
     "Request changes during code review and exit. Use when substantive issues must be fixed before merge. Each issue: { file, line?, severity: critical|major|minor, description }.",
     {
       reviewedSha: reviewedShaSchema,
-      issues: z18.array(
-        z18.object({
-          file: z18.string().describe("File path where the issue was found"),
-          line: z18.number().optional().describe("Line number (if applicable)"),
-          severity: z18.enum(["critical", "major", "minor"]).describe("Issue severity"),
-          description: z18.string().describe("What is wrong and how to fix it")
+      issues: z19.array(
+        z19.object({
+          file: z19.string().describe("File path where the issue was found"),
+          line: z19.number().optional().describe("Line number (if applicable)"),
+          severity: z19.enum(["critical", "major", "minor"]).describe("Issue severity"),
+          description: z19.string().describe("What is wrong and how to fix it")
         })
       ).describe("List of issues found during review"),
-      summary: z18.string().describe("Brief overall summary of the review findings"),
-      risk: z18.enum(RISK_LEVELS2).describe(riskDescription)
+      summary: z19.string().describe("Brief overall summary of the review findings"),
+      risk: z19.enum(RISK_LEVELS2).describe(riskDescription)
     },
     async ({ reviewedSha, issues, summary, risk }) => {
       const issueLines = issues.map((issue) => {
@@ -11237,26 +12130,30 @@ function getTaskModeTools(agentMode, connection) {
 }
 function getModeTools(agentMode, connection, config, context) {
   if (config.mode === "pack") {
-    return buildPmTools(connection, { includePackTools: true });
+    return buildPmTools(connection, {
+      includePackTools: config.packExecution === "fan-out"
+    });
   }
   if (config.mode === "task") return getTaskModeTools(agentMode, connection);
+  const packToolsFor = (isParent) => ({
+    includePackTools: !!isParent && config.packExecution === "fan-out"
+  });
   switch (agentMode) {
     case "building":
-      return context?.isParentTask ? buildPmTools(connection, { includePackTools: true }) : [];
+      return context?.isParentTask ? buildPmTools(connection, packToolsFor(true)) : [];
     case "review":
     case "auto":
     case "discovery":
     case "help":
-      return buildPmTools(connection, {
-        includePackTools: !!context?.isParentTask
-      });
+      return buildPmTools(connection, packToolsFor(context?.isParentTask));
     default:
       return config.mode === "pm" ? buildPmTools(connection, { includePackTools: false }) : [];
   }
 }
 function buildPrGuideToolsFor(effectiveMode, connection, config, context) {
   const isLeafBuild = effectiveMode === "building" || effectiveMode === "auto";
-  return isLeafBuild && !context?.isParentTask ? [
+  const isSinglePodPack = config.mode === "pack" && config.packExecution !== "fan-out";
+  return (isLeafBuild || isSinglePodPack) && (isSinglePodPack || !context?.isParentTask) ? [
     buildPublishReviewGuideTool(connection, {
       resolveHeadSha: () => resolveGitHeadSha(config.workspaceDir)
     })
@@ -11268,11 +12165,30 @@ var ALWAYS_LOADED_TOOLS = /* @__PURE__ */ new Set([
   "read_task_chat",
   "get_task",
   "get_current_plan",
+  // The identity call the shared skills open with. Its schema is empty, so it
+  // is the cheapest possible entry here, and deferring it would put a
+  // ToolSearch round trip in front of the FIRST call of every skill run.
+  "get_connection_context",
   "set_manual_tests",
   "create_pull_request",
-  // Planning/auto/building
-  "update_task_plan",
+  // Planning/auto/building.
+  //
+  // A2-6, executed HALFWAY on purpose. The note here used to say the split pair
+  // should leave this set once the prompts stopped naming them. `update_task`
+  // has now replaced every `update_task_plan` reference in the prompts, so that
+  // one is gone from the always-loaded set — it stays REGISTERED, just not hot.
+  //
+  // `update_task_properties` does NOT leave, and the plan that asked for the
+  // pair to go was wrong about it: `update_task`'s agent surface deliberately
+  // omits `storyPointValue` and `risk` (see tool-contracts/task-update.ts), and
+  // this is the only pod tool that carries them. Discovery's ExitPlanMode gate
+  // fails until the card has story points, risk AND a title, so dropping this
+  // would leave the one mode that must set them with no tool that can — the
+  // unfollowable-instruction defect, manufactured deliberately.
   "update_task_properties",
+  // The shared-skill card write: one name whose fields match the mcp surface,
+  // so a single skill text drives a local session and a pod verbatim.
+  "update_task",
   // Building/auto — the PR guide is published as part of opening the PR
   "publish_review_guide",
   // Review mode
@@ -11298,12 +12214,9 @@ var PACK_PROMOTED_TOOLS = /* @__PURE__ */ new Set(["get_execution_logs"]);
 function glossaryToolsFor(connection, config, context) {
   return context?.projectId ? buildGlossaryTools(connection, context.projectId, config.taskId, config.workspaceDir) : [];
 }
-function driveToolsFor(connection, context) {
-  return context?.projectId && context.googleDriveConnected ? buildDriveTools(connection, context.projectId) : [];
-}
-function promotedToolsFor(effectiveMode, isPack, isProjectAgent) {
+function promotedToolsFor(effectiveMode, isPack, isProjectAgent, isSinglePodPack = false) {
   const names = /* @__PURE__ */ new Set();
-  if (effectiveMode === "building" || effectiveMode === "auto") {
+  if (effectiveMode === "building" || effectiveMode === "auto" || isSinglePodPack) {
     for (const name of BUILDING_PROMOTED_TOOLS) names.add(name);
   }
   if (effectiveMode === "review") {
@@ -11332,7 +12245,7 @@ function buildConveyorTools(connection, config, context, agentMode) {
   const handoffTools = config.mode === "pm" && (effectiveMode === "discovery" || effectiveMode === "auto") ? [buildHandoffTool(connection)] : [];
   const emergencyTools = [buildForceUpdateTaskStatusTool(connection)];
   const glossaryTools = glossaryToolsFor(connection, config, context);
-  const driveTools = driveToolsFor(connection, context);
+  const connectedTools = connectedToolsFor(connection, context);
   const isPack = config.mode === "pack" || Boolean(context?.isParentTask);
   return withAlwaysLoad(
     [
@@ -11343,10 +12256,15 @@ function buildConveyorTools(connection, config, context, agentMode) {
       ...prGuideTools,
       ...handoffTools,
       ...glossaryTools,
-      ...driveTools,
+      ...connectedTools,
       ...emergencyTools
     ],
-    promotedToolsFor(effectiveMode, isPack, config.mode === "pm")
+    promotedToolsFor(
+      effectiveMode,
+      isPack,
+      config.mode === "pm",
+      config.mode === "pack" && config.packExecution !== "fan-out"
+    )
   );
 }
 function createConveyorMcpServer(harness, connection, config, context, agentMode) {
@@ -11835,7 +12753,7 @@ function fallbackResetIso(rateLimitType, now = Date.now()) {
 // src/execution/task-property-utils.ts
 function collectMissingProps(taskProps) {
   const missing = [];
-  if (!taskProps.plan?.trim()) missing.push("plan (save via update_task_plan)");
+  if (!taskProps.plan?.trim()) missing.push("plan (save via update_task)");
   if (!taskProps.storyPointId) missing.push("story points (use update_task_properties)");
   if (!taskProps.title || taskProps.title === "Untitled")
     missing.push("title (use update_task_properties)");
@@ -12013,7 +12931,12 @@ function matchesReadOnlyBlocked(cmd) {
   }
   return null;
 }
+var POST_CHANNEL_TOOL = /(^|__)post_channel_message$/;
+var CHANNEL_POST_DENIED = "Posting into a chat channel is not available in this mode. Reading channels still is \u2014 use read_channel_messages if you need the discussion.";
 function handleReadOnlyToolAccess(toolName, input) {
+  if (POST_CHANNEL_TOOL.test(toolName)) {
+    return { behavior: "deny", message: CHANNEL_POST_DENIED };
+  }
   if (PM_PLAN_FILE_TOOLS.has(toolName)) {
     if (isPlanFile(input)) {
       return { behavior: "allow", updatedInput: input };
@@ -12056,13 +12979,16 @@ function handleBuildingToolAccess(toolName, input) {
   return { behavior: "allow", updatedInput: input };
 }
 function handleReviewToolAccess(toolName, input) {
+  if (POST_CHANNEL_TOOL.test(toolName)) {
+    return { behavior: "deny", message: CHANNEL_POST_DENIED };
+  }
   return handleBuildingToolAccess(toolName, input);
 }
 var CHAT_BLOCKED_BASH = /\bgit\s+push\b|\bgh\s+pr\b|\bhub\s+pull-request\b/;
 var CREATE_PR_TOOL = /(^|__)create_pull_request$/;
 var CHAT_PLAN_GATE_MESSAGE = [
   "This chat card has no saved plan, so it has no PR path yet.",
-  "If the conversation has turned into a development task, save a plan with update_task_plan first \u2014 that identifies the card and moves it to In Progress \u2014 then commit, push, and open the PR.",
+  "If the conversation has turned into a development task, save a plan with update_task first \u2014 that identifies the card and moves it to In Progress \u2014 then commit, push, and open the PR.",
   "If it is still a conversation, deliver the work by attaching files to the card with upload_attachment instead."
 ].join(" ");
 function isChatPrTool(toolName, input) {
@@ -12092,7 +13018,7 @@ function enforceMissingProps(host, input, missingProps) {
         "Cannot exit plan mode. Required task properties are missing:",
         ...missingProps.map((p) => `- ${p}`),
         "",
-        "Fill these in using MCP tools (e.g. update_task_plan, update_task_properties), then call ExitPlanMode again.",
+        "Fill these in using MCP tools (e.g. update_task, update_task_properties), then call ExitPlanMode again.",
         "",
         "If you have a deliberate reason to proceed without them, you must explicitly bypass validation by calling ExitPlanMode with `bypassValidation: true` as a tool argument. Do not bypass unless the team has asked you to \u2014 it will be surfaced in chat."
       ].join("\n")
@@ -12510,7 +13436,7 @@ async function buildFollowUpPrompt(host, context, followUpContent) {
   const followUpImages = typeof followUpContent === "string" ? [] : followUpContent.filter(
     (b) => b.type === "image"
   );
-  const textPrompt = isPmMode ? `${await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode)}
+  const textPrompt = isPmMode ? `${await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode, host.config.packExecution)}
 
 ---
 
@@ -12707,7 +13633,8 @@ async function runPrefilledFollowUp(host, context, options, resume, followUpCont
       host.config.mode,
       context,
       host.isAuto,
-      host.agentMode
+      host.agentMode,
+      host.config.packExecution
     );
     queryOptions.appendSystemPrompt = [queryOptions.appendSystemPrompt, initialPrompt].filter(Boolean).join("\n\n").slice(0, APPEND_SYSTEM_PROMPT_MAX_CHARS);
   }
@@ -12778,7 +13705,8 @@ async function runInitialQuery(host, context, options, resume, promptDelivery) {
     host.config.mode,
     context,
     host.isAuto,
-    host.agentMode
+    host.agentMode,
+    host.config.packExecution
   );
   const { prompt, appendSystemPrompt } = selectInitialPromptInput(
     promptDelivery,
@@ -12808,7 +13736,13 @@ async function buildRetryQuery(host, context, options, lastErrorWasImage) {
     );
   }
   const retryPrompt = buildMultimodalPrompt(
-    await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
+    await buildInitialPrompt(
+      host.config.mode,
+      context,
+      host.isAuto,
+      host.agentMode,
+      host.config.packExecution
+    ),
     context,
     lastErrorWasImage || !supportsImageBlocks(host.harnessKind)
   );
@@ -12837,7 +13771,13 @@ async function handleAuthError(context, host, options) {
   context.claudeSessionId = null;
   host.connection.storeSessionId("");
   const freshPrompt = buildMultimodalPrompt(
-    await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
+    await buildInitialPrompt(
+      host.config.mode,
+      context,
+      host.isAuto,
+      host.agentMode,
+      host.config.packExecution
+    ),
     context,
     !supportsImageBlocks(host.harnessKind)
   );
@@ -12852,7 +13792,13 @@ async function handleStaleSession(context, host, options) {
   context.claudeSessionId = null;
   host.connection.storeSessionId("");
   const freshPrompt = buildMultimodalPrompt(
-    await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
+    await buildInitialPrompt(
+      host.config.mode,
+      context,
+      host.isAuto,
+      host.agentMode,
+      host.config.packExecution
+    ),
     context,
     !supportsImageBlocks(host.harnessKind)
   );
@@ -12946,7 +13892,13 @@ async function handleUsageCapRejection(context, host, options, rateLimitType, re
   context.claudeSessionId = null;
   host.connection.storeSessionId("");
   const freshPrompt = buildMultimodalPrompt(
-    await buildInitialPrompt(host.config.mode, context, host.isAuto, host.agentMode),
+    await buildInitialPrompt(
+      host.config.mode,
+      context,
+      host.isAuto,
+      host.agentMode,
+      host.config.packExecution
+    ),
     context,
     !supportsImageBlocks(host.harnessKind)
   );
@@ -13778,9 +14730,20 @@ var BackgroundWorkTracker = class {
   }
 };
 
+// src/runner/live-children.ts
+function findLiveChild(sources) {
+  for (const source of sources) {
+    for (const sessionId of source.activeSessionIds()) {
+      if (sessionId) return { kind: source.kind, sessionId };
+    }
+  }
+  return null;
+}
+
 // src/runner/session-runner.ts
 var AUTO_RUN_MODES = /* @__PURE__ */ new Set(["building", "auto", "review", "discovery", "chat"]);
 var AUTONOMOUS_RUNNER_MODES = /* @__PURE__ */ new Set(["pack", "pm", "code-review"]);
+var CHILD_DEFER_RECHECK_MS = 60 * 1e3;
 var SessionRunner = class _SessionRunner {
   connection;
   mode;
@@ -13852,6 +14815,7 @@ var SessionRunner = class _SessionRunner {
         this.connection.sendHeartbeat(this.loopLag.takeMaxLagMs(), loopStatus);
       },
       onIdleTimeout: () => {
+        if (this.deferShutdownForLiveChild("idle")) return;
         process.stderr.write("[conveyor-agent] Idle timeout reached, stopping agent\n");
         this.stopped = true;
         this.queryBridge?.stop();
@@ -13862,6 +14826,7 @@ var SessionRunner = class _SessionRunner {
         }
       },
       onDormantTimeout: () => {
+        if (this.deferShutdownForLiveChild("dormant")) return;
         process.stderr.write("[conveyor-agent] Dormant idle timeout reached, shutting down\n");
         this.stopped = true;
         this.queryBridge?.stop();
@@ -13879,6 +14844,58 @@ var SessionRunner = class _SessionRunner {
   get state() {
     return this._state;
   }
+  /**
+   * Supervisors whose live children keep this pod alive. Empty until `cli.ts`
+   * wires them, which is deliberate: the supervisors are constructed AFTER the
+   * runner, and an empty list simply means "no children to protect" — the
+   * pre-existing shutdown behavior.
+   */
+  liveChildSources = [];
+  /** Called by `cli.ts` once the child supervisors exist. */
+  setLiveChildSources(sources) {
+    this.liveChildSources = sources;
+  }
+  /**
+   * Suppress an idle/dormant shutdown while a spawned child is still working.
+   *
+   * The Planner is the pod's main process, so its timeouts take the pod — and
+   * the Builder's in-flight work — down with it. Returns true when the shutdown
+   * was deferred and the caller must not proceed.
+   *
+   * Re-arms with a SHORT delay rather than a fresh full window: the pod should
+   * converge on shutdown soon after the last child exits, not one more idle
+   * window later. Bounded by the configured timeout so a test with a 50ms idle
+   * window re-checks in 50ms rather than a minute.
+   *
+   * Fail-open by construction — if the probe throws, or no sources are wired,
+   * the shutdown proceeds exactly as before. The opposite bias (a pod that
+   * cannot die) is the more expensive mistake here only in money; killing a
+   * live build costs work.
+   */
+  deferShutdownForLiveChild(timer) {
+    let live;
+    try {
+      live = findLiveChild(this.liveChildSources);
+    } catch (err) {
+      process.stderr.write(`[conveyor-agent] Live-child probe failed, not deferring: ${err}
+`);
+      return false;
+    }
+    if (!live) return false;
+    const recheckMs = Math.min(this.lifecycle.config.idleTimeoutMs, CHILD_DEFER_RECHECK_MS);
+    const label = timer === "idle" ? "Idle" : "Dormant idle";
+    process.stderr.write(
+      `[conveyor-agent] ${label} timeout deferred: ${live.kind} session ${live.sessionId} active
+`
+    );
+    if (timer === "idle") {
+      this.lifecycle.startIdleTimer(recheckMs);
+    } else {
+      this.dormantDeadline = Date.now() + recheckMs;
+      this.lifecycle.startDormantTimer(recheckMs);
+    }
+    return true;
+  }
   get sessionId() {
     return this.connection.sessionId;
   }
@@ -14604,6 +15621,7 @@ var SessionRunner = class _SessionRunner {
       instructions: this.fullContext?.agentInstructions ?? "",
       workspaceDir: this.config.workspaceDir,
       mode: this.config.runnerMode,
+      packExecution: this.config.packExecution,
       isAuto: this.config.isAuto
     };
     const bridge = new QueryBridge(this.connection, this.mode, runnerConfig, {
@@ -14867,6 +15885,8 @@ function unshallowRepo(workspaceDir) {
 
 export {
   DEFAULT_SONNET_MODEL,
+  RUNNER_MODES,
+  parsePackExecution,
   isPermissionDeniedError,
   buildSynthesizedCredentials,
   claudeJsonPath,