@rallycry/conveyor-agent 11.0.8 → 11.0.10

package/dist/{chunk-SKTCDL4K.js → chunk-PGNV3DGV.js}

@@ -59,7 +59,7 @@ import {
   statWorkspacePath,
   updateRemoteToken,
   verifyGitCredential
-} from "./chunk-APP6Y2D7.js";
+} from "./chunk-YMZ6Q55T.js";
 import {
   registerBootMilestoneSocketFallback,
   reportBootMilestone
@@ -230,6 +230,7 @@ import { z as z6 } from "zod";
 import { z as z7 } from "zod";
 import { z as z8 } from "zod";
 import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var EXTERNAL_AGENT_MESSAGE_SOURCE = "external_agent";
 var DEFAULT_SONNET_MODEL = "claude-sonnet-5";
 var DEFAULT_OPUS_MODEL = "claude-opus-5";
@@ -993,10 +994,6 @@ var ReportReviewSpawnFailureRequestSchema = z4.object({
 var ReportBuilderSpawnFailureRequestSchema = ReportReviewSpawnFailureRequestSchema.omit({
   reviewSessionId: true
 }).extend({ buildSessionId: z4.string() });
-var RequestWorkspaceRecycleRequestSchema = z4.object({
-  sessionId: z4.string(),
-  reason: z4.string().max(2e3)
-});
 var SpawnTaskSessionRequestSchema = z4.object({
   taskId: z4.string(),
   kind: z4.enum(["tui", "shell"])
@@ -1679,12 +1676,21 @@ var GetProjectAnalyticsSummaryRequestSchema = z6.object({
   rangeDays: z6.number().int().min(1).max(GET_ANALYTICS_SUMMARY_MAX_RANGE_DAYS).optional(),
   campaign: z6.string().max(200).optional()
 });
+var RequestWorkspaceRecycleRequestSchema = z7.object({
+  sessionId: z7.string(),
+  reason: z7.string().max(2e3)
+});
+var ReportApiOutageRequestSchema = z7.object({
+  sessionId: z7.string(),
+  detail: z7.string().max(2e3),
+  attempts: z7.number().int().min(0).max(100)
+});
 var SHA_PATTERN = /^[0-9a-f]{40}$/i;
-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()
+var ReviewGuideFileReferenceSchema = z8.object({
+  path: z8.string().min(1).max(500),
+  startLine: z8.number().int().positive().max(1e6).optional(),
+  endLine: z8.number().int().positive().max(1e6).optional(),
+  hunkHeader: z8.string().min(1).max(300).optional()
 }).strict().superRefine((value, ctx) => {
   if (value.endLine !== void 0 && value.startLine === void 0) {
     ctx.addIssue({
@@ -1701,19 +1707,19 @@ var ReviewGuideFileReferenceSchema = z7.object({
     });
   }
 });
-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)
+var ReviewGuideSectionSchema = z8.object({
+  title: z8.string().min(1).max(160),
+  explanation: z8.string().min(1).max(2e3),
+  classification: z8.enum(["core", "supporting"]).optional(),
+  files: z8.array(ReviewGuideFileReferenceSchema).min(1).max(20)
 }).strict();
-var ReviewGuideContentSchema = z7.object({
-  overview: z7.string().min(1).max(3e3),
-  sections: z7.array(ReviewGuideSectionSchema).min(1).max(12)
+var ReviewGuideContentSchema = z8.object({
+  overview: z8.string().min(1).max(3e3),
+  sections: z8.array(ReviewGuideSectionSchema).min(1).max(12)
 }).strict();
 var PublishReviewGuideRequestSchema = ReviewGuideContentSchema.extend({
-  sessionId: z7.string().min(1),
-  reviewedSha: z7.string().regex(SHA_PATTERN, "reviewedSha must be a 40-character commit SHA")
+  sessionId: z8.string().min(1),
+  reviewedSha: z8.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;
@@ -1730,130 +1736,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 = z8.object({
-  type: z8.enum(["rule", "doc", "file", "folder"]),
-  path: z8.string().min(1).max(500),
-  label: z8.string().max(100).optional(),
+var ProjectTagContextPathSchema = z9.object({
+  type: z9.enum(["rule", "doc", "file", "folder"]),
+  path: z9.string().min(1).max(500),
+  label: z9.string().max(100).optional(),
   /** Verified-link tether — text that must keep existing in the file. */
-  locator: z8.string().min(1).max(CONTEXT_LINK_LOCATOR_MAX).regex(/^[^\r\n]*$/, "Locator cannot contain line breaks").optional(),
+  locator: z9.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: z8.enum(["test", "code"]).optional()
+  locatorType: z9.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 = 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),
+var hexColor = z9.string().regex(/^#[0-9a-fA-F]{6}$/, "Expected #RRGGBB hex color");
+var overviewPathSchema = z9.string().min(1).max(500).regex(/^[^\r\n]*$/, "Overview path cannot contain line breaks");
+var CreateProjectTagRequestSchema = z9.object({
+  projectId: z9.string(),
+  name: z9.string().min(1).max(50),
   color: hexColor.optional(),
-  description: z8.string().max(TAG_DESCRIPTION_MAX).optional(),
-  overview: z8.string().max(TAG_OVERVIEW_MAX).optional(),
+  description: z9.string().max(TAG_DESCRIPTION_MAX).optional(),
+  overview: z9.string().max(TAG_OVERVIEW_MAX).optional(),
   /** Source the overview from this repo file (stored overview stays as the pending fallback). */
   overviewPath: overviewPathSchema.optional(),
-  contextPaths: z8.array(ProjectTagContextPathSchema).max(20).optional(),
+  contextPaths: z9.array(ProjectTagContextPathSchema).max(20).optional(),
   /** Parents to link at create time (multi-parent DAG). */
-  parentTagIds: z8.array(z8.string()).max(25).optional(),
-  requestingUserId: z8.string().optional()
+  parentTagIds: z9.array(z9.string()).max(25).optional(),
+  requestingUserId: z9.string().optional()
 });
-var UpdateProjectTagRequestSchema = z8.object({
-  projectId: z8.string(),
-  tagId: z8.string(),
-  name: z8.string().min(1).max(50).optional(),
+var UpdateProjectTagRequestSchema = z9.object({
+  projectId: z9.string(),
+  tagId: z9.string(),
+  name: z9.string().min(1).max(50).optional(),
   color: hexColor.optional(),
-  description: z8.string().max(TAG_DESCRIPTION_MAX).optional(),
+  description: z9.string().max(TAG_DESCRIPTION_MAX).optional(),
   /** Full markdown glossary body; null clears it. Rejected while overviewPath is set. */
-  overview: z8.string().max(TAG_OVERVIEW_MAX).nullable().optional(),
+  overview: z9.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: z8.array(ProjectTagContextPathSchema).max(20).optional(),
+  contextPaths: z9.array(ProjectTagContextPathSchema).max(20).optional(),
   /** Full-set replacement of the tag's parent tags (multi-parent DAG). */
-  parentTagIds: z8.array(z8.string()).max(25).optional(),
+  parentTagIds: z9.array(z9.string()).max(25).optional(),
   /** One-line revision provenance, recorded in the tag's history. */
-  reason: z8.string().max(TAG_REASON_MAX).optional(),
+  reason: z9.string().max(TAG_REASON_MAX).optional(),
   /** Card the caller was working in — stamped into the revision history. */
-  taskId: z8.string().optional(),
-  requestingUserId: z8.string().optional()
+  taskId: z9.string().optional(),
+  requestingUserId: z9.string().optional()
 });
-var PostToProjectChatRequestSchema = z8.object({
-  projectId: z8.string(),
-  content: z8.string().min(1).max(2e4),
-  requestingUserId: z8.string().optional(),
+var PostToProjectChatRequestSchema = z9.object({
+  projectId: z9.string(),
+  content: z9.string().min(1).max(2e4),
+  requestingUserId: z9.string().optional(),
   /** Marks the post so the server can persist it beyond chat (tag-audit summaries land in tag history). */
-  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()
+  kind: z9.enum(["tag_audit_summary"]).optional()
+});
+var StartTagAuditRequestSchema = z9.object({
+  projectId: z9.string(),
+  requestingUserId: z9.string().optional()
+});
+var StartTaskAuditRequestSchema = z9.object({
+  projectId: z9.string(),
+  taskIds: z9.array(z9.string()).min(1).max(20),
+  requestingUserId: z9.string().optional()
+});
+var GetActiveAuditSessionsRequestSchema = z9.object({
+  projectId: z9.string()
+});
+var ReportTaskAuditResultRequestSchema = z9.object({
+  projectId: z9.string(),
+  taskId: z9.string(),
+  summary: z9.string(),
+  turnGrades: z9.array(
+    z9.object({
+      turnIndex: z9.number(),
+      phase: z9.enum(["planning", "building", "human"]),
+      grade: z9.enum(["correct", "neutral", "blunder"]),
+      reasoning: z9.string(),
+      eventType: z9.string(),
+      eventSummary: z9.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()
+  planningAccuracy: z9.number().nullable(),
+  buildingAccuracy: z9.number().nullable(),
+  humanAccuracy: z9.number().nullable(),
+  planningCorrect: z9.number(),
+  planningNeutral: z9.number(),
+  planningBlunder: z9.number(),
+  buildingCorrect: z9.number(),
+  buildingNeutral: z9.number(),
+  buildingBlunder: z9.number(),
+  humanCorrect: z9.number(),
+  humanNeutral: z9.number(),
+  humanBlunder: z9.number(),
+  humanEvaluations: z9.array(
+    z9.object({
+      messageIndex: z9.number(),
+      rating: z9.union([z9.literal(-1), z9.literal(0), z9.literal(1)]),
+      reasoning: z9.string()
     })
   ).optional(),
-  suggestionIds: z8.array(z8.string()),
-  auditCostUsd: z8.number().nullable(),
-  model: z8.string().nullable(),
+  suggestionIds: z9.array(z9.string()),
+  auditCostUsd: z9.number().nullable(),
+  model: z9.string().nullable(),
   /** When set, the audit is marked failed with this message instead. */
-  error: z8.string().optional()
+  error: z9.string().optional()
 });
-var GetTaskAuditsRequestSchema = z8.object({
-  projectId: z8.string(),
-  limit: z8.number().int().positive().max(200).optional().default(50)
+var GetTaskAuditsRequestSchema = z9.object({
+  projectId: z9.string(),
+  limit: z9.number().int().positive().max(200).optional().default(50)
 });
-var GetTaskAuditRequestSchema = z8.object({
-  projectId: z8.string(),
-  auditId: z8.string()
+var GetTaskAuditRequestSchema = z9.object({
+  projectId: z9.string(),
+  auditId: z9.string()
 });
-var GetTaskAuditAggregatesRequestSchema = z8.object({
-  projectId: z8.string()
+var GetTaskAuditAggregatesRequestSchema = z9.object({
+  projectId: z9.string()
 });
-var DeleteTaskAuditRequestSchema = z8.object({
-  projectId: z8.string(),
-  auditId: z8.string(),
-  requestingUserId: z8.string().optional()
+var DeleteTaskAuditRequestSchema = z9.object({
+  projectId: z9.string(),
+  auditId: z9.string(),
+  requestingUserId: z9.string().optional()
 });
-var MarkInitialPromptSubmittedRequestSchema = z8.object({
-  sessionId: z8.string()
+var MarkInitialPromptSubmittedRequestSchema = z9.object({
+  sessionId: z9.string()
 });
 var CRITICAL_AUTOMATED_SOURCES = /* @__PURE__ */ new Set([
   "ci_failure",
@@ -1871,47 +1877,139 @@ var DEFAULT_PACK_EXECUTION = "single-pod";
 function parsePackExecution(value) {
   return PACK_EXECUTIONS.includes(value ?? "") ? value : DEFAULT_PACK_EXECUTION;
 }
+var MEETING_CHECKLIST_TITLE_MAX = 300;
 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(),
+var MEETING_OCCURRED_AT_MIN_YEAR = 2e3;
+var MEETING_OCCURRED_AT_MAX_FUTURE_MS = 48 * 60 * 60 * 1e3;
+var OCCURRED_AT_RANGE_MESSAGE = `occurredAt must be a real date: no earlier than ${MEETING_OCCURRED_AT_MIN_YEAR}, and no more than 48 hours in the future.`;
+var MeetingOccurredAtSchema = z10.string().datetime().refine((value) => {
+  const ms = Date.parse(value);
+  if (Number.isNaN(ms)) return false;
+  if (ms > Date.now() + MEETING_OCCURRED_AT_MAX_FUTURE_MS) return false;
+  return new Date(ms).getUTCFullYear() >= MEETING_OCCURRED_AT_MIN_YEAR;
+}, OCCURRED_AT_RANGE_MESSAGE);
+var CreateMeetingFromTranscriptRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  rawText: z10.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
+  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
   /** ISO 8601. Defaults to now when the source carries no date. */
-  occurredAt: z9.string().datetime().optional(),
+  occurredAt: MeetingOccurredAtSchema.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()
+  format: z10.enum(["text", "vtt", "srt"]).optional(),
+  source: z10.enum(["manual", "slack"]).optional()
+});
+var GetMeetingRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid()
+});
+var UpdateMeetingRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
+  occurredAt: MeetingOccurredAtSchema.optional()
+});
+var RegenerateMeetingSummaryRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid()
+});
+var DeleteMeetingRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid()
+});
+var checklistTitle = z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX);
+var ListMeetingChecklistRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid()
+});
+var AddMeetingChecklistItemsRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  items: z10.array(z10.object({ title: checklistTitle })).min(1).max(50)
+});
+var UpdateMeetingChecklistItemRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  itemId: z10.string().cuid(),
+  title: checklistTitle.optional(),
+  ordinal: z10.number().int().min(0).optional(),
+  /** Explicit null clears the link; undefined leaves it alone. */
+  linkedTaskId: z10.string().cuid().nullable().optional()
+}).refine(
+  (v) => v.title !== void 0 || v.ordinal !== void 0 || v.linkedTaskId !== void 0,
+  "Pass at least one of title, ordinal, or linkedTaskId."
+);
+var DeleteMeetingChecklistItemRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  itemId: z10.string().cuid()
+});
+var SetMeetingChecklistItemCheckedRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  itemId: z10.string().cuid(),
+  checked: z10.boolean(),
+  /** Attach the card in the same call that ticks the item. */
+  linkedTaskId: z10.string().cuid().nullable().optional()
+});
+var ListMeetingsRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  limit: z10.number().int().min(1).max(50).optional(),
+  search: z10.string().max(200).optional()
+});
+var ReadMeetingTranscriptRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  offset: z10.number().int().min(0).optional(),
+  limit: z10.number().int().min(1).max(500).optional()
+});
+var MEETING_SUMMARY_MAX_CHARS = 5e4;
+var AddProjectMeetingChecklistItemsRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  items: z10.array(z10.object({ title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX) })).min(1).max(50),
+  requestingUserId: z10.string().optional()
+});
+var CheckProjectMeetingChecklistItemRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  checked: z10.boolean(),
+  /** Card id or slug. Resolved server-side and required to be in the project. */
+  linkedTask: z10.string().min(1).optional(),
+  requestingUserId: z10.string().optional()
+});
+var EditProjectMeetingChecklistItemRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  newTitle: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  requestingUserId: z10.string().optional()
+});
+var RemoveProjectMeetingChecklistItemRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  requestingUserId: z10.string().optional()
+});
+var CreateProjectMeetingRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  rawText: z10.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
+  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
+  occurredAt: MeetingOccurredAtSchema.optional(),
+  requestingUserId: z10.string().optional()
 });
+var UpdateProjectMeetingRequestSchema = z10.object({
+  projectId: z10.string().cuid(),
+  meetingId: z10.string().cuid(),
+  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
+  occurredAt: MeetingOccurredAtSchema.optional(),
+  summary: z10.string().min(1).max(MEETING_SUMMARY_MAX_CHARS).optional(),
+  requestingUserId: z10.string().optional()
+}).refine(
+  (v) => v.title !== void 0 || v.occurredAt !== void 0 || v.summary !== void 0,
+  "Pass at least one of title, occurredAt, or summary."
+);
 var AGENT_STATUS_REASON_USER_QUESTION = "user_question";
 var TASK_CHAT_HISTORY_LIMIT = 20;
 var PM_CHAT_HISTORY_LIMIT = 40;
@@ -1954,6 +2052,9 @@ When you write prose a person will read \u2014 chat messages, plan updates, PR t
 - Define a technical term on first use when a non-engineer will read the message.
 - Never drop a condition, number, or scope qualifier to shorten a sentence. Precision beats brevity.
 These rules do NOT apply to code, code comments, commit messages, or quoted output.`;
+var CLAUDESPACE_WORKLOAD_LABEL = "rc-workload";
+var CLAUDESPACE_WORKLOAD_VALUE = "claudespace";
+var CONVEYOR_POD_SELECTOR = `${CLAUDESPACE_WORKLOAD_LABEL}=${CLAUDESPACE_WORKLOAD_VALUE}`;
 var MS_PER_DAY = 24 * 60 * 60 * 1e3;
 var MENTION_TOKEN_REGEX = /@\[(\w+):([^\]]+)\]/g;
 function parseMentions(content) {
@@ -2495,7 +2596,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 z10 } from "zod";
+import { z as z11 } from "zod";
 var ClaudeCodeHarness = class {
   /** The SDK stream is itself the structured-event source. */
   emitsStructuredEvents = true;
@@ -2528,7 +2629,7 @@ var ClaudeCodeHarness = class {
         }
       );
       if (t.strict) {
-        sdkTool.inputSchema = z10.strictObject(t.schema);
+        sdkTool.inputSchema = z11.strictObject(t.schema);
       }
       return sdkTool;
     });
@@ -3096,6 +3197,7 @@ function mapAssistant(record) {
   };
   const usage = mapUsage(message);
   if (usage !== void 0) result.message.usage = usage;
+  if (record.isApiErrorMessage === true) result.isApiError = true;
   return result;
 }
 function mapResultSuccess(record) {
@@ -3786,7 +3888,7 @@ var PtyOutputCoalescer = class {
 
 // src/harness/pty/tool-server.ts
 import { createServer as createServer2 } from "http";
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 import { writeFile as writeFile3 } from "fs/promises";
 import { join as join3 } from "path";
 import { randomBytes } from "crypto";
@@ -3843,7 +3945,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 ? z11.strictObject(tool2.schema) : tool2.schema;
+      const inputSchema = tool2.strict ? z12.strictObject(tool2.schema) : tool2.schema;
       register(
         tool2.name,
         {
@@ -6799,9 +6901,7 @@ function buildChatInstructions(context, scenario, newMessages) {
   const parts = [];
   if (scenario === "fresh") {
     parts.push(
-      `Read the chat history above and respond to what the team asked.`,
-      `Reply with post_to_chat \u2014 your turn output is NOT shown in chat, so post_to_chat is the only way the team sees your answer.`,
-      `Ask clarifying questions when they help. This is a conversation, not an autonomous build.`
+      `The user's message is above. Do what it asks and reply with post_to_chat \u2014 your turn output is NOT shown in chat, so post_to_chat is the only way the user sees your answer.`
     );
   } else if (userMessages.length > 0) {
     parts.push(
@@ -6818,17 +6918,6 @@ Respond to them with post_to_chat (your turn output is NOT shown in chat).`
       `Post a brief status update with post_to_chat if you still owe the team a response, then wait for them.`
     );
   }
-  if (!context.plan?.trim()) {
-    parts.push(
-      `
-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 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.`);
   }
@@ -7461,31 +7550,20 @@ function buildModePrompt(agentMode, context, runnerMode) {
   }
 }
 function buildChatPrompt(context) {
-  const base = context?.baseBranch?.trim() || "dev";
+  const branch = context?.githubBranch?.trim();
+  const gitScope = branch ? ` on branch \`${branch}\`` : "";
   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.`,
+## Mode: Interactive`,
+    `This is a direct Claude Code session on this card. The user drives it message by message; you have the same access you would have running Claude Code locally in this repo (full read/write, shell, git${gitScope}).`,
+    `- Your turn output is NOT shown in chat \u2014 reply with \`post_to_chat\`.`,
+    `- There is no required Conveyor workflow here. Do what the message asks: answer, investigate, write files, build, or open a PR. Skills such as \`/conveyor-plan\` and \`/conveyor-build\` are available if the user asks for them or they clearly help; nothing runs them for you.`,
     ``,
-    `### 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.`
+    `### Card facts`,
+    `- This card starts Unidentified and stays so until a plan is saved with \`update_task\`; that first plan identifies it and moves it to In Progress.`,
+    `- Files the user should keep go on the card via \`upload_attachment\` (any file type, up to 25MB), not an off-platform link.`,
+    `- \`create_pull_request\` opens the PR for this card and moves it to Review PR. Save a short plan first so the card is identified \u2014 a record, not an approval gate.`,
+    `- When the user says they are done, call \`force_update_task_status\` with status \`"Complete"\`. Not if a PR is open \u2014 the review flow takes it from there.`
   ].join("\n");
 }
 function buildReviewTagSection(context) {
@@ -8040,6 +8118,7 @@ ${config.instructions}`);
     `
 Your turn output appears ONLY in the live agent terminal \u2014 it is NOT posted to the task chat. The team does NOT see your replies unless you post them.`,
     `Use post_to_chat (omit task_id \u2192 your own task's chat) to share meaningful status as you work, a summary when you finish, and any blocker or question you need a human to answer.`,
+    `A question you need answered goes through AskUserQuestion \u2014 that is what pages a person. post_to_chat with milestone: "blocked" records that you are parked and does not page anyone.`,
     `Pass task_id only to message a DIFFERENT task's chat (e.g. a parent task via get_task).`,
     `Use read_task_chat only if you need to re-read earlier messages beyond the chat context above.`,
     `
@@ -8346,7 +8425,7 @@ async function buildInitialPrompt(mode, context, isAuto, agentMode, packExecutio
 }
 
 // src/tools/task-context-tools.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 
 // ../shared/dist/tool-contracts/index.js
 var f = {
@@ -8375,14 +8454,14 @@ var f = {
     return { kind: "nullable", inner };
   }
 };
-function compileString(z20, spec) {
-  let schema = z20.string();
+function compileString(z21, spec) {
+  let schema = z21.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(z20, spec) {
-  let schema = z20.number();
+function compileNumber(z21, spec) {
+  let schema = z21.number();
   if (spec.int) schema = schema.int();
   if (spec.positive) schema = schema.positive();
   if (spec.nonnegative) schema = schema.nonnegative();
@@ -8390,49 +8469,49 @@ function compileNumber(z20, spec) {
   if (spec.max !== void 0) schema = schema.max(spec.max);
   return schema;
 }
-function compileArray(z20, spec) {
-  let schema = z20.array(compileField(z20, spec.item));
+function compileArray(z21, spec) {
+  let schema = z21.array(compileField(z21, spec.item));
   if (spec.min !== void 0) schema = schema.min(spec.min);
   return schema;
 }
-function compileBase(z20, spec) {
+function compileBase(z21, spec) {
   switch (spec.kind) {
     case "string":
-      return compileString(z20, spec);
+      return compileString(z21, spec);
     case "number":
-      return compileNumber(z20, spec);
+      return compileNumber(z21, spec);
     case "boolean":
-      return z20.boolean();
+      return z21.boolean();
     case "enum":
-      return z20.enum([...spec.values]);
+      return z21.enum([...spec.values]);
     case "array":
-      return compileArray(z20, spec);
+      return compileArray(z21, spec);
     case "object":
-      return z20.object(compileShape(z20, spec.fields));
+      return z21.object(compileShape(z21, spec.fields));
   }
 }
 function descriptionOf(spec) {
   if (spec.kind === "optional" || spec.kind === "nullable") return descriptionOf(spec.inner);
   return spec.desc;
 }
-function compileUndescribed(z20, spec) {
+function compileUndescribed(z21, spec) {
   if (spec.kind === "optional") {
-    return compileUndescribed(z20, spec.inner).optional();
+    return compileUndescribed(z21, spec.inner).optional();
   }
   if (spec.kind === "nullable") {
-    return compileUndescribed(z20, spec.inner).nullable();
+    return compileUndescribed(z21, spec.inner).nullable();
   }
-  return compileBase(z20, spec);
+  return compileBase(z21, spec);
 }
-function compileField(z20, spec) {
-  const schema = compileUndescribed(z20, spec);
+function compileField(z21, spec) {
+  const schema = compileUndescribed(z21, spec);
   const desc = descriptionOf(spec);
   return desc === void 0 ? schema : schema.describe(desc);
 }
-function compileShape(z20, fields) {
+function compileShape(z21, fields) {
   const shape = {};
   for (const [key, spec] of Object.entries(fields)) {
-    shape[key] = compileField(z20, spec);
+    shape[key] = compileField(z21, spec);
   }
   return shape;
 }
@@ -8481,7 +8560,7 @@ var postToChatContract = defineToolContract({
       ),
       milestone: f.optional(
         f.enum(["plan_ready", "implementation_complete", "blocked"], {
-          desc: "Declare a narrative milestone instead of a routine update. Use SPARINGLY \u2014 only when the plan is ready, implementation is complete, or you are blocked. Milestones appear on the card's activity timeline and in Slack."
+          desc: "Declare a narrative milestone instead of a routine update. Use SPARINGLY \u2014 only when the plan is ready (plan_ready), implementation is complete (implementation_complete), or you are parked and cannot continue until a human acts (blocked). `blocked` posts a note and enables reply delivery but pages nobody; to page a person, ask them with AskUserQuestion. Never use `blocked` for a finished plan, finished work, or a tool error you can retry. Milestones appear on the card's activity timeline and in Slack."
         })
       )
     }
@@ -9013,7 +9092,7 @@ var createSubtaskContract = defineToolContract({
       ),
       tags: f.optional(
         f.array(f.string(), {
-          desc: 'Tag names to assign to the subtask (e.g. ["refactor"]). Unknown names are rejected \u2014 create the tag first with manage_tags. Use list_tags to see available tags.'
+          desc: 'Tag names to assign to the subtask (e.g. ["refactor"]). Unknown names are rejected before the subtask is created, so nothing is written and a corrected retry creates exactly one subtask. Create the tag first with manage_tags. Use list_tags to see available tags.'
         })
       )
     }
@@ -9606,10 +9685,149 @@ var readMeetingTranscriptContract = defineToolContract({
     }
   }
 });
+var RAW_TEXT_DESC = "The transcript itself. Plain text with `Speaker: line` labels, or a WebVTT/SRT file's contents \u2014 the format is detected, and the speaker labels become the participant list. Paste the whole thing; it is stored as the meeting's record.";
+var OCCURRED_AT_DESC = "When the meeting happened, ISO 8601 (e.g. 2026-09-02T15:00:00Z). Defaults to now. Must be a real date \u2014 no earlier than 2000, and no more than 48 hours ahead.";
+var TITLE_DESC = "Meeting title. Defaults to `Meeting <date>` when you do not name one.";
+var createMeetingContract = defineToolContract({
+  name: "create_meeting",
+  agent: {
+    description: `File a transcript as a project meeting. Use this when you have the text of a call \u2014 a paste, an export, notes captured elsewhere \u2014 and it belongs in the project's record. The transcript is parsed into speaker segments and an AI summary is written straight after, so the meeting reads "processing" for a few seconds before its overview appears. This creates a MEETING, not cards: turning what was decided into work is still create_task's job.`,
+    fields: {
+      rawText: f.string({ desc: RAW_TEXT_DESC, min: 1 }),
+      title: f.optional(f.string({ desc: TITLE_DESC, max: 200 })),
+      occurredAt: f.optional(f.string({ desc: OCCURRED_AT_DESC }))
+    }
+  },
+  mcp: {
+    description: `File a transcript as a project meeting. The text is parsed into speaker segments and summarized automatically, so the meeting reports status "processing" briefly before its overview lands. Creates a meeting only \u2014 use the card tools to turn decisions into work. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      rawText: f.string({ desc: RAW_TEXT_DESC, min: 1 }),
+      title: f.optional(f.string({ desc: TITLE_DESC, max: 200 })),
+      occurredAt: f.optional(f.string({ desc: OCCURRED_AT_DESC }))
+    }
+  }
+});
+var SUMMARY_DESC = "Replace the meeting's overview with this text. Markdown, and it is what every reader sees from then on \u2014 write the whole overview, not a note about it. Writing a summary marks the meeting ready, so a later regenerate is the only thing that overwrites it.";
+var updateMeetingContract = defineToolContract({
+  name: "update_meeting",
+  agent: {
+    description: `Correct a meeting's title or date, or replace its AI summary with a better one. This is how a rewritten overview actually persists \u2014 read the transcript, write the summary you want, and pass it here. Pass at least one field; the ones you leave out are untouched.`,
+    fields: {
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.optional(f.string({ desc: TITLE_DESC, max: 200 })),
+      occurredAt: f.optional(f.string({ desc: OCCURRED_AT_DESC })),
+      summary: f.optional(f.string({ desc: SUMMARY_DESC, min: 1 }))
+    }
+  },
+  mcp: {
+    description: `Correct a meeting's title or date, or replace its AI summary with a rewritten one. Pass at least one field; omitted fields are left alone. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.optional(f.string({ desc: TITLE_DESC, max: 200 })),
+      occurredAt: f.optional(f.string({ desc: OCCURRED_AT_DESC })),
+      summary: f.optional(f.string({ desc: SUMMARY_DESC, min: 1 }))
+    }
+  }
+});
+var CHECKLIST_ITEM_TITLE = "The item's exact title, as get_meeting lists it. Matched case-insensitively.";
+var CHECKLIST_INTRO = "A meeting's checklist is its follow-ups: one line each, ticked when done, optionally pointing at the Conveyor card that carries the work. The AI summary's proposed next steps are seeded here automatically.";
+var addMeetingChecklistItemsContract = defineToolContract({
+  name: "add_meeting_checklist_items",
+  agent: {
+    description: `Add follow-up items to a meeting's checklist. ${CHECKLIST_INTRO} Use this for a step the summary missed, or one that came out of a later conversation. Items whose title already exists are skipped, so re-running this is safe.`,
+    fields: {
+      meetingId: f.string({ desc: MEETING_ID }),
+      items: f.array(
+        f.object({ title: f.string({ desc: "One follow-up, as a single line.", min: 1 }) }),
+        { desc: "The items to add, in the order they should appear." }
+      )
+    }
+  },
+  mcp: {
+    description: `Add follow-up items to a meeting's checklist. ${CHECKLIST_INTRO} Existing titles are skipped, so re-running is safe. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      meetingId: f.string({ desc: MEETING_ID }),
+      items: f.array(
+        f.object({ title: f.string({ desc: "One follow-up, as a single line.", min: 1 }) }),
+        { desc: "The items to add, in the order they should appear." }
+      )
+    }
+  }
+});
+var LINKED_TASK_DESC = "Card id or slug to attach to this item \u2014 the card that carries the work. Must be in the same project. Pass it in the same call that ticks the item when you just filed the card.";
+var checkMeetingChecklistItemContract = defineToolContract({
+  name: "check_meeting_checklist_item",
+  agent: {
+    description: `Tick or untick one of a meeting's checklist items, and optionally attach the card that carries it. This is how a next step becomes tracked work: file the card with create_task, then call this with the item's title and the new card's slug. Ticking records YOU as the person who did it. Unticking clears that, but keeps the linked card.`,
+    fields: {
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE }),
+      checked: f.boolean({ desc: "true to tick the item, false to untick it." }),
+      linkedTask: f.optional(f.string({ desc: LINKED_TASK_DESC }))
+    }
+  },
+  mcp: {
+    description: `Tick or untick a meeting checklist item, optionally attaching the card that carries it. Ticking records the acting user. Unticking clears that but keeps the link. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE }),
+      checked: f.boolean({ desc: "true to tick the item, false to untick it." }),
+      linkedTask: f.optional(f.string({ desc: LINKED_TASK_DESC }))
+    }
+  }
+});
+var editMeetingChecklistItemContract = defineToolContract({
+  name: "edit_meeting_checklist_item",
+  agent: {
+    description: `Reword one of a meeting's checklist items. Use it to sharpen a vague next step into something someone can act on; to mark it done use check_meeting_checklist_item instead.`,
+    fields: {
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE }),
+      newTitle: f.string({ desc: "The replacement text, as a single line.", min: 1 })
+    }
+  },
+  mcp: {
+    description: `Reword a meeting checklist item. To mark it done use check_meeting_checklist_item. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE }),
+      newTitle: f.string({ desc: "The replacement text, as a single line.", min: 1 })
+    }
+  }
+});
+var removeMeetingChecklistItemContract = defineToolContract({
+  name: "remove_meeting_checklist_item",
+  agent: {
+    description: `Delete one of a meeting's checklist items. For a step that turned out not to be needed. An item someone already ticked is a record that work happened \u2014 untick it or leave it rather than deleting it.`,
+    fields: {
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE })
+    }
+  },
+  mcp: {
+    description: `Delete a meeting checklist item. Prefer unticking over deleting an item someone already completed. ${MCP_TAIL}`,
+    fields: {
+      projectId: mcpProjectId,
+      meetingId: f.string({ desc: MEETING_ID }),
+      title: f.string({ desc: CHECKLIST_ITEM_TITLE })
+    }
+  }
+});
 var meetingsContracts = [
   listMeetingsContract,
   getMeetingContract,
-  readMeetingTranscriptContract
+  readMeetingTranscriptContract,
+  createMeetingContract,
+  updateMeetingContract,
+  addMeetingChecklistItemsContract,
+  checkMeetingChecklistItemContract,
+  editMeetingChecklistItemContract,
+  removeMeetingChecklistItemContract
 ];
 var SINCE_MINUTES = f.optional(
   f.number({
@@ -9744,9 +9962,9 @@ var TOOL_CONTRACTS = Object.fromEntries(
 );
 
 // src/tools/contract-tool.ts
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 function agentShape(surface) {
-  return compileShape(z12, surface.fields);
+  return compileShape(z13, surface.fields);
 }
 function defineContractTool(contract, handler, options) {
   return {
@@ -9903,11 +10121,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: z13.string().optional().describe(
+      task_id: z14.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: 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).")
+      source: z14.enum(["agent", "application"]).optional().describe("Filter by log source. Omit for all logs."),
+      limit: z14.number().optional().describe("Max number of log entries to return (default 50, max 500).")
     },
     async ({ task_id, source, limit }) => {
       try {
@@ -10002,7 +10220,7 @@ function buildTaskContextTools(connection) {
 }
 
 // src/tools/dependency-suggestion-tools.ts
-import { z as z14 } from "zod";
+import { z as z15 } from "zod";
 function buildGetDependenciesTool(connection) {
   return defineContractTool(
     getDependenciesContract,
@@ -10026,10 +10244,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: z14.string().optional().describe(
+      status: z15.string().optional().describe(
         "Filter by status: Planning, Open, InProgress, ReviewPR, ReviewDev, ReviewLive, Complete, Cancelled"
       ),
-      limit: z14.number().int().min(1).max(100).optional().describe("Max results (default 20)")
+      limit: z15.number().int().min(1).max(100).optional().describe("Max results (default 20)")
     },
     async ({ status, limit }) => {
       try {
@@ -10053,7 +10271,7 @@ function buildGetSuggestionsTool(connection) {
 }
 
 // src/tools/mutation-tools.ts
-import { z as z15 } from "zod";
+import { z as z16 } from "zod";
 
 // src/runner/refresh-verify-heal.ts
 async function refreshAndVerifyGithubCredential(cwd, mint) {
@@ -10185,7 +10403,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: z15.enum([
+      status: z16.enum([
         "Planning",
         "Open",
         "InProgress",
@@ -10195,7 +10413,7 @@ function buildForceUpdateTaskStatusTool(connection) {
         "Complete",
         "Cancelled"
       ]).describe("The new status for the task"),
-      task_id: z15.string().optional().describe("Child task ID to update. Omit to update the current task.")
+      task_id: z16.string().optional().describe("Child task ID to update. Omit to update the current task.")
     },
     async ({ status, task_id }) => {
       try {
@@ -10348,10 +10566,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: 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)")
+      title: z16.string().describe("Follow-up task title"),
+      description: z16.string().optional().describe(cardDescriptionDesc("Brief description of the follow-up work")),
+      plan: z16.string().optional().describe("Implementation plan if known"),
+      story_point_value: z16.number().optional().describe("Story point estimate (1=Common, 2=Magic, 3=Rare, 5=Unique)")
     },
     async ({ title, description, plan, story_point_value }) => {
       try {
@@ -10378,11 +10596,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: z15.string().describe("Short title for the suggestion"),
-      description: z15.string().optional().describe(
+      title: z16.string().describe("Short title for the suggestion"),
+      description: z16.string().optional().describe(
         "1-2 sentence description of what should change and why. Keep concise and project-focused."
       ),
-      tag_names: z15.array(z15.string()).optional().describe("Tag names to categorize the suggestion")
+      tag_names: z16.array(z16.string()).optional().describe("Tag names to categorize the suggestion")
     },
     async ({ title, description, tag_names }) => {
       try {
@@ -10411,8 +10629,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: 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")
+      suggestion_id: z16.string().describe("The suggestion ID to vote on"),
+      value: z16.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 {
@@ -10793,7 +11011,7 @@ function buildCommonTools(connection, config) {
 }
 
 // src/tools/pm-tools.ts
-import { z as z16 } from "zod";
+import { z as z17 } from "zod";
 
 // src/tools/task-update-tools.ts
 var CURRENT_TASK_ONLY = ["title", "description", "plan", "githubBranch"];
@@ -10866,8 +11084,8 @@ function buildUpdateTaskTool(connection) {
     "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: z16.string().optional().describe("The task plan in markdown"),
-      description: z16.string().optional().describe(cardDescriptionDesc("Updated task description"))
+      plan: z17.string().optional().describe("The task plan in markdown"),
+      description: z17.string().optional().describe(cardDescriptionDesc("Updated task description"))
     },
     async ({ plan, description }) => {
       try {
@@ -10890,10 +11108,10 @@ function buildHandoffTool(connection) {
     "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). 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: z16.number().int().positive().optional().describe(
+      storyPoints: z17.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: z16.string().optional().describe("Optional kickoff note posted to the chat alongside the handoff notice.")
+      message: z17.string().optional().describe("Optional kickoff note posted to the chat alongside the handoff notice.")
     },
     async ({ storyPoints, message }) => {
       try {
@@ -11044,7 +11262,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: z16.string().describe("The child task ID to start a cloud build for")
+        childTaskId: z17.string().describe("The child task ID to start a cloud build for")
       },
       async ({ childTaskId }) => {
         try {
@@ -11073,7 +11291,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: z16.string().describe("The child task ID whose build should be stopped")
+        childTaskId: z17.string().describe("The child task ID whose build should be stopped")
       },
       async ({ childTaskId }) => {
         try {
@@ -11132,7 +11350,7 @@ function buildPmTools(connection, options) {
 }
 
 // src/tools/discovery-tools.ts
-import { z as z17 } from "zod";
+import { z as z18 } 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) {
@@ -11151,12 +11369,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: 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(
+        title: z18.string().optional().describe("The new task title"),
+        storyPointValue: z18.number().optional().describe(SP_DESCRIPTION2),
+        tagNames: z18.array(z18.string()).optional().describe("Array of tag names to assign"),
+        githubPRUrl: z18.string().url().optional().describe("GitHub pull request URL to link to this task"),
+        githubBranch: z18.string().optional().describe("Set the GitHub branch name for this task (e.g. 'conveyor/my-feature-abc123')"),
+        risk: z18.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."
         )
       },
@@ -11196,7 +11414,7 @@ function buildDiscoveryTools(connection) {
 }
 
 // src/tools/project-tools.ts
-import { z as z18 } from "zod";
+import { z as z19 } from "zod";
 
 // src/execution/context-path-verifier.ts
 import { readFile as readFile2 } from "fs/promises";
@@ -11274,16 +11492,16 @@ function formatContextPathProblems(problems) {
 }
 
 // src/tools/project-tools.ts
-var CONTEXT_PATH_SHAPE = z18.object({
-  type: z18.enum(["rule", "doc", "file", "folder"]).describe(
+var CONTEXT_PATH_SHAPE = z19.object({
+  type: z19.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: 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(
+  path: z19.string().min(1).max(500).describe("Repo-relative path"),
+  label: z19.string().max(100).optional(),
+  locator: z19.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: z18.enum(["test", "code"]).optional().describe(
+  locatorType: z19.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), {
@@ -11332,15 +11550,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: 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(
+      name: z19.string().min(1).max(50),
+      color: z19.string().regex(/^#[0-9a-fA-F]{6}$/).optional().describe("#RRGGBB (default gray)"),
+      description: z19.string().max(TAG_DESCRIPTION_MAX).optional(),
+      overview: z19.string().max(TAG_OVERVIEW_MAX).optional().describe("Full markdown glossary body \u2014 the term's spec"),
+      overviewPath: z19.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: 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()
+      parentTagIds: z19.array(z19.string()).max(25).optional().describe("Parent tag ids from list_tags (multi-parent DAG) to link at create time"),
+      contextPaths: z19.array(CONTEXT_PATH_SHAPE).max(20).optional()
     },
     async ({ name, color, description, overview, overviewPath, parentTagIds, contextPaths }) => {
       const rejection = await rejectBadContextPaths(contextPaths, workspaceDir);
@@ -11368,19 +11586,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: 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(
+      tagId: z19.string().describe("Tag id from list_tags"),
+      name: z19.string().min(1).max(50).optional(),
+      color: z19.string().regex(/^#[0-9a-fA-F]{6}$/).optional(),
+      description: z19.string().max(TAG_DESCRIPTION_MAX).optional(),
+      overview: z19.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: z18.string().min(1).max(500).nullable().optional().describe(
+      overviewPath: z19.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: 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()
+      parentTagIds: z19.array(z19.string()).max(25).optional().describe("Full-set replacement of the tag's parent tags (multi-parent DAG)"),
+      reason: z19.string().max(TAG_REASON_MAX).optional().describe("One line on why \u2014 shown in the tag's revision history"),
+      contextPaths: z19.array(CONTEXT_PATH_SHAPE).max(20).optional()
     },
     async ({
       tagId,
@@ -11438,8 +11656,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: z18.string().min(1).max(2e4),
-      kind: z18.enum(["tag_audit_summary"]).optional().describe(
+      message: z19.string().min(1).max(2e4),
+      kind: z19.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"
       )
     },
@@ -11458,7 +11676,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: z18.string().describe("Task id or slug")
+      taskId: z19.string().describe("Task id or slug")
     },
     async ({ taskId }) => {
       try {
@@ -11476,8 +11694,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: z18.string().describe("Task id or slug"),
-      limit: z18.number().int().min(1).max(200).optional().describe("Messages to fetch (default 50)")
+      taskId: z19.string().describe("Task id or slug"),
+      limit: z19.number().int().min(1).max(200).optional().describe("Messages to fetch (default 50)")
     },
     async ({ taskId, limit }) => {
       try {
@@ -11499,9 +11717,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: 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)")
+      taskId: z19.string().describe("Task id or slug"),
+      limit: z19.number().int().min(1).max(500).optional().describe("Entries to fetch (default 50)"),
+      source: z19.enum(["agent", "application"]).optional().describe("Filter: 'agent' = model events (default useful for grading)")
     },
     async ({ taskId, limit, source }) => {
       try {
@@ -11519,44 +11737,44 @@ function buildGetProjectTaskLogsTool(connection, projectId) {
     { annotations: { readOnlyHint: true } }
   );
 }
-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 TURN_GRADE_SHAPE = z19.object({
+  turnIndex: z19.number().int().min(0),
+  phase: z19.enum(["planning", "building", "human"]),
+  grade: z19.enum(["correct", "neutral", "blunder"]),
+  reasoning: z19.string(),
+  eventType: z19.string().describe('e.g. "message", "tool_use", "human_message"'),
+  eventSummary: z19.string().max(200).describe("\u2264120 chars of what happened this turn")
 });
-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()
+var HUMAN_EVAL_SHAPE = z19.object({
+  messageIndex: z19.number().int().min(0).describe("Index into the task's human messages, oldest first"),
+  rating: z19.number().int().min(-1).max(1),
+  reasoning: z19.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: 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")
+      taskId: z19.string().describe("The audited task's id (NOT slug)"),
+      summary: z19.string().describe("3-6 sentences: what went well, what was wasted"),
+      turnGrades: z19.array(TURN_GRADE_SHAPE),
+      planningAccuracy: z19.number().min(0).max(1).nullable(),
+      buildingAccuracy: z19.number().min(0).max(1).nullable(),
+      humanAccuracy: z19.number().min(0).max(1).nullable(),
+      planningCorrect: z19.number().int().min(0),
+      planningNeutral: z19.number().int().min(0),
+      planningBlunder: z19.number().int().min(0),
+      buildingCorrect: z19.number().int().min(0),
+      buildingNeutral: z19.number().int().min(0),
+      buildingBlunder: z19.number().int().min(0),
+      humanCorrect: z19.number().int().min(0),
+      humanNeutral: z19.number().int().min(0),
+      humanBlunder: z19.number().int().min(0),
+      humanEvaluations: z19.array(HUMAN_EVAL_SHAPE).optional(),
+      suggestionIds: z19.array(z19.string()).describe("Suggestion ids filed for this task, or []"),
+      auditCostUsd: z19.number().nullable(),
+      model: z19.string().nullable().describe("The model you are running as"),
+      error: z19.string().optional().describe("Set ONLY to mark this task's audit failed")
     },
     async (input) => {
       try {
@@ -11849,6 +12067,13 @@ function errText4(prefix, error) {
   return textResult(`${prefix}: ${error instanceof Error ? error.message : "Unknown error"}`);
 }
 function buildMeetingTools(connection, projectId) {
+  return [
+    ...readTools(connection, projectId),
+    ...writeTools(connection, projectId),
+    ...checklistTools(connection, projectId)
+  ];
+}
+function readTools(connection, projectId) {
   return [
     defineContractTool(
       listMeetingsContract,
@@ -11911,6 +12136,107 @@ ${res.lines.join("\n")}${footer}`);
     )
   ];
 }
+function writeTools(connection, projectId) {
+  return [
+    defineContractTool(createMeetingContract, async (input) => {
+      try {
+        const res = await connection.call("createProjectMeeting", {
+          projectId,
+          rawText: input.rawText,
+          title: input.title,
+          occurredAt: input.occurredAt
+        });
+        return textResult(
+          `Created "${res.title}" (${res.segmentCount} segments, ${res.participants.length} participants).
+The AI summary is being written now; read it back with get_meeting in a few seconds.
+${res.url}`
+        );
+      } catch (error) {
+        return errText4("Failed to create the meeting", error);
+      }
+    }),
+    defineContractTool(updateMeetingContract, async (input) => {
+      try {
+        const res = await connection.call("updateProjectMeeting", {
+          projectId,
+          meetingId: input.meetingId,
+          title: input.title,
+          occurredAt: input.occurredAt,
+          summary: input.summary
+        });
+        return textResult(`Updated "${res.title}".
+${res.url}`);
+      } catch (error) {
+        return errText4("Failed to update the meeting", error);
+      }
+    })
+  ];
+}
+function describeItem(item) {
+  const box = item.checked ? "[x]" : "[ ]";
+  const who = item.checked && item.checkedBy ? ` \u2014 ${item.checkedBy}` : "";
+  const card = item.linkedTaskSlug ? ` (${item.linkedTaskSlug})` : "";
+  return `${box} ${item.title}${who}${card}`;
+}
+function checklistTools(connection, projectId) {
+  return [
+    defineContractTool(addMeetingChecklistItemsContract, async (input) => {
+      try {
+        const res = await connection.call("addProjectMeetingChecklistItems", {
+          projectId,
+          meetingId: input.meetingId,
+          items: input.items
+        });
+        if (res.length === 0) {
+          return textResult("No items added \u2014 every title is already on this checklist.");
+        }
+        return textResult(`Added ${res.length}:
+${res.map(describeItem).join("\n")}`);
+      } catch (error) {
+        return errText4("Failed to add checklist items", error);
+      }
+    }),
+    defineContractTool(checkMeetingChecklistItemContract, async (input) => {
+      try {
+        const res = await connection.call("checkProjectMeetingChecklistItem", {
+          projectId,
+          meetingId: input.meetingId,
+          title: input.title,
+          checked: input.checked,
+          linkedTask: input.linkedTask
+        });
+        return textResult(describeItem(res));
+      } catch (error) {
+        return errText4("Failed to update the checklist item", error);
+      }
+    }),
+    defineContractTool(editMeetingChecklistItemContract, async (input) => {
+      try {
+        const res = await connection.call("editProjectMeetingChecklistItem", {
+          projectId,
+          meetingId: input.meetingId,
+          title: input.title,
+          newTitle: input.newTitle
+        });
+        return textResult(describeItem(res));
+      } catch (error) {
+        return errText4("Failed to edit the checklist item", error);
+      }
+    }),
+    defineContractTool(removeMeetingChecklistItemContract, async (input) => {
+      try {
+        const res = await connection.call("removeProjectMeetingChecklistItem", {
+          projectId,
+          meetingId: input.meetingId,
+          title: input.title
+        });
+        return textResult(`Removed "${res.title}".`);
+      } catch (error) {
+        return errText4("Failed to remove the checklist item", error);
+      }
+    })
+  ];
+}
 
 // src/tools/connected-tools.ts
 function connectedToolsFor(connection, context) {
@@ -11930,7 +12256,7 @@ function connectedToolsFor(connection, context) {
 // src/tools/code-review-tools.ts
 import { execFile } from "child_process";
 import { promisify } from "util";
-import { z as z19 } from "zod";
+import { z as z20 } from "zod";
 async function endReviewSession(connection, reason) {
   await connection.call("endReviewSession", {
     sessionId: connection.sessionId,
@@ -11938,26 +12264,26 @@ async function endReviewSession(connection, reason) {
   });
 }
 var RISK_LEVELS2 = ["critical", "high", "medium", "low"];
-var reviewedShaSchema = z19.string().regex(/^[0-9a-f]{40}$/i).describe("REQUIRED. The full 40-character commit SHA this verdict reviews.");
+var reviewedShaSchema = z20.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 = z19.strictObject({
-  reviewedSha: z19.string().regex(/^[0-9a-f]{40}$/i).describe(
+var ReviewGuideToolSchema = z20.strictObject({
+  reviewedSha: z20.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: 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(
+  overview: z20.string().min(1).max(6e4).describe("REQUIRED. Plain-text walkthrough intro, max 3000 characters. Keep it short."),
+  sections: z20.array(
+    z20.strictObject({
+      title: z20.string().min(1).max(160),
+      explanation: z20.string().min(1).max(2e3),
+      classification: z20.enum(["core", "supporting"]).optional(),
+      files: z20.array(
+        z20.strictObject({
+          path: z20.string().min(1).max(500).describe(
             "A file the PR's diff actually changed. Context files you merely read are rejected."
           ),
-          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(
+          startLine: z20.number().int().positive().max(1e6).optional(),
+          endLine: z20.number().int().positive().max(1e6).optional(),
+          hunkHeader: z20.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)."
           )
         })
@@ -12041,8 +12367,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: z19.string().describe("Brief summary of what was reviewed and why it looks good"),
-      risk: z19.enum(RISK_LEVELS2).describe(riskDescription)
+      summary: z20.string().describe("Brief summary of what was reviewed and why it looks good"),
+      risk: z20.enum(RISK_LEVELS2).describe(riskDescription)
     },
     async ({ reviewedSha, summary, risk }) => {
       const content = `**Code Review: Approved** :white_check_mark:
@@ -12073,16 +12399,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: 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")
+      issues: z20.array(
+        z20.object({
+          file: z20.string().describe("File path where the issue was found"),
+          line: z20.number().optional().describe("Line number (if applicable)"),
+          severity: z20.enum(["critical", "major", "minor"]).describe("Issue severity"),
+          description: z20.string().describe("What is wrong and how to fix it")
         })
       ).describe("List of issues found during review"),
-      summary: z19.string().describe("Brief overall summary of the review findings"),
-      risk: z19.enum(RISK_LEVELS2).describe(riskDescription)
+      summary: z20.string().describe("Brief overall summary of the review findings"),
+      risk: z20.enum(RISK_LEVELS2).describe(riskDescription)
     },
     async ({ reviewedSha, issues, summary, risk }) => {
       const issueLines = issues.map((issue) => {
@@ -12152,7 +12478,7 @@ function getModeTools(agentMode, connection, config, context) {
   }
 }
 function buildPrGuideToolsFor(effectiveMode, connection, config, context) {
-  const isLeafBuild = effectiveMode === "building" || effectiveMode === "auto";
+  const isLeafBuild = effectiveMode === "building" || effectiveMode === "auto" || effectiveMode === "chat";
   const isSinglePodPack = config.mode === "pack" && config.packExecution !== "fan-out";
   return (isLeafBuild || isSinglePodPack) && (isSinglePodPack || !context?.isParentTask) ? [
     buildPublishReviewGuideTool(connection, {
@@ -12639,10 +12965,14 @@ async function processAssistantCase(event, host, state) {
   }
   const usage = await handleAssistantCase(event, host, state.turnToolCalls);
   if (usage) state.lastAssistantUsage = usage;
-  if (!state.sawApiError) {
+  if (!state.sawApiError || event.isApiError && !state.terminalApiError) {
     const fullText = event.message.content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
     if (API_ERROR_PATTERN.test(fullText)) {
       state.sawApiError = true;
+      if (event.isApiError) {
+        state.terminalApiError = true;
+        state.apiErrorText = fullText.slice(0, 300);
+      }
     }
   }
 }
@@ -12657,7 +12987,7 @@ async function processResultCase(event, host, context, startTime, state) {
   );
   if (info.stoppedTyping) state.isTyping = false;
   state.retriable = info.retriable;
-  if (!info.retriable) state.sawApiError = false;
+  if (!info.retriable && !state.terminalApiError) state.sawApiError = false;
   state.resultSummary = info.resultSummary;
   if (info.staleSession) state.staleSession = true;
   if (info.authError) state.authError = true;
@@ -12678,6 +13008,8 @@ async function processEvents(events, context, host) {
     isTyping: false,
     retriable: false,
     sawApiError: false,
+    terminalApiError: false,
+    apiErrorText: void 0,
     resultSummary: void 0,
     rateLimitResetsAt: void 0,
     rateLimitRejectedType: void 0,
@@ -12720,8 +13052,12 @@ async function processEvents(events, context, host) {
   }
   flushPendingToolCalls(host, state.turnToolCalls);
   stopTypingIfNeeded(host, state.isTyping);
+  return buildProcessResult(state);
+}
+function buildProcessResult(state) {
   return {
     retriable: state.retriable || state.sawApiError,
+    ...state.apiErrorText && { apiErrorText: state.apiErrorText },
     resultSummary: state.resultSummary,
     rateLimitResetsAt: state.rateLimitResetsAt,
     ...state.rateLimitRejectedType && { rateLimitRejectedType: state.rateLimitRejectedType },
@@ -12964,25 +13300,6 @@ function handleReviewToolAccess(toolName, input) {
   }
   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 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) {
-  if (CREATE_PR_TOOL.test(toolName)) return true;
-  return toolName === "Bash" && CHAT_BLOCKED_BASH.test(String(input.command ?? ""));
-}
-async function chatCardHasPlan(host) {
-  try {
-    const props = await host.connection.getTaskProperties();
-    return !!props.plan?.trim();
-  } catch {
-    return false;
-  }
-}
 function handleAutoToolAccess(toolName, input, hasExitedPlanMode, isParentTask) {
   if (hasExitedPlanMode) {
     return isParentTask ? handleReviewToolAccess(toolName, input) : handleBuildingToolAccess(toolName, input);
@@ -13162,7 +13479,6 @@ function resolveToolAccess(host, toolName, input) {
 }
 function buildCanUseTool(host) {
   let consecutiveDenials = 0;
-  let chatHasPlan = false;
   return async (toolName, input) => {
     if (toolName === "ExitPlanMode" && (host.agentMode === "auto" || host.agentMode === "discovery") && !host.hasExitedPlanMode) {
       return await handleExitPlanMode(host, input);
@@ -13178,14 +13494,6 @@ function buildCanUseTool(host) {
     }
     const loopResult = checkToolLoop(host, toolName, input);
     if (loopResult) return loopResult;
-    if (host.agentMode === "chat" && isChatPrTool(toolName, input)) {
-      if (!chatHasPlan) chatHasPlan = await chatCardHasPlan(host);
-      if (!chatHasPlan) {
-        consecutiveDenials++;
-        handleDenialEscalation(host, consecutiveDenials);
-        return { behavior: "deny", message: CHAT_PLAN_GATE_MESSAGE };
-      }
-    }
     const result = resolveToolAccess(host, toolName, input);
     if (result.behavior === "deny") {
       consecutiveDenials++;
@@ -13955,11 +14263,13 @@ function handleProcessResult(result, context, host, options) {
 }
 async function runWithRetry(initialQuery, context, host, options) {
   let lastErrorWasImage = false;
+  let lastDetail = null;
   for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {
     if (host.isStopped()) return;
     const agentQuery = attempt === 0 ? initialQuery : await buildRetryQuery(host, context, options, lastErrorWasImage);
     try {
       const result = await processEvents(agentQuery, context, host);
+      if (result.apiErrorText) lastDetail = result.apiErrorText;
       const outcome = handleProcessResult(result, context, host, options);
       if (outcome.action === "return") return;
       if (outcome.action === "return_promise") return outcome.promise;
@@ -13968,12 +14278,16 @@ async function runWithRetry(initialQuery, context, host, options) {
       const outcome = handleRetryError(error, context, host, options, lastErrorWasImage);
       if (outcome instanceof Promise) return outcome;
       if (outcome.action === "return") return;
+      lastDetail = getErrorMessage(error).slice(0, 300);
       lastErrorWasImage = outcome.lastErrorWasImage;
     }
     if (attempt >= RETRY_DELAYS_MS.length) {
+      const detail = lastDetail ?? "API error";
       host.connection.postChatMessage(
-        `Agent shutting down after ${RETRY_DELAYS_MS.length} failed retry attempts due to API errors. The task will resume automatically when the codespace restarts.`
+        `Claude API calls kept failing (\`${detail}\`) through ${RETRY_DELAYS_MS.length} retries over ~${Math.round(RETRY_DELAYS_MS.reduce((a, b) => a + b, 0) / 6e4)} minutes. Handing the card back: it returns to Open and this environment goes to sleep.`
       );
+      host.apiOutageExhausted = true;
+      host.apiOutageDetail = detail;
       return;
     }
     await emitRetryStatus(host, attempt, RETRY_DELAYS_MS[attempt]);
@@ -14043,6 +14357,8 @@ var QueryBridge = class {
   _isParentTask = false;
   _wasRateLimited = false;
   _wedgeAborted = false;
+  _apiOutageExhausted = false;
+  _apiOutageDetail = null;
   _keyCycleCount = 0;
   _abortController = null;
   /** Called by SessionRunner when ExitPlanMode triggers a mode transition. */
@@ -14081,6 +14397,18 @@ var QueryBridge = class {
   get lastTurnWedgeAborted() {
     return this._wedgeAborted;
   }
+  /**
+   * Whether the turn that just ran ended with every Claude API retry
+   * exhausted. Reset at the start of every execute(); SessionRunner reads it
+   * to flush WIP and hand the card back to the server.
+   */
+  get lastTurnApiOutage() {
+    return this._apiOutageExhausted;
+  }
+  /** The API error text behind `lastTurnApiOutage`, or null. */
+  get lastTurnApiOutageDetail() {
+    return this._apiOutageDetail;
+  }
   /**
    * Ask the live terminal (PTY harness only) to redraw its full screen.
    * Safe no-op on the SDK harness or between queries.
@@ -14155,6 +14483,8 @@ var QueryBridge = class {
     this._stopped = false;
     this._wasRateLimited = false;
     this._wedgeAborted = false;
+    this._apiOutageExhausted = false;
+    this._apiOutageDetail = null;
     this._abortController = new AbortController();
     const host = this.buildHost();
     try {
@@ -14204,7 +14534,7 @@ var QueryBridge = class {
   // ── QueryHost construction ──────────────────────────────────────────
   buildHost() {
     const bridge = this;
-    return {
+    const host = {
       config: this.runnerConfig,
       connection: this.connection,
       callbacks: this.callbacks,
@@ -14247,12 +14577,6 @@ var QueryBridge = class {
       set wasRateLimited(val) {
         bridge._wasRateLimited = val;
       },
-      get wedgeAborted() {
-        return bridge._wedgeAborted;
-      },
-      set wedgeAborted(val) {
-        bridge._wedgeAborted = val;
-      },
       get keyCycleCount() {
         return bridge._keyCycleCount;
       },
@@ -14276,6 +14600,38 @@ var QueryBridge = class {
       createInputStream: (prompt) => bridge.createInputStream(prompt),
       onModeTransition: bridge.onModeTransition
     };
+    return Object.defineProperties(host, this.turnFlagDescriptors());
+  }
+  /**
+   * The per-turn recovery flags the executor writes and SessionRunner reads
+   * after the turn (`lastTurnWedgeAborted`, `lastTurnApiOutage`). Live
+   * accessors onto the bridge's backing fields, attached as descriptors
+   * because an object spread would snapshot a getter's value instead.
+   */
+  turnFlagDescriptors() {
+    return {
+      wedgeAborted: {
+        enumerable: true,
+        get: () => this._wedgeAborted,
+        set: (val) => {
+          this._wedgeAborted = val;
+        }
+      },
+      apiOutageExhausted: {
+        enumerable: true,
+        get: () => this._apiOutageExhausted,
+        set: (val) => {
+          this._apiOutageExhausted = val;
+        }
+      },
+      apiOutageDetail: {
+        enumerable: true,
+        get: () => this._apiOutageDetail,
+        set: (val) => {
+          this._apiOutageDetail = val;
+        }
+      }
+    };
   }
   // ── Input stream for Claude SDK ─────────────────────────────────────
   async *createInputStream(prompt) {
@@ -14769,7 +15125,7 @@ function resolveQuestionGraceMs() {
 }
 var QUESTION_TYPING_RECENT_MS = 6e4;
 var QUESTION_TYPING_DEFER_MS = 2 * 6e4;
-var QUESTION_TIMEOUT_PROMPT = 'No one answered your clarifying questions within 10 minutes. Do this now: (1) Save your findings-so-far as the card plan (`update_task`). (2) Post the unanswered questions to chat with `post_to_chat` using `milestone: "blocked"`, stating the assumption you would make for each. (3) If you can safely proceed on your best-judgment answers, state the assumptions and continue; otherwise end your turn \u2014 answers posted in chat will be delivered when you resume.';
+var QUESTION_TIMEOUT_PROMPT = 'No one answered your clarifying questions within 10 minutes. Do this now: (1) Save your findings-so-far as the card plan (`update_task`). (2) Post the unanswered questions to chat with `post_to_chat` using `milestone: "blocked"`, stating the assumption you would make for each (this is a parking note \u2014 the question already paged them). (3) If you can safely proceed on your best-judgment answers, state the assumptions and continue; otherwise end your turn \u2014 answers posted in chat will be delivered when you resume.';
 var SessionRunner = class _SessionRunner {
   connection;
   mode;
@@ -15620,6 +15976,27 @@ var SessionRunner = class _SessionRunner {
       }
       throw err;
     }
+    await this.handleApiOutageExhausted();
+  }
+  /**
+   * The turn ended with every Claude API retry exhausted (the CLI's own
+   * retries gave up, then `runWithRetry`'s fresh-session backoff did too).
+   * Push WIP first — the server sleeps this pod in response, so the flush
+   * must not race the teardown — then hand the card back. The core loop
+   * then falls into its normal idle wait; the server-driven sleep is what
+   * ends the pod, and nothing here exits the process or re-prompts.
+   *
+   * NOT a stuck nudge: this keys on the CLI's own error record, never on
+   * silence or idleness (see `.claude/rules/agent-runner.md`).
+   */
+  async handleApiOutageExhausted() {
+    if (!this.queryBridge?.lastTurnApiOutage) return;
+    process.stderr.write("[conveyor-agent] API retries exhausted \u2014 handing the card back\n");
+    await this.flushWipNow("WIP: API outage hand-off");
+    this.connection.reportApiOutage(
+      this.queryBridge.lastTurnApiOutageDetail ?? "API error",
+      RETRY_DELAYS_MS.length
+    );
   }
   /**
    * A human typed into the parked, idle Connected-TUI (keep-alive PTY). Wake the