@rallycry/conveyor-agent 10.12.0 → 10.13.0

package/dist/{chunk-CXNWRIS7.js → chunk-CHJ7JPAQ.js}

@@ -1902,1016 +1902,1109 @@ import { z } from "zod";
 import { z as z2 } from "zod";
 import { z as z3 } from "zod";
 import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var DEFAULT_SONNET_MODEL = "claude-sonnet-5";
 var FABLE_MODEL = "claude-fable-5";
 var TUI_KINDS = ["claude-code", "opencode"];
+var RISK_LEVELS = ["critical", "high", "medium", "low"];
+var riskLevelSchema = z.enum(RISK_LEVELS);
+var DEFAULT_RISK_LEVELS = [
+  {
+    level: "critical",
+    value: 4,
+    label: "Critical",
+    description: "Touches critical surface area; give it the closest review.",
+    color: "#dc2626",
+    ordinal: 0
+  },
+  {
+    level: "high",
+    value: 3,
+    label: "High",
+    description: "Touches important surface area; review carefully.",
+    color: "#ea580c",
+    ordinal: 1
+  },
+  {
+    level: "medium",
+    value: 2,
+    label: "Medium",
+    description: "Moderate surface area; normal review.",
+    color: "#d97706",
+    ordinal: 2
+  },
+  {
+    level: "low",
+    value: 1,
+    label: "Low",
+    description: "Small or isolated surface area.",
+    color: "#64748b",
+    ordinal: 3
+  }
+];
+var LEVEL_BY_VALUE = new Map(DEFAULT_RISK_LEVELS.map((m) => [m.value, m.level]));
+var ACTIVE_WORK_STATUSES = [
+  "InProgress",
+  "ReviewPR",
+  "ReviewDev",
+  "ReviewLive",
+  "Complete"
+];
+var IDENTIFIED_WORK_STATUSES = ["Open", ...ACTIVE_WORK_STATUSES];
 var MAX_FILE_SIZE_BYTES = 25 * 1024 * 1024;
 var EMBED_THRESHOLD_IMAGES = 5 * 1024 * 1024;
 var EMBED_THRESHOLD_TEXT = 2 * 1024 * 1024;
 var IDLE_HEARTBEAT_MS = 90 * 1e3;
-var TurnEndToolCallSchema = z.object({
-  tool: z.string(),
-  input: z.string().optional(),
-  output: z.string().optional(),
-  timestamp: z.string().optional()
+var TurnEndToolCallSchema = z2.object({
+  tool: z2.string(),
+  input: z2.string().optional(),
+  output: z2.string().optional(),
+  timestamp: z2.string().optional()
 }).passthrough();
-var KnownAgentEventSchema = z.discriminatedUnion("type", [
+var KnownAgentEventSchema = z2.discriminatedUnion("type", [
   // ── Lifecycle / connection ────────────────────────────────────────────
-  z.object({
-    type: z.literal("connected"),
-    sessionId: z.string(),
-    projectId: z.string().optional()
+  z2.object({
+    type: z2.literal("connected"),
+    sessionId: z2.string(),
+    projectId: z2.string().optional()
   }).passthrough(),
   // Open-ended context snapshot spread from buildInitializationContext().
-  z.object({ type: z.literal("session_manifest") }).passthrough(),
-  z.object({
-    type: z.literal("agent_runner_status"),
-    reason: z.string(),
-    attempt: z.number().optional(),
-    attempts: z.number().optional()
+  z2.object({ type: z2.literal("session_manifest") }).passthrough(),
+  z2.object({
+    type: z2.literal("agent_runner_status"),
+    reason: z2.string(),
+    attempt: z2.number().optional(),
+    attempts: z2.number().optional()
   }).passthrough(),
-  z.object({ type: z.literal("shutdown"), reason: z.string().optional() }).passthrough(),
-  z.object({ type: z.literal("mode_changed"), agentMode: z.string() }).passthrough(),
-  z.object({ type: z.literal("mode_transition"), from: z.string(), to: z.string() }).passthrough(),
+  z2.object({ type: z2.literal("shutdown"), reason: z2.string().optional() }).passthrough(),
+  z2.object({ type: z2.literal("mode_changed"), agentMode: z2.string() }).passthrough(),
+  z2.object({ type: z2.literal("mode_transition"), from: z2.string(), to: z2.string() }).passthrough(),
   // ── Turn stream ───────────────────────────────────────────────────────
-  z.object({ type: z.literal("message"), content: z.string() }).passthrough(),
-  z.object({ type: z.literal("thinking"), message: z.string() }).passthrough(),
-  z.object({
-    type: z.literal("tool_use"),
-    tool: z.string(),
+  z2.object({ type: z2.literal("message"), content: z2.string() }).passthrough(),
+  z2.object({ type: z2.literal("thinking"), message: z2.string() }).passthrough(),
+  z2.object({
+    type: z2.literal("tool_use"),
+    tool: z2.string(),
     // Producers send JSON.stringify(input); consumers defend against
     // object inputs from older agents, so the wire stays permissive here.
-    input: z.unknown().optional()
+    input: z2.unknown().optional()
   }).passthrough(),
-  z.object({
-    type: z.literal("tool_result"),
-    tool: z.string(),
-    output: z.unknown().optional(),
-    isError: z.boolean().optional(),
-    redactedCount: z.number().optional()
+  z2.object({
+    type: z2.literal("tool_result"),
+    tool: z2.string(),
+    output: z2.unknown().optional(),
+    isError: z2.boolean().optional(),
+    redactedCount: z2.number().optional()
   }).passthrough(),
-  z.object({ type: z.literal("turn_end"), toolCalls: z.array(TurnEndToolCallSchema) }).passthrough(),
-  z.object({
-    type: z.literal("completed"),
-    summary: z.string().optional(),
-    durationMs: z.number().optional()
+  z2.object({ type: z2.literal("turn_end"), toolCalls: z2.array(TurnEndToolCallSchema) }).passthrough(),
+  z2.object({
+    type: z2.literal("completed"),
+    summary: z2.string().optional(),
+    durationMs: z2.number().optional()
   }).passthrough(),
-  z.object({ type: z.literal("error"), message: z.string() }).passthrough(),
-  z.object({ type: z.literal("agent_typing_start") }).passthrough(),
-  z.object({ type: z.literal("agent_typing_stop") }).passthrough(),
+  z2.object({ type: z2.literal("error"), message: z2.string() }).passthrough(),
+  z2.object({ type: z2.literal("agent_typing_start") }).passthrough(),
+  z2.object({ type: z2.literal("agent_typing_stop") }).passthrough(),
   // ── Telemetry ─────────────────────────────────────────────────────────
   // heartbeat/typing: legacy telemetry the server still classifies as
   // transient (TRANSIENT_EVENT_TYPES) — kept in the vocabulary.
-  z.object({ type: z.literal("heartbeat") }).passthrough(),
-  z.object({ type: z.literal("typing") }).passthrough(),
-  z.object({
-    type: z.literal("context_update"),
-    contextTokens: z.number(),
-    contextWindow: z.number(),
-    inputTokens: z.number().optional(),
-    cacheReadInputTokens: z.number().optional(),
-    cacheCreationInputTokens: z.number().optional(),
-    totalTokensUsed: z.number().optional()
+  z2.object({ type: z2.literal("heartbeat") }).passthrough(),
+  z2.object({ type: z2.literal("typing") }).passthrough(),
+  z2.object({
+    type: z2.literal("context_update"),
+    contextTokens: z2.number(),
+    contextWindow: z2.number(),
+    inputTokens: z2.number().optional(),
+    cacheReadInputTokens: z2.number().optional(),
+    cacheCreationInputTokens: z2.number().optional(),
+    totalTokensUsed: z2.number().optional()
   }).passthrough(),
-  // Two producer shapes share this type: {rateLimitType, utilization, status}
-  // (SDK rate_limit_event) and {resetsAt} (agent-connection resume notice).
-  z.object({
-    type: z.literal("rate_limit_update"),
-    rateLimitType: z.string().optional(),
-    utilization: z.number().optional(),
-    status: z.string().optional(),
-    resetsAt: z.string().optional()
+  // Three producer shapes share this type: {rateLimitType, utilization, status}
+  // (SDK rate_limit_event), {resetsAt} (agent-connection resume notice), and
+  // the usage-sampler ({rateLimitType, utilization, status, resetsAt, gauges}
+  // — resetsAt matches rateLimitType; gauges survives via .passthrough()).
+  z2.object({
+    type: z2.literal("rate_limit_update"),
+    rateLimitType: z2.string().optional(),
+    utilization: z2.number().optional(),
+    status: z2.string().optional(),
+    resetsAt: z2.string().optional()
   }).passthrough(),
-  z.object({
-    type: z.literal("context_compacted"),
-    trigger: z.string().optional(),
-    preTokens: z.number().optional()
+  z2.object({
+    type: z2.literal("context_compacted"),
+    trigger: z2.string().optional(),
+    preTokens: z2.number().optional()
   }).passthrough(),
-  z.object({
-    type: z.literal("tool_progress"),
-    toolName: z.string().optional(),
-    elapsedSeconds: z.number().optional()
+  z2.object({
+    type: z2.literal("tool_progress"),
+    toolName: z2.string().optional(),
+    elapsedSeconds: z2.number().optional()
   }).passthrough(),
-  z.object({
-    type: z.literal("subagent_started"),
-    sdkTaskId: z.string().optional(),
-    description: z.string().optional()
+  z2.object({
+    type: z2.literal("subagent_started"),
+    sdkTaskId: z2.string().optional(),
+    description: z2.string().optional()
   }).passthrough(),
-  z.object({
-    type: z.literal("subagent_progress"),
-    sdkTaskId: z.string().optional(),
-    description: z.string().optional(),
-    toolUses: z.number().optional(),
-    durationMs: z.number().optional()
+  z2.object({
+    type: z2.literal("subagent_progress"),
+    sdkTaskId: z2.string().optional(),
+    description: z2.string().optional(),
+    toolUses: z2.number().optional(),
+    durationMs: z2.number().optional()
   }).passthrough(),
   // ── Work products ─────────────────────────────────────────────────────
-  z.object({ type: z.literal("pr_created"), url: z.string(), number: z.number() }).passthrough(),
-  z.object({
-    type: z.literal("code_review_complete"),
-    result: z.enum(["approved", "changes_requested"]),
-    summary: z.string().optional(),
-    issues: z.array(
-      z.object({
-        file: z.string(),
-        line: z.number().optional(),
-        severity: z.string().optional(),
-        description: z.string().optional()
+  z2.object({ type: z2.literal("pr_created"), url: z2.string(), number: z2.number() }).passthrough(),
+  z2.object({
+    type: z2.literal("code_review_complete"),
+    result: z2.enum(["approved", "changes_requested"]),
+    summary: z2.string().optional(),
+    issues: z2.array(
+      z2.object({
+        file: z2.string(),
+        line: z2.number().optional(),
+        severity: z2.string().optional(),
+        description: z2.string().optional()
       }).passthrough()
     ).optional()
   }).passthrough(),
   // ── Environment setup / start command ─────────────────────────────────
-  z.object({ type: z.literal("setup_output"), stream: z.string(), data: z.string() }).passthrough(),
-  z.object({
-    type: z.literal("setup_complete"),
-    startCommandRunning: z.boolean().optional(),
+  z2.object({ type: z2.literal("setup_output"), stream: z2.string(), data: z2.string() }).passthrough(),
+  z2.object({
+    type: z2.literal("setup_complete"),
+    startCommandRunning: z2.boolean().optional(),
     // Sanitized server-side by sanitizeSessionPreviewPorts — stays unknown.
-    previewPorts: z.unknown().optional()
+    previewPorts: z2.unknown().optional()
   }).passthrough(),
-  z.object({ type: z.literal("setup_error"), message: z.string() }).passthrough(),
-  z.object({ type: z.literal("start_command_started") }).passthrough(),
-  z.object({ type: z.literal("start_command_output"), stream: z.string(), data: z.string() }).passthrough(),
-  z.object({
-    type: z.literal("start_command_exited"),
-    code: z.number().nullable().optional(),
-    signal: z.string().nullable().optional(),
-    message: z.string().optional()
+  z2.object({ type: z2.literal("setup_error"), message: z2.string() }).passthrough(),
+  z2.object({ type: z2.literal("start_command_started") }).passthrough(),
+  z2.object({ type: z2.literal("start_command_output"), stream: z2.string(), data: z2.string() }).passthrough(),
+  z2.object({
+    type: z2.literal("start_command_exited"),
+    code: z2.number().nullable().optional(),
+    signal: z2.string().nullable().optional(),
+    message: z2.string().optional()
   }).passthrough(),
-  z.object({ type: z.literal("start_command_error"), message: z.string() }).passthrough()
+  z2.object({ type: z2.literal("start_command_error"), message: z2.string() }).passthrough()
 ]);
-var AgentEventSchema = z.union([
+var AgentEventSchema = z2.union([
   KnownAgentEventSchema,
-  z.object({ type: z.string().min(1) }).catchall(z.unknown())
+  z2.object({ type: z2.string().min(1) }).catchall(z2.unknown())
 ]);
-var AgentHeartbeatSchema = z2.object({
-  sessionId: z2.string().optional(),
-  timestamp: z2.string(),
-  status: z2.enum(["active", "idle", "building"]),
-  currentAction: z2.string().optional(),
+var AgentHeartbeatSchema = z3.object({
+  sessionId: z3.string().optional(),
+  timestamp: z3.string(),
+  status: z3.enum(["active", "idle", "building"]),
+  currentAction: z3.string().optional(),
   /** Sender-observed main event-loop lag (ms) — see AgentHeartbeat.loopLagMs. */
-  loopLagMs: z2.number().nonnegative().optional()
+  loopLagMs: z3.number().nonnegative().optional()
 });
-var CreatePRInputSchema = z2.object({
-  title: z2.string().min(1),
-  body: z2.string(),
-  head: z2.string().optional(),
-  base: z2.string().optional()
+var CreatePRInputSchema = z3.object({
+  title: z3.string().min(1),
+  body: z3.string(),
+  head: z3.string().optional(),
+  base: z3.string().optional()
 });
-var PostToChatInputSchema = z2.object({
-  message: z2.string().min(1),
-  type: z2.enum(["message", "question", "update"]).optional().default("message")
+var PostToChatInputSchema = z3.object({
+  message: z3.string().min(1),
+  type: z3.enum(["message", "question", "update"]).optional().default("message")
 });
-var GetTaskContextRequestSchema = z2.object({
-  sessionId: z2.string(),
-  includeHistory: z2.boolean().optional().default(false)
+var GetTaskContextRequestSchema = z3.object({
+  sessionId: z3.string(),
+  includeHistory: z3.boolean().optional().default(false)
 });
-var GetChatMessagesRequestSchema = z2.object({
-  sessionId: z2.string(),
-  limit: z2.number().int().positive().optional().default(50),
-  offset: z2.number().int().nonnegative().optional().default(0)
+var GetChatMessagesRequestSchema = z3.object({
+  sessionId: z3.string(),
+  limit: z3.number().int().positive().optional().default(50),
+  offset: z3.number().int().nonnegative().optional().default(0)
 });
-var GetTaskFilesRequestSchema = z2.object({
-  sessionId: z2.string()
+var GetTaskFilesRequestSchema = z3.object({
+  sessionId: z3.string()
 });
-var GetTaskFileRequestSchema = z2.object({
-  sessionId: z2.string(),
-  fileId: z2.string()
+var GetTaskFileRequestSchema = z3.object({
+  sessionId: z3.string(),
+  fileId: z3.string()
 });
-var GetTaskRequestSchema = z2.object({
-  sessionId: z2.string(),
-  taskSlugOrId: z2.string()
+var GetTaskRequestSchema = z3.object({
+  sessionId: z3.string(),
+  taskSlugOrId: z3.string()
 });
-var GetCliHistoryRequestSchema = z2.object({
-  sessionId: z2.string(),
-  limit: z2.number().int().positive().optional().default(100),
-  source: z2.enum(["agent", "application"]).optional()
+var GetCliHistoryRequestSchema = z3.object({
+  sessionId: z3.string(),
+  limit: z3.number().int().positive().optional().default(100),
+  source: z3.enum(["agent", "application"]).optional()
 });
-var ListSubtasksRequestSchema = z2.object({
-  sessionId: z2.string(),
+var ListSubtasksRequestSchema = z3.object({
+  sessionId: z3.string(),
   /** "compact" returns the slim orchestration view (ListSubtasksCompactResponse)
    * with the pack build-slot picture; "full" (default — wire-compat with older
    * agents) returns the verbose SubtaskSummaryDTO[] including description/plan. */
-  view: z2.enum(["compact", "full"]).optional()
-});
-var GetDependenciesRequestSchema = z2.object({
-  sessionId: z2.string()
-});
-var GetSuggestionsRequestSchema = z2.object({
-  sessionId: z2.string(),
-  status: z2.string().optional(),
-  limit: z2.number().int().min(1).max(100).optional()
-});
-var ListManualTestsRequestSchema = z2.object({
-  sessionId: z2.string()
-});
-var QueryManualTestsRequestSchema = z2.object({
-  sessionId: z2.string(),
-  cardStatuses: z2.array(z2.string()).optional(),
-  testStatuses: z2.array(z2.enum(["open", "approved", "rejected"])).optional()
-});
-var CreatePullRequestRequestSchema = CreatePRInputSchema.extend({ sessionId: z2.string() });
-var RequestFileUploadRequestSchema = z2.object({
-  sessionId: z2.string(),
-  fileName: z2.string().min(1).max(255),
-  mimeType: z2.string().min(1).max(128),
-  fileSize: z2.number().int().positive().max(MAX_FILE_SIZE_BYTES)
-});
-var ConfirmFileUploadRequestSchema = z2.object({
-  sessionId: z2.string(),
-  fileId: z2.string(),
-  title: z2.string().max(500).optional()
-});
-var UpdateTaskStatusRequestSchema = z2.object({
-  sessionId: z2.string(),
-  status: z2.string(),
-  force: z2.boolean().optional().default(false)
-});
-var StoreSessionIdRequestSchema = z2.object({
-  sessionId: z2.string(),
-  sdkSessionId: z2.string()
-});
-var SetManualTestsRequestSchema = z2.object({
-  sessionId: z2.string(),
-  items: z2.array(z2.object({ title: z2.string().min(1) })).min(1)
-});
-var EditManualTestRequestSchema = z2.object({
-  sessionId: z2.string(),
-  title: z2.string().min(1),
-  newTitle: z2.string().min(1)
-});
-var RemoveManualTestRequestSchema = z2.object({
-  sessionId: z2.string(),
-  title: z2.string().min(1)
-});
-var ApproveManualTestRequestSchema = z2.object({
-  sessionId: z2.string(),
-  title: z2.string().min(1)
-});
-var RejectManualTestRequestSchema = z2.object({
-  sessionId: z2.string(),
-  title: z2.string().min(1),
-  reason: z2.string().min(1).max(2e3)
-});
-var SessionStartRequestSchema = z2.object({
-  sessionId: z2.string(),
-  agentVersion: z2.string(),
-  capabilities: z2.array(z2.string())
-});
-var SessionStopRequestSchema = z2.object({
-  sessionId: z2.string(),
-  reason: z2.string().optional()
-});
-var EndReviewSessionRequestSchema = z2.object({
-  sessionId: z2.string(),
-  reason: z2.enum(["approved", "changes_requested", "finished"]).optional()
-});
-var ConnectAgentRequestSchema = z2.object({
-  sessionId: z2.string()
-});
-var ReportAgentStatusRequestSchema = z2.object({
-  sessionId: z2.string(),
-  status: z2.string(),
+  view: z3.enum(["compact", "full"]).optional()
+});
+var GetDependenciesRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var GetSuggestionsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  status: z3.string().optional(),
+  limit: z3.number().int().min(1).max(100).optional()
+});
+var ListManualTestsRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var QueryManualTestsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  cardStatuses: z3.array(z3.string()).optional(),
+  testStatuses: z3.array(z3.enum(["open", "approved", "rejected"])).optional()
+});
+var CreatePullRequestRequestSchema = CreatePRInputSchema.extend({ sessionId: z3.string() });
+var RequestFileUploadRequestSchema = z3.object({
+  sessionId: z3.string(),
+  fileName: z3.string().min(1).max(255),
+  mimeType: z3.string().min(1).max(128),
+  fileSize: z3.number().int().positive().max(MAX_FILE_SIZE_BYTES)
+});
+var ConfirmFileUploadRequestSchema = z3.object({
+  sessionId: z3.string(),
+  fileId: z3.string(),
+  title: z3.string().max(500).optional()
+});
+var UpdateTaskStatusRequestSchema = z3.object({
+  sessionId: z3.string(),
+  status: z3.string(),
+  force: z3.boolean().optional().default(false)
+});
+var StoreSessionIdRequestSchema = z3.object({
+  sessionId: z3.string(),
+  sdkSessionId: z3.string()
+});
+var SetManualTestsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  items: z3.array(z3.object({ title: z3.string().min(1) })).min(1)
+});
+var EditManualTestRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1),
+  newTitle: z3.string().min(1)
+});
+var RemoveManualTestRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1)
+});
+var ApproveManualTestRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1)
+});
+var RejectManualTestRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1),
+  reason: z3.string().min(1).max(2e3)
+});
+var SessionStartRequestSchema = z3.object({
+  sessionId: z3.string(),
+  agentVersion: z3.string(),
+  capabilities: z3.array(z3.string())
+});
+var SessionStopRequestSchema = z3.object({
+  sessionId: z3.string(),
+  reason: z3.string().optional()
+});
+var EndReviewSessionRequestSchema = z3.object({
+  sessionId: z3.string(),
+  reason: z3.enum(["approved", "changes_requested", "finished"]).optional()
+});
+var ConnectAgentRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var ReportAgentStatusRequestSchema = z3.object({
+  sessionId: z3.string(),
+  status: z3.string(),
   /** Why the agent reports this status (e.g. "user_question" while an AskUserQuestion questionnaire is pending in the TUI). */
-  reason: z2.string().optional(),
+  reason: z3.string().optional(),
   /**
    * The pending question text, sent only alongside `reason: "user_question"`
    * so the server can surface it in the user-question notification body (and
    * thus the Attention feed) instead of a generic string. Optional: older
    * agents omit it and the server falls back to the generic wording.
    */
-  questionText: z2.string().optional()
-});
-var NotifyAgentVersionRequestSchema = z2.object({
-  sessionId: z2.string(),
-  agentVersion: z2.string()
-});
-var DiscoveredPortSchema = z2.object({
-  port: z2.number().int().min(1).max(65535),
-  label: z2.string().min(1).max(64).optional(),
-  protocol: z2.enum(["http", "tcp"]).optional(),
-  detectedAt: z2.string()
-});
-var ReportDiscoveredPortsRequestSchema = z2.object({
-  sessionId: z2.string(),
-  ports: z2.array(DiscoveredPortSchema).max(64)
-});
-var CreateSubtaskRequestSchema = z2.object({
-  sessionId: z2.string(),
-  title: z2.string().min(1),
-  description: z2.string().optional(),
-  plan: z2.string().optional(),
-  storyPointValue: z2.number().int().positive().optional(),
-  ordinal: z2.number().int().nonnegative().optional(),
-  followParentStatus: z2.boolean().optional(),
+  questionText: z3.string().optional()
+});
+var NotifyAgentVersionRequestSchema = z3.object({
+  sessionId: z3.string(),
+  agentVersion: z3.string()
+});
+var DiscoveredPortSchema = z3.object({
+  port: z3.number().int().min(1).max(65535),
+  label: z3.string().min(1).max(64).optional(),
+  protocol: z3.enum(["http", "tcp"]).optional(),
+  detectedAt: z3.string()
+});
+var ReportDiscoveredPortsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  ports: z3.array(DiscoveredPortSchema).max(64)
+});
+var CreateSubtaskRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1),
+  description: z3.string().optional(),
+  plan: z3.string().optional(),
+  storyPointValue: z3.number().int().positive().optional(),
+  ordinal: z3.number().int().nonnegative().optional(),
+  followParentStatus: z3.boolean().optional(),
   /** Sibling subtask ids or slugs this subtask blocks on (explicit dependency
    * metadata — preferred over encoding order in plan text / ordinal). */
-  dependsOn: z2.array(z2.string().min(1)).max(32).optional()
-});
-var UpdateSubtaskRequestSchema = z2.object({
-  sessionId: z2.string(),
-  subtaskId: z2.string(),
-  title: z2.string().min(1).optional(),
-  description: z2.string().optional(),
-  plan: z2.string().optional(),
+  dependsOn: z3.array(z3.string().min(1)).max(32).optional()
+});
+var UpdateSubtaskRequestSchema = z3.object({
+  sessionId: z3.string(),
+  subtaskId: z3.string(),
+  title: z3.string().min(1).optional(),
+  description: z3.string().optional(),
+  plan: z3.string().optional(),
   /** Orchestration statuses only ("Planning" | "Open") — the pack parent's
    * sanctioned promotion path. Execution statuses stay with the build
    * pipeline / force_update_task_status. Enforced server-side. */
-  status: z2.string().optional(),
+  status: z3.string().optional(),
   /** Assign a project agent to the child — accepts the agent's id or exact
    * name; resolved against the parent task's project server-side. */
-  agentIdOrName: z2.string().min(1).optional(),
-  storyPointValue: z2.number().int().positive().optional(),
-  followParentStatus: z2.boolean().optional(),
+  agentIdOrName: z3.string().min(1).optional(),
+  storyPointValue: z3.number().int().positive().optional(),
+  followParentStatus: z3.boolean().optional(),
   /** Replace this subtask's dependency edges with these sibling ids/slugs.
    * Empty array clears all. Omit to leave dependencies unchanged. */
-  dependsOn: z2.array(z2.string().min(1)).max(32).optional()
-});
-var DeleteSubtaskRequestSchema = z2.object({
-  sessionId: z2.string(),
-  subtaskId: z2.string()
-});
-var GetTaskPropertiesRequestSchema = z2.object({
-  sessionId: z2.string()
-});
-var UpdateTaskFieldsRequestSchema = z2.object({
-  sessionId: z2.string(),
-  plan: z2.string().optional(),
-  description: z2.string().optional()
-});
-var UpdateTaskPropertiesRequestSchema = z2.object({
-  sessionId: z2.string(),
-  title: z2.string().optional(),
-  storyPointValue: z2.number().int().positive().optional(),
-  tagIds: z2.array(z2.string()).optional(),
-  tagNames: z2.array(z2.string()).optional(),
-  githubPRUrl: z2.string().url().optional(),
-  githubBranch: z2.string().optional()
-});
-var ListIconsRequestSchema = z2.object({
-  sessionId: z2.string()
-});
-var GenerateTaskIconRequestSchema = z2.object({
-  sessionId: z2.string(),
-  prompt: z2.string().min(1),
-  aspectRatio: z2.string().optional()
-});
-var SearchFaIconsRequestSchema = z2.object({
-  sessionId: z2.string(),
-  query: z2.string().min(1),
-  first: z2.number().int().positive().optional()
-});
-var PickFaIconRequestSchema = z2.object({
-  sessionId: z2.string(),
-  fontAwesomeId: z2.string().min(1),
-  fontAwesomeStyle: z2.string().optional()
-});
-var CreateFollowUpTaskRequestSchema = z2.object({
-  sessionId: z2.string(),
-  title: z2.string().min(1),
-  description: z2.string().optional(),
-  plan: z2.string().optional(),
-  storyPointValue: z2.number().int().positive().optional()
-});
-var AddDependencyRequestSchema = z2.object({
-  sessionId: z2.string(),
-  dependsOnSlugOrId: z2.string()
-});
-var RemoveDependencyRequestSchema = z2.object({
-  sessionId: z2.string(),
-  dependsOnSlugOrId: z2.string()
-});
-var CreateSuggestionRequestSchema = z2.object({
-  sessionId: z2.string(),
-  title: z2.string().min(1),
-  description: z2.string().optional(),
-  tagNames: z2.array(z2.string()).optional()
-});
-var VoteSuggestionRequestSchema = z2.object({
-  sessionId: z2.string(),
-  suggestionId: z2.string(),
-  value: z2.union([z2.literal(1), z2.literal(-1)])
-});
-var TriggerIdentificationRequestSchema = z2.object({
-  sessionId: z2.string()
-});
-var SubmitCodeReviewResultRequestSchema = z2.object({
-  sessionId: z2.string(),
-  approved: z2.boolean(),
-  content: z2.string()
-});
-var CycleCodingAgentKeyRequestSchema = z2.object({
-  sessionId: z2.string(),
-  rateLimitType: z2.string(),
-  resetsAt: z2.string().optional()
-});
-var StartChildCloudBuildRequestSchema = z2.object({
-  sessionId: z2.string(),
-  childTaskId: z2.string()
-});
-var StopChildBuildRequestSchema = z2.object({
-  sessionId: z2.string(),
-  childTaskId: z2.string()
-});
-var ApproveAndMergePRRequestSchema = z2.object({
-  sessionId: z2.string(),
-  childTaskId: z2.string()
-});
-var PostChildChatMessageRequestSchema = z2.object({
-  sessionId: z2.string(),
-  childTaskId: z2.string(),
-  message: z2.string().min(1)
-});
-var UpdateChildStatusRequestSchema = z2.object({
-  sessionId: z2.string(),
-  childTaskId: z2.string(),
-  status: z2.string()
-});
-var GetAgentStatusRequestSchema = z2.object({
-  taskId: z2.string()
-});
-var GetUiCliHistoryRequestSchema = z2.object({
-  taskId: z2.string()
-});
-var GetActivePtySessionRequestSchema = z2.object({
-  taskId: z2.string()
-});
-var ListActivePtySessionsRequestSchema = z2.object({
-  taskId: z2.string()
-});
-var SendSoftStopRequestSchema = z2.object({
-  taskId: z2.string()
-});
-var StopTaskSessionRequestSchema = z2.object({
-  taskId: z2.string(),
-  sessionId: z2.string()
-});
-var FlushTaskQueueRequestSchema = z2.object({
-  taskId: z2.string(),
-  softStop: z2.boolean().optional()
-});
-var CancelTaskQueuedMessageRequestSchema = z2.object({
-  taskId: z2.string(),
-  messageId: z2.string()
-});
-var FlushSingleQueuedMessageRequestSchema = z2.object({
-  taskId: z2.string(),
-  messageId: z2.string(),
-  softStop: z2.boolean().optional()
-});
-var AnswerAgentQuestionRequestSchema = z2.object({
-  taskId: z2.string(),
-  requestId: z2.string(),
-  answers: z2.record(z2.string(), z2.string())
-});
-var ClearAgentTodosRequestSchema = z2.object({
-  taskId: z2.string()
-});
-var AgentQuestionOptionSchema = z2.object({
-  label: z2.string(),
-  description: z2.string(),
-  preview: z2.string().optional()
-});
-var AgentQuestionSchema = z2.object({
-  question: z2.string(),
-  header: z2.string(),
-  options: z2.array(AgentQuestionOptionSchema),
-  multiSelect: z2.boolean().optional()
-});
-var AskUserQuestionRequestSchema = z2.object({
-  sessionId: z2.string(),
-  question: z2.string().min(1),
-  requestId: z2.string().min(1),
-  questions: z2.array(AgentQuestionSchema).min(1)
-});
-var EmitAgentEventRequestSchema = z2.object({
-  sessionId: z2.string(),
-  events: z2.array(AgentEventSchema).max(500)
-});
-var RefreshGithubTokenRequestSchema = z2.object({
-  sessionId: z2.string()
+  dependsOn: z3.array(z3.string().min(1)).max(32).optional()
 });
-var ReportReviewSpawnFailureRequestSchema = z2.object({
-  sessionId: z2.string(),
-  reviewSessionId: z2.string(),
-  error: z2.string().max(2e3).optional()
-});
-var SpawnTaskSessionRequestSchema = z2.object({
-  taskId: z2.string(),
-  kind: z2.enum(["tui", "shell"])
+var DeleteSubtaskRequestSchema = z3.object({
+  sessionId: z3.string(),
+  subtaskId: z3.string()
 });
-var SpawnTaskReviewRequestSchema = z2.object({
-  taskId: z2.string()
+var GetTaskPropertiesRequestSchema = z3.object({
+  sessionId: z3.string()
 });
-var ReportSessionSpawnFailureRequestSchema = z2.object({
-  sessionId: z2.string(),
-  spawnedSessionId: z2.string(),
-  error: z2.string().max(2e3).optional()
+var UpdateTaskFieldsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  plan: z3.string().optional(),
+  description: z3.string().optional()
 });
-var RefreshGithubTokenResponseSchema = z2.object({
-  token: z2.string()
+var UpdateTaskPropertiesRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().optional(),
+  storyPointValue: z3.number().int().positive().optional(),
+  tagIds: z3.array(z3.string()).optional(),
+  tagNames: z3.array(z3.string()).optional(),
+  githubPRUrl: z3.string().url().optional(),
+  githubBranch: z3.string().optional()
 });
-var PTY_FRAME_MAX_CHARS = 256 * 1024;
-var PTY_MAX_DIMENSION = 1e3;
-var PtyOutputRequestSchema = z2.object({
-  sessionId: z2.string(),
-  data: z2.string().max(PTY_FRAME_MAX_CHARS),
-  cols: z2.number().int().positive().max(PTY_MAX_DIMENSION).optional(),
-  rows: z2.number().int().positive().max(PTY_MAX_DIMENSION).optional()
+var ListIconsRequestSchema = z3.object({
+  sessionId: z3.string()
 });
-var PtyEndedRequestSchema = z2.object({
-  sessionId: z2.string()
+var GenerateTaskIconRequestSchema = z3.object({
+  sessionId: z3.string(),
+  prompt: z3.string().min(1),
+  aspectRatio: z3.string().optional()
 });
-var PtyInputRequestSchema = z2.object({
-  sessionId: z2.string(),
-  data: z2.string().max(PTY_FRAME_MAX_CHARS)
+var SearchFaIconsRequestSchema = z3.object({
+  sessionId: z3.string(),
+  query: z3.string().min(1),
+  first: z3.number().int().positive().optional()
 });
-var PtyResizeRequestSchema = z2.object({
-  sessionId: z2.string(),
-  cols: z2.number().int().positive().max(PTY_MAX_DIMENSION),
-  rows: z2.number().int().positive().max(PTY_MAX_DIMENSION)
+var PickFaIconRequestSchema = z3.object({
+  sessionId: z3.string(),
+  fontAwesomeId: z3.string().min(1),
+  fontAwesomeStyle: z3.string().optional()
 });
-var PtyAttachRequestSchema = z2.object({
-  sessionId: z2.string()
+var CreateFollowUpTaskRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1),
+  description: z3.string().optional(),
+  plan: z3.string().optional(),
+  storyPointValue: z3.number().int().positive().optional()
 });
-var PtyChatEventPayloadSchema = z2.discriminatedUnion("kind", [
-  z2.object({
-    kind: z2.literal("init"),
-    model: z2.string().max(200),
-    claudeSessionId: z2.string().max(100).optional()
+var AddDependencyRequestSchema = z3.object({
+  sessionId: z3.string(),
+  dependsOnSlugOrId: z3.string()
+});
+var RemoveDependencyRequestSchema = z3.object({
+  sessionId: z3.string(),
+  dependsOnSlugOrId: z3.string()
+});
+var CreateSuggestionRequestSchema = z3.object({
+  sessionId: z3.string(),
+  title: z3.string().min(1),
+  description: z3.string().optional(),
+  tagNames: z3.array(z3.string()).optional()
+});
+var VoteSuggestionRequestSchema = z3.object({
+  sessionId: z3.string(),
+  suggestionId: z3.string(),
+  value: z3.union([z3.literal(1), z3.literal(-1)])
+});
+var TriggerIdentificationRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var SubmitCodeReviewResultRequestSchema = z3.object({
+  sessionId: z3.string(),
+  approved: z3.boolean(),
+  content: z3.string(),
+  // Canonical risk derived by the reviewer (approve → low; changes → max issue
+  // severity). Applied raise-only server-side; never lowers an explicit value.
+  risk: riskLevelSchema.optional(),
+  // The commit SHA the reviewer actually reviewed. When present, the verdict is
+  // rejected unless the task is still at this SHA (guards against a late
+  // old-SHA verdict overwriting a newer review cycle).
+  reviewedSha: z3.string().optional()
+});
+var CycleCodingAgentKeyRequestSchema = z3.object({
+  sessionId: z3.string(),
+  rateLimitType: z3.string(),
+  resetsAt: z3.string().optional()
+});
+var StartChildCloudBuildRequestSchema = z3.object({
+  sessionId: z3.string(),
+  childTaskId: z3.string()
+});
+var StopChildBuildRequestSchema = z3.object({
+  sessionId: z3.string(),
+  childTaskId: z3.string()
+});
+var ApproveAndMergePRRequestSchema = z3.object({
+  sessionId: z3.string(),
+  childTaskId: z3.string()
+});
+var PostChildChatMessageRequestSchema = z3.object({
+  sessionId: z3.string(),
+  childTaskId: z3.string(),
+  message: z3.string().min(1)
+});
+var UpdateChildStatusRequestSchema = z3.object({
+  sessionId: z3.string(),
+  childTaskId: z3.string(),
+  status: z3.string()
+});
+var GetAgentStatusRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var GetUiCliHistoryRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var GetActivePtySessionRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var ListActivePtySessionsRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var SendSoftStopRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var StopTaskSessionRequestSchema = z3.object({
+  taskId: z3.string(),
+  sessionId: z3.string()
+});
+var FlushTaskQueueRequestSchema = z3.object({
+  taskId: z3.string(),
+  softStop: z3.boolean().optional()
+});
+var CancelTaskQueuedMessageRequestSchema = z3.object({
+  taskId: z3.string(),
+  messageId: z3.string()
+});
+var FlushSingleQueuedMessageRequestSchema = z3.object({
+  taskId: z3.string(),
+  messageId: z3.string(),
+  softStop: z3.boolean().optional()
+});
+var AnswerAgentQuestionRequestSchema = z3.object({
+  taskId: z3.string(),
+  requestId: z3.string(),
+  answers: z3.record(z3.string(), z3.string())
+});
+var ClearAgentTodosRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var AgentQuestionOptionSchema = z3.object({
+  label: z3.string(),
+  description: z3.string(),
+  preview: z3.string().optional()
+});
+var AgentQuestionSchema = z3.object({
+  question: z3.string(),
+  header: z3.string(),
+  options: z3.array(AgentQuestionOptionSchema),
+  multiSelect: z3.boolean().optional()
+});
+var AskUserQuestionRequestSchema = z3.object({
+  sessionId: z3.string(),
+  question: z3.string().min(1),
+  requestId: z3.string().min(1),
+  questions: z3.array(AgentQuestionSchema).min(1)
+});
+var EmitAgentEventRequestSchema = z3.object({
+  sessionId: z3.string(),
+  events: z3.array(AgentEventSchema).max(500)
+});
+var RefreshGithubTokenRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var ReportReviewSpawnFailureRequestSchema = z3.object({
+  sessionId: z3.string(),
+  reviewSessionId: z3.string(),
+  error: z3.string().max(2e3).optional()
+});
+var SpawnTaskSessionRequestSchema = z3.object({
+  taskId: z3.string(),
+  kind: z3.enum(["tui", "shell"])
+});
+var SpawnTaskReviewRequestSchema = z3.object({
+  taskId: z3.string()
+});
+var ReportSessionSpawnFailureRequestSchema = z3.object({
+  sessionId: z3.string(),
+  spawnedSessionId: z3.string(),
+  error: z3.string().max(2e3).optional()
+});
+var RefreshGithubTokenResponseSchema = z3.object({
+  token: z3.string()
+});
+var PTY_FRAME_MAX_CHARS = 256 * 1024;
+var PTY_MAX_DIMENSION = 1e3;
+var PtyOutputRequestSchema = z3.object({
+  sessionId: z3.string(),
+  data: z3.string().max(PTY_FRAME_MAX_CHARS),
+  cols: z3.number().int().positive().max(PTY_MAX_DIMENSION).optional(),
+  rows: z3.number().int().positive().max(PTY_MAX_DIMENSION).optional()
+});
+var PtyEndedRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var PtyInputRequestSchema = z3.object({
+  sessionId: z3.string(),
+  data: z3.string().max(PTY_FRAME_MAX_CHARS)
+});
+var PtyResizeRequestSchema = z3.object({
+  sessionId: z3.string(),
+  cols: z3.number().int().positive().max(PTY_MAX_DIMENSION),
+  rows: z3.number().int().positive().max(PTY_MAX_DIMENSION)
+});
+var PtyAttachRequestSchema = z3.object({
+  sessionId: z3.string()
+});
+var PtyChatEventPayloadSchema = z3.discriminatedUnion("kind", [
+  z3.object({
+    kind: z3.literal("init"),
+    model: z3.string().max(200),
+    claudeSessionId: z3.string().max(100).optional()
   }),
-  z2.object({ kind: z2.literal("user_text"), text: z2.string().max(16384) }),
-  z2.object({ kind: z2.literal("assistant_text"), text: z2.string().max(16384) }),
-  z2.object({
-    kind: z2.literal("tool_use"),
-    name: z2.string().max(200),
+  z3.object({ kind: z3.literal("user_text"), text: z3.string().max(16384) }),
+  z3.object({ kind: z3.literal("assistant_text"), text: z3.string().max(16384) }),
+  z3.object({
+    kind: z3.literal("tool_use"),
+    name: z3.string().max(200),
     // Compact preview: JSON.stringify(input) truncated agent-side.
-    input: z2.string().max(2e3),
+    input: z3.string().max(2e3),
     // Transcript tool_use block id — lets the client pair the tool_result.
-    id: z2.string().max(100).optional()
+    id: z3.string().max(100).optional()
   }),
-  z2.object({
-    kind: z2.literal("tool_result"),
+  z3.object({
+    kind: z3.literal("tool_result"),
     // tool_use block id this result answers (absent on malformed records).
-    toolUseId: z2.string().max(100).optional(),
+    toolUseId: z3.string().max(100).optional(),
     // Compact output preview, truncated agent-side.
-    output: z2.string().max(2e3),
-    isError: z2.boolean().optional()
+    output: z3.string().max(2e3),
+    isError: z3.boolean().optional()
   }),
-  z2.object({ kind: z2.literal("turn_end") })
+  z3.object({ kind: z3.literal("turn_end") })
 ]);
-var PtyChatEventRequestSchema = z2.object({
-  sessionId: z2.string(),
+var PtyChatEventRequestSchema = z3.object({
+  sessionId: z3.string(),
   event: PtyChatEventPayloadSchema
 });
-var PtyChatAttachRequestSchema = z2.object({
-  sessionId: z2.string()
+var PtyChatAttachRequestSchema = z3.object({
+  sessionId: z3.string()
 });
-var CreatePRResponseSchema = z2.object({
-  prNumber: z2.number().int().positive(),
-  prUrl: z2.string().url()
+var CreatePRResponseSchema = z3.object({
+  prNumber: z3.number().int().positive(),
+  prUrl: z3.string().url()
 });
-var PostToChatResponseSchema = z2.object({
-  messageId: z2.string()
+var PostToChatResponseSchema = z3.object({
+  messageId: z3.string()
 });
-var UpdateTaskStatusResponseSchema = z2.object({
-  taskId: z2.string(),
-  status: z2.string()
+var UpdateTaskStatusResponseSchema = z3.object({
+  taskId: z3.string(),
+  status: z3.string()
 });
-var StoreSessionIdResponseSchema = z2.object({
-  success: z2.boolean()
+var StoreSessionIdResponseSchema = z3.object({
+  success: z3.boolean()
 });
-var HeartbeatResponseSchema = z2.object({
-  acknowledged: z2.boolean()
+var HeartbeatResponseSchema = z3.object({
+  acknowledged: z3.boolean()
 });
-var SessionStartResponseSchema = z2.object({
-  sessionId: z2.string(),
-  startedAt: z2.string()
+var SessionStartResponseSchema = z3.object({
+  sessionId: z3.string(),
+  startedAt: z3.string()
 });
-var SessionStopResponseSchema = z2.object({
-  sessionId: z2.string(),
-  stoppedAt: z2.string()
+var SessionStopResponseSchema = z3.object({
+  sessionId: z3.string(),
+  stoppedAt: z3.string()
 });
-var DeleteSubtaskResponseSchema = z2.object({
-  deleted: z2.boolean()
+var DeleteSubtaskResponseSchema = z3.object({
+  deleted: z3.boolean()
 });
-var ListAccessibleProjectsRequestSchema = z3.object({
-  pageSize: z3.number().int().positive().max(100).optional().default(100)
+var ListAccessibleProjectsRequestSchema = z4.object({
+  pageSize: z4.number().int().positive().max(100).optional().default(100)
 });
-var ListProjectTasksRequestSchema = z3.object({
-  projectId: z3.string(),
-  status: z3.string().optional(),
-  assigneeId: z3.string().optional(),
-  unassigned: z3.boolean().optional(),
-  limit: z3.number().int().positive().optional().default(50)
+var ListProjectTasksRequestSchema = z4.object({
+  projectId: z4.string(),
+  status: z4.string().optional(),
+  assigneeId: z4.string().optional(),
+  unassigned: z4.boolean().optional(),
+  // Scope to a sub-project board when provided. Unlike the board layer's `?? null`
+  // semantics, agents default to seeing the whole project when omitted.
+  subProjectId: z4.string().nullable().optional(),
+  limit: z4.number().int().positive().optional().default(50)
 }).refine((p) => !(p.unassigned && p.assigneeId), {
   message: "Pass either assigneeId or unassigned, not both"
 });
-var GetProjectTaskRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string()
+var GetProjectTaskRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string()
 });
-var SearchProjectTasksRequestSchema = z3.object({
-  projectId: z3.string(),
-  tagNames: z3.array(z3.string()).optional(),
-  searchQuery: z3.string().optional(),
-  statusFilters: z3.array(z3.string()).optional(),
+var SearchProjectTasksRequestSchema = z4.object({
+  projectId: z4.string(),
+  tagNames: z4.array(z4.string()).optional(),
+  searchQuery: z4.string().optional(),
+  statusFilters: z4.array(z4.string()).optional(),
   // Card types to include. Omitted/empty → defaults to ["task"] in the handler so
   // search doesn't surface incidents/suggestions unless asked. Enum validation lives
   // at the MCP tool layer (mirrors statusFilters).
-  typeFilters: z3.array(z3.string()).optional(),
-  assigneeId: z3.string().optional(),
-  unassigned: z3.boolean().optional(),
-  limit: z3.number().int().positive().optional().default(20)
+  typeFilters: z4.array(z4.string()).optional(),
+  assigneeId: z4.string().optional(),
+  unassigned: z4.boolean().optional(),
+  // Scope to a sub-project board when provided. Unlike the board layer's `?? null`
+  // semantics, agents default to seeing the whole project when omitted.
+  subProjectId: z4.string().nullable().optional(),
+  limit: z4.number().int().positive().optional().default(20)
 }).refine((p) => !(p.unassigned && p.assigneeId), {
   message: "Pass either assigneeId or unassigned, not both"
 });
-var ListProjectTagsRequestSchema = z3.object({
-  projectId: z3.string()
+var ListProjectTagsRequestSchema = z4.object({
+  projectId: z4.string()
 });
-var GetProjectSummaryRequestSchema = z3.object({
-  projectId: z3.string()
+var GetProjectSummaryRequestSchema = z4.object({
+  projectId: z4.string()
 });
-var CreateProjectTaskRequestSchema = z3.object({
-  projectId: z3.string(),
-  title: z3.string().min(1),
-  description: z3.string().optional(),
-  plan: z3.string().optional(),
-  status: z3.string().optional(),
-  requestingUserId: z3.string().optional()
+var CreateProjectTaskRequestSchema = z4.object({
+  projectId: z4.string(),
+  title: z4.string().min(1),
+  description: z4.string().optional(),
+  plan: z4.string().optional(),
+  status: z4.string().optional(),
+  // Assign to a sub-project board. Validated to belong to `projectId` in the handler.
+  subProjectId: z4.string().nullable().optional(),
+  requestingUserId: z4.string().optional()
 });
-var UpdateProjectTaskRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  title: z3.string().optional(),
-  description: z3.string().optional(),
-  plan: z3.string().optional(),
-  status: z3.string().optional(),
-  assignedUserId: z3.string().nullish(),
-  requestingUserId: z3.string().optional()
+var UpdateProjectTaskRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  title: z4.string().optional(),
+  plan: z4.string().optional(),
+  // Canonical risk level, or null to clear. Resolved to the project's
+  // configured Risk row (by rank) in the handler.
+  risk: riskLevelSchema.nullable().optional(),
+  assignedUserId: z4.string().nullish(),
+  // Move to a different sub-project board, or null to move to the parent board.
+  // Validated to belong to `projectId` in the handler.
+  subProjectId: z4.string().nullable().optional(),
+  requestingUserId: z4.string().optional()
+}).strict().refine(
+  (v) => v.title !== void 0 || v.plan !== void 0 || v.risk !== void 0 || v.assignedUserId !== void 0 || v.subProjectId !== void 0,
+  {
+    message: "update_task requires at least one field to change (title, plan, risk, assignedUserId, or subProjectId)"
+  }
+);
+var TransitionProjectTaskStatusRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  toStatus: z4.string(),
+  expectedFromStatus: z4.string().optional(),
+  // Optional raise-only risk to attempt alongside the transition
+  // (approve → low, request_changes → medium by default).
+  risk: riskLevelSchema.optional(),
+  requestingUserId: z4.string().optional()
 });
-var PostToProjectTaskChatRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  content: z3.string(),
-  requestingUserId: z3.string().optional()
+var MoveProjectCardRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  destinationProjectId: z4.string(),
+  requestingUserId: z4.string().optional()
 });
-var GetProjectTaskCliRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  limit: z3.number().int().positive().optional().default(50),
-  source: z3.string().optional()
+var PostToProjectTaskChatRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  content: z4.string(),
+  requestingUserId: z4.string().optional()
 });
-var GetProjectTaskSessionsRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string()
+var GetProjectTaskCliRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  limit: z4.number().int().positive().optional().default(50),
+  source: z4.string().optional()
 });
-var QueryProjectGcpLogsRequestSchema = z3.object({
-  projectId: z3.string(),
-  env: z3.enum(["prod", "dev", "claudespace"]).optional(),
-  severity: z3.enum(["DEBUG", "INFO", "NOTICE", "WARNING", "ERROR", "CRITICAL", "ALERT", "EMERGENCY"]).optional(),
-  services: z3.array(z3.string().min(1).max(200)).max(25).optional(),
-  sqlInstances: z3.array(z3.string().min(1).max(200)).max(25).optional(),
-  allServices: z3.boolean().optional(),
-  search: z3.string().max(256).optional(),
-  filter: z3.string().max(1e3).optional(),
-  startTime: z3.string().optional(),
-  endTime: z3.string().optional(),
-  limit: z3.number().int().min(1).max(200).optional().default(50),
-  pageToken: z3.string().max(4096).optional()
-});
-var StartProjectBuildRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  requestingUserId: z3.string().optional()
+var GetProjectTaskSessionsRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string()
 });
-var StopProjectBuildRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  requestingUserId: z3.string().optional()
+var QueryProjectGcpLogsRequestSchema = z4.object({
+  projectId: z4.string(),
+  env: z4.enum(["prod", "dev", "claudespace"]).optional(),
+  severity: z4.enum(["DEBUG", "INFO", "NOTICE", "WARNING", "ERROR", "CRITICAL", "ALERT", "EMERGENCY"]).optional(),
+  services: z4.array(z4.string().min(1).max(200)).max(25).optional(),
+  sqlInstances: z4.array(z4.string().min(1).max(200)).max(25).optional(),
+  allServices: z4.boolean().optional(),
+  search: z4.string().max(256).optional(),
+  filter: z4.string().max(1e3).optional(),
+  startTime: z4.string().optional(),
+  endTime: z4.string().optional(),
+  limit: z4.number().int().min(1).max(200).optional().default(50),
+  pageToken: z4.string().max(4096).optional()
+});
+var StartProjectBuildRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  requestingUserId: z4.string().optional()
+});
+var StopProjectBuildRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  requestingUserId: z4.string().optional()
 });
-var StartProjectWorkspaceRequestSchema = z3.object({
-  projectId: z3.string(),
-  requestingUserId: z3.string().optional()
+var StartProjectWorkspaceRequestSchema = z4.object({
+  projectId: z4.string(),
+  requestingUserId: z4.string().optional()
 });
-var StopProjectWorkspaceRequestSchema = z3.object({
-  projectId: z3.string(),
-  destroy: z3.boolean().optional(),
-  requestingUserId: z3.string().optional()
+var StopProjectWorkspaceRequestSchema = z4.object({
+  projectId: z4.string(),
+  destroy: z4.boolean().optional(),
+  requestingUserId: z4.string().optional()
 });
-var ListMyLiveSessionsRequestSchema = z3.object({
-  projectId: z3.string(),
+var ListMyLiveSessionsRequestSchema = z4.object({
+  projectId: z4.string(),
   /** Admin-only: list another member's sessions instead of the caller's. */
-  targetUserId: z3.string().optional()
+  targetUserId: z4.string().optional()
 });
-var ListProjectSessionGroupsRequestSchema = z3.object({
-  projectId: z3.string()
+var ListProjectSessionGroupsRequestSchema = z4.object({
+  projectId: z4.string()
 });
-var GetProjectAvailableTuisRequestSchema = z3.object({
-  projectId: z3.string()
+var GetProjectAvailableTuisRequestSchema = z4.object({
+  projectId: z4.string()
 });
-var StartAdhocSessionRequestSchema = z3.object({
-  projectId: z3.string(),
-  label: z3.string().max(200).optional(),
+var StartAdhocSessionRequestSchema = z4.object({
+  projectId: z4.string(),
+  label: z4.string().max(200).optional(),
   /** Coding-agent key to launch under — validated pick-time (ownership + TUI availability) in the handler. */
-  codingAgentKeyId: z3.string().optional(),
+  codingAgentKeyId: z4.string().optional(),
+  /** Model override (Claude model id) — overrides the launch key's own model. */
+  model: z4.string().max(200).optional(),
   /**
    * Session role. Constrained: other task-less modes fall through to the pm
    * runner in the pod entrypoint, and "review" would crash without a task.
    */
-  mode: z3.enum(["adhoc", "pm"]).optional(),
+  mode: z4.enum(["adhoc", "pm"]).optional(),
   /** Base branch to check out (defaults to the project's dev branch). */
-  branch: z3.string().max(300).optional(),
-  requestingUserId: z3.string().optional()
-});
-var StopAdhocSessionRequestSchema = z3.object({
-  projectId: z3.string(),
-  workspaceId: z3.string(),
-  destroy: z3.boolean().optional(),
-  requestingUserId: z3.string().optional()
-});
-var ResumeAdhocSessionRequestSchema = z3.object({
-  projectId: z3.string(),
-  workspaceId: z3.string(),
-  requestingUserId: z3.string().optional()
-});
-var CreateProjectReleaseRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskIds: z3.array(z3.string()).optional(),
-  requestingUserId: z3.string().optional()
-});
-var ApproveProjectMergePRRequestSchema = z3.object({
-  projectId: z3.string(),
-  childTaskId: z3.string(),
-  requestingUserId: z3.string().optional()
+  branch: z4.string().max(300).optional(),
+  requestingUserId: z4.string().optional()
 });
-var ListProjectSubtasksRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string()
+var StopAdhocSessionRequestSchema = z4.object({
+  projectId: z4.string(),
+  workspaceId: z4.string(),
+  destroy: z4.boolean().optional(),
+  requestingUserId: z4.string().optional()
 });
-var CreateProjectSubtaskRequestSchema = z3.object({
-  projectId: z3.string(),
-  parentTaskId: z3.string(),
-  title: z3.string().min(1),
-  description: z3.string().optional(),
-  plan: z3.string().optional(),
-  ordinal: z3.number().int().nonnegative().optional(),
-  storyPointValue: z3.number().int().positive().optional(),
-  followParentStatus: z3.boolean().optional(),
+var ResumeAdhocSessionRequestSchema = z4.object({
+  projectId: z4.string(),
+  workspaceId: z4.string(),
+  requestingUserId: z4.string().optional()
+});
+var CreateProjectReleaseRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskIds: z4.array(z4.string()).optional(),
+  requestingUserId: z4.string().optional()
+});
+var ApproveProjectMergePRRequestSchema = z4.object({
+  projectId: z4.string(),
+  childTaskId: z4.string(),
+  requestingUserId: z4.string().optional()
+});
+var ListProjectSubtasksRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string()
+});
+var CreateProjectSubtaskRequestSchema = z4.object({
+  projectId: z4.string(),
+  parentTaskId: z4.string(),
+  title: z4.string().min(1),
+  description: z4.string().optional(),
+  plan: z4.string().optional(),
+  ordinal: z4.number().int().nonnegative().optional(),
+  storyPointValue: z4.number().int().positive().optional(),
+  followParentStatus: z4.boolean().optional(),
   /** Sibling subtask ids or slugs this subtask blocks on (explicit dependency
    * metadata — preferred over encoding order in plan text / ordinal). */
-  dependsOn: z3.array(z3.string().min(1)).max(32).optional(),
-  requestingUserId: z3.string().optional()
+  dependsOn: z4.array(z4.string().min(1)).max(32).optional(),
+  requestingUserId: z4.string().optional()
 });
-var UpdateProjectSubtaskRequestSchema = z3.object({
-  projectId: z3.string(),
-  subtaskId: z3.string(),
-  title: z3.string().optional(),
-  description: z3.string().optional(),
-  plan: z3.string().optional(),
-  status: z3.string().optional(),
-  ordinal: z3.number().int().nonnegative().optional(),
-  storyPointValue: z3.number().int().positive().optional(),
-  followParentStatus: z3.boolean().optional(),
-  requestingUserId: z3.string().optional()
+var UpdateProjectSubtaskRequestSchema = z4.object({
+  projectId: z4.string(),
+  subtaskId: z4.string(),
+  title: z4.string().optional(),
+  description: z4.string().optional(),
+  plan: z4.string().optional(),
+  status: z4.string().optional(),
+  ordinal: z4.number().int().nonnegative().optional(),
+  storyPointValue: z4.number().int().positive().optional(),
+  followParentStatus: z4.boolean().optional(),
+  requestingUserId: z4.string().optional()
 });
-var DeleteProjectSubtaskRequestSchema = z3.object({
-  projectId: z3.string(),
-  subtaskId: z3.string(),
-  requestingUserId: z3.string().optional()
+var DeleteProjectSubtaskRequestSchema = z4.object({
+  projectId: z4.string(),
+  subtaskId: z4.string(),
+  requestingUserId: z4.string().optional()
 });
-var GetProjectTaskChatRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  limit: z3.number().int().positive().optional().default(20)
+var GetProjectTaskChatRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  limit: z4.number().int().positive().optional().default(20)
 });
-var AddProjectTaskDependencyRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  dependsOnSlugOrId: z3.string(),
-  requestingUserId: z3.string().optional()
+var AddProjectTaskDependencyRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  dependsOnSlugOrId: z4.string(),
+  requestingUserId: z4.string().optional()
 });
-var RemoveProjectTaskDependencyRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  dependsOnSlugOrId: z3.string(),
-  requestingUserId: z3.string().optional()
+var RemoveProjectTaskDependencyRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  dependsOnSlugOrId: z4.string(),
+  requestingUserId: z4.string().optional()
 });
-var VoteProjectSuggestionRequestSchema = z3.object({
-  projectId: z3.string(),
-  suggestionId: z3.string(),
-  value: z3.union([z3.literal(1), z3.literal(-1)]),
-  requestingUserId: z3.string().optional()
+var VoteProjectSuggestionRequestSchema = z4.object({
+  projectId: z4.string(),
+  suggestionId: z4.string(),
+  value: z4.union([z4.literal(1), z4.literal(-1)]),
+  requestingUserId: z4.string().optional()
 });
-var GetProjectTaskDependenciesRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string()
+var GetProjectTaskDependenciesRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string()
 });
-var ListProjectTaskFilesRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string()
+var ListProjectTaskFilesRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string()
 });
-var GetProjectAttachmentRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  fileId: z3.string(),
+var GetProjectAttachmentRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  fileId: z4.string(),
   /** Byte offset into text content (paging large logs/JSON). Default 0. */
-  offset: z3.number().int().nonnegative().optional(),
+  offset: z4.number().int().nonnegative().optional(),
   /** Max bytes of text content to return from `offset`. Server default applies. */
-  maxBytes: z3.number().int().positive().optional()
+  maxBytes: z4.number().int().positive().optional()
 });
-var RequestProjectFileUploadRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  fileName: z3.string().min(1).max(255),
-  mimeType: z3.string().min(1).max(128),
-  fileSize: z3.number().int().positive().max(MAX_FILE_SIZE_BYTES),
-  requestingUserId: z3.string().optional()
+var RequestProjectFileUploadRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  fileName: z4.string().min(1).max(255),
+  mimeType: z4.string().min(1).max(128),
+  fileSize: z4.number().int().positive().max(MAX_FILE_SIZE_BYTES),
+  requestingUserId: z4.string().optional()
 });
-var ConfirmProjectFileUploadRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  fileId: z3.string(),
+var ConfirmProjectFileUploadRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  fileId: z4.string(),
   /** When set, the attachment is also posted to the task chat with this text. */
-  comment: z3.string().max(2e3).optional(),
-  requestingUserId: z3.string().optional()
-});
-var CreateProjectPullRequestRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  title: z3.string().min(1),
-  body: z3.string(),
-  head: z3.string().optional(),
-  base: z3.string().optional(),
-  requestingUserId: z3.string().optional()
-});
-var ListProjectMembersRequestSchema = z3.object({
-  projectId: z3.string()
-});
-var AddProjectTaskReviewerRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  userId: z3.string(),
-  requestingUserId: z3.string().optional()
-});
-var RemoveProjectTaskReviewerRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  userId: z3.string(),
-  requestingUserId: z3.string().optional()
-});
-var ListProjectManualTestsRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string()
-});
-var QueryProjectManualTestsRequestSchema = z3.object({
-  projectId: z3.string(),
-  cardStatuses: z3.array(z3.string()).optional(),
-  testStatuses: z3.array(z3.enum(["open", "approved", "rejected"])).optional()
+  comment: z4.string().max(2e3).optional(),
+  requestingUserId: z4.string().optional()
 });
-var SetProjectManualTestsRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  items: z3.array(z3.object({ title: z3.string().min(1) })).min(1),
-  requestingUserId: z3.string().optional()
+var CreateProjectPullRequestRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  title: z4.string().min(1),
+  body: z4.string(),
+  head: z4.string().optional(),
+  base: z4.string().optional(),
+  requestingUserId: z4.string().optional()
 });
-var EditProjectManualTestRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  title: z3.string().min(1),
-  newTitle: z3.string().min(1),
-  requestingUserId: z3.string().optional()
+var ListProjectMembersRequestSchema = z4.object({
+  projectId: z4.string()
 });
-var RemoveProjectManualTestRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  title: z3.string().min(1),
-  requestingUserId: z3.string().optional()
+var AddProjectTaskReviewerRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  userId: z4.string(),
+  requestingUserId: z4.string().optional()
 });
-var ApproveProjectManualTestRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  title: z3.string().min(1),
-  requestingUserId: z3.string().optional()
+var RemoveProjectTaskReviewerRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  userId: z4.string(),
+  requestingUserId: z4.string().optional()
 });
-var RejectProjectManualTestRequestSchema = z3.object({
-  projectId: z3.string(),
-  taskId: z3.string(),
-  title: z3.string().min(1),
-  reason: z3.string().min(1).max(2e3),
-  requestingUserId: z3.string().optional()
+var ListProjectManualTestsRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string()
 });
-var CreateProjectSuggestionRequestSchema = z3.object({
-  projectId: z3.string(),
-  title: z3.string().min(1),
-  description: z3.string().optional(),
-  tagNames: z3.array(z3.string()).optional(),
-  requestingUserId: z3.string().optional()
+var QueryProjectManualTestsRequestSchema = z4.object({
+  projectId: z4.string(),
+  cardStatuses: z4.array(z4.string()).optional(),
+  testStatuses: z4.array(z4.enum(["open", "approved", "rejected"])).optional()
 });
-var ProjectTagContextPathSchema = z4.object({
-  type: z4.enum(["rule", "doc", "file", "folder"]),
-  path: z4.string().min(1).max(500),
-  label: z4.string().max(100).optional()
+var SetProjectManualTestsRequestSchema = z4.object({
+  projectId: z4.string(),
+  taskId: z4.string(),
+  items: z4.array(z4.object({ title: z4.string().min(1) })).min(1),
+  requestingUserId: z4.string().optional()
 });
-var hexColor = z4.string().regex(/^#[0-9a-fA-F]{6}$/, "Expected #RRGGBB hex color");
-var CreateProjectTagRequestSchema = z4.object({
+var EditProjectManualTestRequestSchema = z4.object({
   projectId: z4.string(),
-  name: z4.string().min(1).max(50),
-  color: hexColor.optional(),
-  description: z4.string().max(500).optional(),
-  contextPaths: z4.array(ProjectTagContextPathSchema).max(20).optional(),
+  taskId: z4.string(),
+  title: z4.string().min(1),
+  newTitle: z4.string().min(1),
   requestingUserId: z4.string().optional()
 });
-var UpdateProjectTagRequestSchema = z4.object({
+var RemoveProjectManualTestRequestSchema = z4.object({
   projectId: z4.string(),
-  tagId: z4.string(),
-  name: z4.string().min(1).max(50).optional(),
-  color: hexColor.optional(),
-  description: z4.string().max(500).optional(),
-  /** Full replacement of the tag's context links when provided. */
-  contextPaths: z4.array(ProjectTagContextPathSchema).max(20).optional(),
+  taskId: z4.string(),
+  title: z4.string().min(1),
   requestingUserId: z4.string().optional()
 });
-var PostToProjectChatRequestSchema = z4.object({
+var ApproveProjectManualTestRequestSchema = z4.object({
   projectId: z4.string(),
-  content: z4.string().min(1).max(2e4),
-  requestingUserId: z4.string().optional(),
-  /** Marks the post so the server can persist it beyond chat (tag-audit summaries land in tag history). */
-  kind: z4.enum(["tag_audit_summary"]).optional()
+  taskId: z4.string(),
+  title: z4.string().min(1),
+  requestingUserId: z4.string().optional()
 });
-var StartTagAuditRequestSchema = z4.object({
+var RejectProjectManualTestRequestSchema = z4.object({
   projectId: z4.string(),
+  taskId: z4.string(),
+  title: z4.string().min(1),
+  reason: z4.string().min(1).max(2e3),
   requestingUserId: z4.string().optional()
 });
-var StartTaskAuditRequestSchema = z4.object({
+var CreateProjectSuggestionRequestSchema = z4.object({
   projectId: z4.string(),
-  taskIds: z4.array(z4.string()).min(1).max(20),
+  title: z4.string().min(1),
+  description: z4.string().optional(),
+  tagNames: z4.array(z4.string()).optional(),
   requestingUserId: z4.string().optional()
 });
-var GetActiveAuditSessionsRequestSchema = z4.object({
-  projectId: z4.string()
+var ProjectTagContextPathSchema = z5.object({
+  type: z5.enum(["rule", "doc", "file", "folder"]),
+  path: z5.string().min(1).max(500),
+  label: z5.string().max(100).optional()
 });
-var ReportTaskAuditResultRequestSchema = z4.object({
-  projectId: z4.string(),
-  taskId: z4.string(),
-  summary: z4.string(),
-  turnGrades: z4.array(
-    z4.object({
-      turnIndex: z4.number(),
-      phase: z4.enum(["planning", "building", "human"]),
-      grade: z4.enum(["correct", "neutral", "blunder"]),
-      reasoning: z4.string(),
-      eventType: z4.string(),
-      eventSummary: z4.string()
+var hexColor = z5.string().regex(/^#[0-9a-fA-F]{6}$/, "Expected #RRGGBB hex color");
+var CreateProjectTagRequestSchema = z5.object({
+  projectId: z5.string(),
+  name: z5.string().min(1).max(50),
+  color: hexColor.optional(),
+  description: z5.string().max(500).optional(),
+  contextPaths: z5.array(ProjectTagContextPathSchema).max(20).optional(),
+  requestingUserId: z5.string().optional()
+});
+var UpdateProjectTagRequestSchema = z5.object({
+  projectId: z5.string(),
+  tagId: z5.string(),
+  name: z5.string().min(1).max(50).optional(),
+  color: hexColor.optional(),
+  description: z5.string().max(500).optional(),
+  /** Full replacement of the tag's context links when provided. */
+  contextPaths: z5.array(ProjectTagContextPathSchema).max(20).optional(),
+  requestingUserId: z5.string().optional()
+});
+var PostToProjectChatRequestSchema = z5.object({
+  projectId: z5.string(),
+  content: z5.string().min(1).max(2e4),
+  requestingUserId: z5.string().optional(),
+  /** Marks the post so the server can persist it beyond chat (tag-audit summaries land in tag history). */
+  kind: z5.enum(["tag_audit_summary"]).optional()
+});
+var StartTagAuditRequestSchema = z5.object({
+  projectId: z5.string(),
+  requestingUserId: z5.string().optional()
+});
+var StartTaskAuditRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskIds: z5.array(z5.string()).min(1).max(20),
+  requestingUserId: z5.string().optional()
+});
+var GetActiveAuditSessionsRequestSchema = z5.object({
+  projectId: z5.string()
+});
+var ReportTaskAuditResultRequestSchema = z5.object({
+  projectId: z5.string(),
+  taskId: z5.string(),
+  summary: z5.string(),
+  turnGrades: z5.array(
+    z5.object({
+      turnIndex: z5.number(),
+      phase: z5.enum(["planning", "building", "human"]),
+      grade: z5.enum(["correct", "neutral", "blunder"]),
+      reasoning: z5.string(),
+      eventType: z5.string(),
+      eventSummary: z5.string()
     })
   ),
-  planningAccuracy: z4.number().nullable(),
-  buildingAccuracy: z4.number().nullable(),
-  humanAccuracy: z4.number().nullable(),
-  planningCorrect: z4.number(),
-  planningNeutral: z4.number(),
-  planningBlunder: z4.number(),
-  buildingCorrect: z4.number(),
-  buildingNeutral: z4.number(),
-  buildingBlunder: z4.number(),
-  humanCorrect: z4.number(),
-  humanNeutral: z4.number(),
-  humanBlunder: z4.number(),
-  humanEvaluations: z4.array(
-    z4.object({
-      messageIndex: z4.number(),
-      rating: z4.union([z4.literal(-1), z4.literal(0), z4.literal(1)]),
-      reasoning: z4.string()
+  planningAccuracy: z5.number().nullable(),
+  buildingAccuracy: z5.number().nullable(),
+  humanAccuracy: z5.number().nullable(),
+  planningCorrect: z5.number(),
+  planningNeutral: z5.number(),
+  planningBlunder: z5.number(),
+  buildingCorrect: z5.number(),
+  buildingNeutral: z5.number(),
+  buildingBlunder: z5.number(),
+  humanCorrect: z5.number(),
+  humanNeutral: z5.number(),
+  humanBlunder: z5.number(),
+  humanEvaluations: z5.array(
+    z5.object({
+      messageIndex: z5.number(),
+      rating: z5.union([z5.literal(-1), z5.literal(0), z5.literal(1)]),
+      reasoning: z5.string()
     })
   ).optional(),
-  suggestionIds: z4.array(z4.string()),
-  auditCostUsd: z4.number().nullable(),
-  model: z4.string().nullable(),
+  suggestionIds: z5.array(z5.string()),
+  auditCostUsd: z5.number().nullable(),
+  model: z5.string().nullable(),
   /** When set, the audit is marked failed with this message instead. */
-  error: z4.string().optional()
+  error: z5.string().optional()
 });
-var GetTaskAuditsRequestSchema = z4.object({
-  projectId: z4.string(),
-  limit: z4.number().int().positive().max(200).optional().default(50)
+var GetTaskAuditsRequestSchema = z5.object({
+  projectId: z5.string(),
+  limit: z5.number().int().positive().max(200).optional().default(50)
 });
-var GetTaskAuditRequestSchema = z4.object({
-  projectId: z4.string(),
-  auditId: z4.string()
+var GetTaskAuditRequestSchema = z5.object({
+  projectId: z5.string(),
+  auditId: z5.string()
 });
-var GetTaskAuditAggregatesRequestSchema = z4.object({
-  projectId: z4.string()
+var GetTaskAuditAggregatesRequestSchema = z5.object({
+  projectId: z5.string()
 });
-var DeleteTaskAuditRequestSchema = z4.object({
-  projectId: z4.string(),
-  auditId: z4.string(),
-  requestingUserId: z4.string().optional()
+var DeleteTaskAuditRequestSchema = z5.object({
+  projectId: z5.string(),
+  auditId: z5.string(),
+  requestingUserId: z5.string().optional()
 });
-var MarkInitialPromptSubmittedRequestSchema = z4.object({
-  sessionId: z4.string()
+var MarkInitialPromptSubmittedRequestSchema = z5.object({
+  sessionId: z5.string()
 });
 var AGENT_STATUS_REASON_USER_QUESTION = "user_question";
 var TASK_CHAT_HISTORY_LIMIT = 20;
 var PM_CHAT_HISTORY_LIMIT = 40;
 var AGENT_CHAT_HISTORY_FETCH_LIMIT = Math.max(TASK_CHAT_HISTORY_LIMIT, PM_CHAT_HISTORY_LIMIT) + 10;
 var PRE_BUILD_TASK_STATUSES = /* @__PURE__ */ new Set(["Planning", "Open"]);
+function hasTaskPlan(plan) {
+  return !!plan?.trim();
+}
 
 // src/runner/mode-controller.ts
 var ModeController = class {
@@ -4061,7 +4154,7 @@ var PtyOutputCoalescer = class {
 
 // src/harness/pty/tool-server.ts
 import { createServer as createServer2 } from "http";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import { writeFile as writeFile3 } from "fs/promises";
 import { join as join2 } from "path";
 import { randomBytes } from "crypto";
@@ -4118,7 +4211,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 ? z5.strictObject(tool2.schema) : tool2.schema;
+      const inputSchema = tool2.strict ? z6.strictObject(tool2.schema) : tool2.schema;
       register(
         tool2.name,
         {
@@ -6083,7 +6176,7 @@ function formatEntry(entry) {
   const suffix = entry.summary ? ` \u2014 ${entry.summary}` : "";
   return `- \`${entry.path}\`${suffix}`;
 }
-function formatResolvedTags(resolved) {
+function formatResolvedTags(resolved, subProject) {
   const parts = [
     `
 ## Reference Guides (load on demand)`,
@@ -6098,50 +6191,69 @@ function formatResolvedTags(resolved) {
       parts.push(formatEntry(entry));
     }
   }
+  if (subProject && subProject.entries.length > 0) {
+    parts.push(`
+### Sub-project: "${subProject.name}"`);
+    for (const entry of subProject.entries) {
+      parts.push(formatEntry(entry));
+    }
+  }
   return parts.join("\n");
 }
-async function resolveTagContext(projectTags, taskTagIds, _model, _betas, _runnerMode) {
-  if (!projectTags?.length || !taskTagIds.length) {
-    return { injectedSection: "", stats: { injected: 0, skipped: 0 } };
-  }
-  const taskTagIdSet = new Set(taskTagIds);
-  const assignedTags = projectTags.filter((t) => taskTagIdSet.has(t.id));
-  if (assignedTags.length === 0) {
-    return { injectedSection: "", stats: { injected: 0, skipped: 0 } };
+async function resolveEntries(contextPaths) {
+  if (!contextPaths?.length) return [];
+  const sorted = [...contextPaths].sort(
+    (a, b) => (TYPE_PRIORITY[a.type] ?? 99) - (TYPE_PRIORITY[b.type] ?? 99)
+  );
+  const results = [];
+  for (const entry of sorted) {
+    results.push(await resolveEntry(entry));
   }
-  const allEntries = [];
-  for (let i = 0; i < assignedTags.length; i++) {
-    const tag = assignedTags[i];
-    if (!tag.contextPaths?.length) continue;
-    const sorted = [...tag.contextPaths].sort(
-      (a, b) => (TYPE_PRIORITY[a.type] ?? 99) - (TYPE_PRIORITY[b.type] ?? 99)
-    );
-    for (const entry of sorted) {
-      allEntries.push({ tagIndex: i, entry });
-    }
+  return results;
+}
+function countResolved(entries) {
+  const injected = entries.filter((e) => e.summary !== null).length;
+  return { injected, skipped: entries.length - injected };
+}
+async function resolveAssignedTags(assignedTags) {
+  const resolved = [];
+  let injected = 0;
+  let skipped = 0;
+  for (const tag of assignedTags) {
+    const entries = await resolveEntries(tag.contextPaths);
+    const counts = countResolved(entries);
+    injected += counts.injected;
+    skipped += counts.skipped;
+    resolved.push({ tagName: tag.name, description: tag.description, entries });
   }
-  if (allEntries.length === 0) {
+  return { resolved, injected, skipped };
+}
+async function resolveTagContext(projectTags, taskTagIds, _model, _betas, _runnerMode, subProject) {
+  const taskTagIdSet = new Set(taskTagIds);
+  const assignedTags = (projectTags ?? []).filter((t) => taskTagIdSet.has(t.id));
+  const hasTagPaths = assignedTags.some((t) => t.contextPaths?.length);
+  const hasSubProjectPaths = (subProject?.contextPaths?.length ?? 0) > 0;
+  if (!hasTagPaths && !hasSubProjectPaths) {
     return { injectedSection: "", stats: { injected: 0, skipped: 0 } };
   }
-  let injected = 0;
-  let skipped = 0;
-  const resolved = assignedTags.map((t) => ({
-    tagName: t.name,
-    description: t.description,
-    entries: []
-  }));
-  for (const { tagIndex, entry } of allEntries) {
-    const result = await resolveEntry(entry);
-    resolved[tagIndex].entries.push(result);
-    if (result.summary === null) {
-      skipped++;
-    } else {
-      injected++;
-    }
+  const {
+    resolved,
+    injected: tagInjected,
+    skipped: tagSkipped
+  } = await resolveAssignedTags(assignedTags);
+  let subProjectResolved = null;
+  let subInjected = 0;
+  let subSkipped = 0;
+  if (subProject && hasSubProjectPaths) {
+    const entries = await resolveEntries(subProject.contextPaths);
+    const counts = countResolved(entries);
+    subInjected = counts.injected;
+    subSkipped = counts.skipped;
+    subProjectResolved = { name: subProject.name, entries };
   }
   return {
-    injectedSection: formatResolvedTags(resolved),
-    stats: { injected, skipped }
+    injectedSection: formatResolvedTags(resolved, subProjectResolved),
+    stats: { injected: tagInjected + subInjected, skipped: tagSkipped + subSkipped }
   };
 }
 
@@ -6803,13 +6915,16 @@ Address the requested changes. Do NOT re-investigate the codebase from scratch o
   return parts.join("\n");
 }
 async function resolveTaskTagContext(context, runnerMode) {
-  if (!context.projectTags?.length || !context.taskTagIds?.length) return null;
+  const hasTags = !!context.projectTags?.length && !!context.taskTagIds?.length;
+  const hasSubProjectPaths = !!context.subProject?.contextPaths?.length;
+  if (!hasTags && !hasSubProjectPaths) return null;
   const { injectedSection } = await resolveTagContext(
     context.projectTags,
-    context.taskTagIds,
+    context.taskTagIds ?? [],
     context.model,
     context.agentSettings?.betas,
-    runnerMode
+    runnerMode,
+    context.subProject ?? null
   );
   return injectedSection || null;
 }
@@ -7101,7 +7216,7 @@ async function buildInitialPrompt(mode, context, isAuto, agentMode) {
 }
 
 // src/tools/task-context-tools.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/tools/helpers.ts
 function textResult(text) {
@@ -7135,8 +7250,8 @@ function buildReadTaskChatTool(connection) {
     "read_task_chat",
     "Read recent human/user chat messages for a task. Omit task_id for the current task; pass a child ID for a child's chat. For agent logs use get_execution_logs.",
     {
-      limit: z6.number().optional().describe("Number of recent messages to fetch (default 20)"),
-      task_id: z6.string().optional().describe("Child task ID to read chat from. Omit to read the current task's chat.")
+      limit: z7.number().optional().describe("Number of recent messages to fetch (default 20)"),
+      task_id: z7.string().optional().describe("Child task ID to read chat from. Omit to read the current task's chat.")
     },
     async ({ limit, task_id }) => {
       try {
@@ -7180,7 +7295,7 @@ function buildGetTaskTool(connection) {
     "get_task",
     "Look up any task by slug or ID. Returns JSON with id, slug, title, description, plan, status, branch, githubPRNumber, githubPRUrl, storyPoints. For children use list_subtasks.",
     {
-      slug_or_id: z6.string().describe("The task slug (e.g. 'my-task') or CUID")
+      slug_or_id: z7.string().describe("The task slug (e.g. 'my-task') or CUID")
     },
     async ({ slug_or_id }) => {
       try {
@@ -7203,9 +7318,9 @@ 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: z6.string().optional().describe("Task ID or slug. Omit to read logs from the current task."),
-      source: z6.enum(["agent", "application"]).optional().describe("Filter by log source. Omit for all logs."),
-      limit: z6.number().optional().describe("Max number of log entries to return (default 50, max 500).")
+      task_id: z7.string().optional().describe("Task ID or slug. Omit to read logs from the current task."),
+      source: z7.enum(["agent", "application"]).optional().describe("Filter by log source. Omit for all logs."),
+      limit: z7.number().optional().describe("Max number of log entries to return (default 50, max 500).")
     },
     async ({ task_id, source, limit }) => {
       try {
@@ -7265,7 +7380,7 @@ function buildGetAttachmentTool(connection) {
   return defineTool(
     "get_attachment",
     "Fetch one task file's content plus metadata by file ID. Call list_task_files first to discover IDs and check sizes \u2014 large binaries may be truncated by the service's size limit.",
-    { fileId: z6.string().describe("The file ID to retrieve") },
+    { fileId: z7.string().describe("The file ID to retrieve") },
     async ({ fileId }) => {
       try {
         const file = await connection.call("getTaskFile", {
@@ -7303,7 +7418,7 @@ function buildTaskContextTools(connection) {
 }
 
 // src/tools/dependency-suggestion-tools.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 function buildGetDependenciesTool(connection) {
   return defineTool(
     "get_dependencies",
@@ -7329,10 +7444,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: z7.string().optional().describe(
+      status: z8.string().optional().describe(
         "Filter by status: Planning, Open, InProgress, ReviewPR, ReviewDev, ReviewLive, Complete, Cancelled"
       ),
-      limit: z7.number().int().min(1).max(100).optional().describe("Max results (default 20)")
+      limit: z8.number().int().min(1).max(100).optional().describe("Max results (default 20)")
     },
     async ({ status, limit }) => {
       try {
@@ -7356,14 +7471,14 @@ function buildGetSuggestionsTool(connection) {
 }
 
 // src/tools/mutation-tools.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 function buildPostToChatTool(connection) {
   return defineTool(
     "post_to_chat",
     "Post a message to the task chat for the team to see. Your turn output is NOT shown in chat, so this is the only way the team sees your status, summaries, and questions. Omit task_id to post to the current task's chat; pass a child's ID to message its chat.",
     {
-      message: z8.string().describe("The message to post to the team"),
-      task_id: z8.string().optional().describe("Child task ID to post to. Omit to post to the current task's chat.")
+      message: z9.string().describe("The message to post to the team"),
+      task_id: z9.string().optional().describe("Child task ID to post to. Omit to post to the current task's chat.")
     },
     async ({ message, task_id }) => {
       try {
@@ -7401,8 +7516,8 @@ 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: z8.enum(["InProgress", "ReviewPR", "ReviewDev", "Complete"]).describe("The new status for the task"),
-      task_id: z8.string().optional().describe("Child task ID to update. Omit to update the current task.")
+      status: z9.enum(["InProgress", "ReviewPR", "ReviewDev", "Complete"]).describe("The new status for the task"),
+      task_id: z9.string().optional().describe("Child task ID to update. Omit to update the current task.")
     },
     async ({ status, task_id }) => {
       try {
@@ -7433,18 +7548,18 @@ function buildCreatePullRequestTool(connection, config) {
     "create_pull_request",
     "Create a GitHub PR for this task. Auto-stages, commits (commitMessage or title default), pushes to origin, then opens the PR. Always use this instead of gh CLI or raw git.",
     {
-      title: z8.string().describe("The PR title"),
-      body: z8.string().describe("The PR description/body in markdown"),
-      branch: z8.string().optional().describe(
+      title: z9.string().describe("The PR title"),
+      body: z9.string().describe("The PR description/body in markdown"),
+      branch: z9.string().optional().describe(
         "The head branch name for the PR. If the task doesn't have a branch set, this will be used. Defaults to the task's existing branch."
       ),
-      baseBranch: z8.string().optional().describe(
+      baseBranch: z9.string().optional().describe(
         "The base branch to target for the PR (e.g. 'main', 'develop'). Defaults to the project's configured dev branch."
       ),
-      commitMessage: z8.string().optional().describe(
+      commitMessage: z9.string().optional().describe(
         "Commit message for staging uncommitted changes. If not provided, a default message based on the PR title will be used."
       ),
-      skipVerify: z8.boolean().optional().describe(
+      skipVerify: z9.boolean().optional().describe(
         "Controls the local pre-push quality gate (lint/typecheck/test). Defaults to true (--no-verify): the push skips the local gate because you should run gates yourself before opening the PR and CI re-runs them on the resulting PR. Running the full gate synchronously during the push would block the agent's event loop long enough to drop the Conveyor socket connection. Pass false to force the local pre-push hook to run."
       )
     },
@@ -7526,7 +7641,7 @@ function buildAddDependencyTool(connection) {
     "add_dependency",
     "Add a blocking dependency \u2014 this task cannot start until the named task is merged to dev. For post-task follow-ups use create_follow_up_task instead.",
     {
-      depends_on_slug_or_id: z8.string().describe("Slug or ID of the task this task depends on")
+      depends_on_slug_or_id: z9.string().describe("Slug or ID of the task this task depends on")
     },
     async ({ depends_on_slug_or_id }) => {
       try {
@@ -7548,7 +7663,7 @@ function buildRemoveDependencyTool(connection) {
     "remove_dependency",
     "Remove a previously added dependency from this task. When to use: the dependency was added in error or is no longer relevant. Returns: confirmation string.",
     {
-      depends_on_slug_or_id: z8.string().describe("Slug or ID of the task to remove as dependency")
+      depends_on_slug_or_id: z9.string().describe("Slug or ID of the task to remove as dependency")
     },
     async ({ depends_on_slug_or_id }) => {
       try {
@@ -7570,10 +7685,10 @@ function buildCreateFollowUpTaskTool(connection) {
     "create_follow_up_task",
     "Create a follow-up task that depends on the current task. Use for out-of-scope work or cleanup that should land after this task merges. For blockers use add_dependency.",
     {
-      title: z8.string().describe("Follow-up task title"),
-      description: z8.string().optional().describe("Brief description of the follow-up work"),
-      plan: z8.string().optional().describe("Implementation plan if known"),
-      story_point_value: z8.number().optional().describe("Story point estimate (1=Common, 2=Magic, 3=Rare, 5=Unique)")
+      title: z9.string().describe("Follow-up task title"),
+      description: z9.string().optional().describe("Brief description of the follow-up work"),
+      plan: z9.string().optional().describe("Implementation plan if known"),
+      story_point_value: z9.number().optional().describe("Story point estimate (1=Common, 2=Magic, 3=Rare, 5=Unique)")
     },
     async ({ title, description, plan, story_point_value }) => {
       try {
@@ -7600,11 +7715,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: z8.string().describe("Short title for the suggestion"),
-      description: z8.string().optional().describe(
+      title: z9.string().describe("Short title for the suggestion"),
+      description: z9.string().optional().describe(
         "1-2 sentence description of what should change and why. Keep concise and project-focused."
       ),
-      tag_names: z8.array(z8.string()).optional().describe("Tag names to categorize the suggestion")
+      tag_names: z9.array(z9.string()).optional().describe("Tag names to categorize the suggestion")
     },
     async ({ title, description, tag_names }) => {
       try {
@@ -7633,8 +7748,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: z8.string().describe("The suggestion ID to vote on"),
-      value: z8.number().refine((v) => v === 1 || v === -1, { message: "Value must be 1 or -1" }).describe("+1 to upvote, -1 to downvote")
+      suggestion_id: z9.string().describe("The suggestion ID to vote on"),
+      value: z9.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 {
@@ -7667,7 +7782,7 @@ function buildMutationTools(connection, config) {
 // src/tools/attachment-tools.ts
 import { readFile as readFile3, stat as stat4 } from "fs/promises";
 import { basename, extname, isAbsolute, join as join6 } from "path";
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 var IMAGE_MIME_BY_EXT = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -7680,8 +7795,8 @@ function buildUploadAttachmentTool(connection, config) {
     "upload_attachment",
     "Upload an image file (e.g. a Playwright screenshot) as a task attachment AND post it to the task chat in one step \u2014 no follow-up post_to_chat call needed. Supports png/jpg/gif/webp.",
     {
-      path: z9.string().describe("Path to the image file \u2014 absolute, or relative to the workspace root"),
-      title: z9.string().optional().describe("Short caption posted with the image (defaults to the file name)")
+      path: z10.string().describe("Path to the image file \u2014 absolute, or relative to the workspace root"),
+      title: z10.string().optional().describe("Short caption posted with the image (defaults to the file name)")
     },
     async ({ path: path4, title }) => {
       try {
@@ -7737,7 +7852,7 @@ function buildUploadAttachmentTool(connection, config) {
 }
 
 // src/tools/checklist-tools.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 function buildListManualTestsTool(connection) {
   return defineTool(
     "list_manual_tests",
@@ -7789,8 +7904,8 @@ function buildQueryManualTestsTool(connection) {
     "query_manual_tests",
     "Query manual tests across many tasks in this project, grouped by task. Filter by card status (ReviewDev, ReviewLive, Complete, ...) and/or test status (open | approved | rejected). Use to answer 'show all OPEN manual tests in ReviewDev' or 'show all REJECTED manual tests with the failing reason'. With no filters it defaults to the needs-attention view: open+rejected tests on ReviewDev/ReviewLive cards.",
     {
-      cardStatuses: z10.array(z10.string()).optional().describe('Filter tasks by card status, e.g. ["ReviewDev", "ReviewLive"]'),
-      testStatuses: z10.array(z10.enum(["open", "approved", "rejected"])).optional().describe("Filter tests by status: open | approved | rejected")
+      cardStatuses: z11.array(z11.string()).optional().describe('Filter tasks by card status, e.g. ["ReviewDev", "ReviewLive"]'),
+      testStatuses: z11.array(z11.enum(["open", "approved", "rejected"])).optional().describe("Filter tests by status: open | approved | rejected")
     },
     async ({ cardStatuses, testStatuses }) => {
       try {
@@ -7814,7 +7929,7 @@ function buildSetManualTestsTool(connection) {
     "set_manual_tests",
     "Add manual test steps to the task checklist. Existing items with the same title are automatically skipped (deduplication). Use to record specific manual verification steps that reviewers should follow when testing this PR.",
     {
-      items: z10.array(z10.object({ title: z10.string().min(1).describe("A concise, actionable test step") })).min(1).describe("List of manual test steps to add")
+      items: z11.array(z11.object({ title: z11.string().min(1).describe("A concise, actionable test step") })).min(1).describe("List of manual test steps to add")
     },
     async ({ items }) => {
       try {
@@ -7837,8 +7952,8 @@ function buildEditManualTestTool(connection) {
     "edit_manual_test",
     "Rename an existing manual test step. Identify the test by its current title (case-insensitive); pass the new title to replace it. Use to correct or refine a recorded manual verification step.",
     {
-      title: z10.string().min(1).describe("The current title of the manual test to edit"),
-      newTitle: z10.string().min(1).describe("The new title for the manual test")
+      title: z11.string().min(1).describe("The current title of the manual test to edit"),
+      newTitle: z11.string().min(1).describe("The new title for the manual test")
     },
     async ({ title, newTitle }) => {
       try {
@@ -7860,7 +7975,7 @@ function buildRemoveManualTestTool(connection) {
     "remove_manual_test",
     "Remove an existing manual test step from the task checklist. Identify the test by its title (case-insensitive). Use to delete a stale or incorrect manual verification step.",
     {
-      title: z10.string().min(1).describe("The title of the manual test to remove")
+      title: z11.string().min(1).describe("The title of the manual test to remove")
     },
     async ({ title }) => {
       try {
@@ -7881,7 +7996,7 @@ function buildApproveManualTestTool(connection) {
     "approve_manual_test",
     "Sign off on (approve) a manual test step on behalf of your authenticated user. Identify the test by its title (case-insensitive). Use after you have verified the step passes.",
     {
-      title: z10.string().min(1).describe("The title of the manual test to approve")
+      title: z11.string().min(1).describe("The title of the manual test to approve")
     },
     async ({ title }) => {
       try {
@@ -7902,8 +8017,8 @@ function buildRejectManualTestTool(connection) {
     "reject_manual_test",
     "Flag an issue with (reject) a manual test step on behalf of your authenticated user, recording the reason. Identify the test by its title (case-insensitive). Use when the step fails verification.",
     {
-      title: z10.string().min(1).describe("The title of the manual test to reject"),
-      reason: z10.string().min(1).max(2e3).describe("Why the test failed \u2014 what went wrong, shown to the team")
+      title: z11.string().min(1).describe("The title of the manual test to reject"),
+      reason: z11.string().min(1).max(2e3).describe("Why the test failed \u2014 what went wrong, shown to the team")
     },
     async ({ title, reason }) => {
       try {
@@ -7940,7 +8055,7 @@ function buildCommonTools(connection, config) {
 }
 
 // src/tools/pm-tools.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var SP_DESCRIPTION = "Story point value (1=Common, 2=Magic, 3=Rare, 5=Unique)";
 var FOLLOW_PARENT_STATUS_DESCRIPTION = "Child mirrors the parent task's status automatically \u2014 for subtasks that ship on the parent's branch/PR with no build or PR of their own. Manual status writes on a follower stick only until the parent's next transition.";
 var DEPENDS_ON_DESCRIPTION = "Sibling subtask ids or slugs this subtask blocks on (it won't start until they merge to dev). Set explicit dependency metadata here instead of describing order in the plan text \u2014 the pack runner schedules children off these edges. Omit / leave empty for independent children so they run in parallel.";
@@ -7949,8 +8064,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: z11.string().optional().describe("The task plan in markdown"),
-      description: z11.string().optional().describe("Updated task description")
+      plan: z12.string().optional().describe("The task plan in markdown"),
+      description: z12.string().optional().describe("Updated task description")
     },
     async ({ plan, description }) => {
       try {
@@ -7971,13 +8086,13 @@ function buildCreateSubtaskTool(connection) {
     "create_subtask",
     "Create a subtask under the current parent task. Use when breaking a complex parent into smaller pieces during planning. For post-task follow-ups use create_follow_up_task.",
     {
-      title: z11.string().describe("Subtask title"),
-      description: z11.string().optional().describe("Brief description"),
-      plan: z11.string().optional().describe("Implementation plan in markdown"),
-      ordinal: z11.number().optional().describe("Step/order number (0-based)"),
-      storyPointValue: z11.number().optional().describe(SP_DESCRIPTION),
-      followParentStatus: z11.boolean().optional().describe(FOLLOW_PARENT_STATUS_DESCRIPTION),
-      dependsOn: z11.array(z11.string()).optional().describe(DEPENDS_ON_DESCRIPTION)
+      title: z12.string().describe("Subtask title"),
+      description: z12.string().optional().describe("Brief description"),
+      plan: z12.string().optional().describe("Implementation plan in markdown"),
+      ordinal: z12.number().optional().describe("Step/order number (0-based)"),
+      storyPointValue: z12.number().optional().describe(SP_DESCRIPTION),
+      followParentStatus: z12.boolean().optional().describe(FOLLOW_PARENT_STATUS_DESCRIPTION),
+      dependsOn: z12.array(z12.string()).optional().describe(DEPENDS_ON_DESCRIPTION)
     },
     async ({
       title,
@@ -8013,20 +8128,20 @@ function buildUpdateSubtaskTool(connection) {
     "update_subtask",
     "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.",
     {
-      subtaskId: z11.string().describe("The subtask ID to update"),
-      title: z11.string().optional(),
-      description: z11.string().optional(),
-      plan: z11.string().optional(),
-      status: z11.enum(["Planning", "Open"]).optional().describe(
+      subtaskId: z12.string().describe("The subtask ID to update"),
+      title: z12.string().optional(),
+      description: z12.string().optional(),
+      plan: z12.string().optional(),
+      status: z12.enum(["Planning", "Open"]).optional().describe(
         'Move the child between "Planning" and "Open". "Open" marks it ready to execute \u2014 required before start_child_cloud_build. Execution statuses transition automatically.'
       ),
-      agentIdOrName: z11.string().optional().describe(
+      agentIdOrName: z12.string().optional().describe(
         "Assign a project agent to the child (agent id or exact name from the Project Agents list). Required before start_child_cloud_build."
       ),
-      ordinal: z11.number().optional(),
-      storyPointValue: z11.number().optional().describe(SP_DESCRIPTION),
-      followParentStatus: z11.boolean().optional().describe(FOLLOW_PARENT_STATUS_DESCRIPTION),
-      dependsOn: z11.array(z11.string()).optional().describe(
+      ordinal: z12.number().optional(),
+      storyPointValue: z12.number().optional().describe(SP_DESCRIPTION),
+      followParentStatus: z12.boolean().optional().describe(FOLLOW_PARENT_STATUS_DESCRIPTION),
+      dependsOn: z12.array(z12.string()).optional().describe(
         `${DEPENDS_ON_DESCRIPTION} Replaces the full dependency set \u2014 pass [] to clear all, omit to leave unchanged.`
       )
     },
@@ -8065,7 +8180,7 @@ function buildDeleteSubtaskTool(connection) {
   return defineTool(
     "delete_subtask",
     "Delete a subtask by id. When to use: a subtask was created in error or is no longer needed. Returns: confirmation string.",
-    { subtaskId: z11.string().describe("The subtask ID to delete") },
+    { subtaskId: z12.string().describe("The subtask ID to delete") },
     async ({ subtaskId }) => {
       try {
         await connection.call("deleteSubtask", {
@@ -8084,7 +8199,7 @@ function buildListSubtasksTool(connection) {
     "list_subtasks",
     "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.",
     {
-      verbose: z11.boolean().optional().describe(
+      verbose: z12.boolean().optional().describe(
         "Return full task rows including description and plan text (large \u2014 can exceed tool result limits on big packs). Default: compact orchestration view."
       )
     },
@@ -8108,7 +8223,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.",
       {
-        childTaskId: z11.string().describe("The child task ID to start a cloud build for")
+        childTaskId: z12.string().describe("The child task ID to start a cloud build for")
       },
       async ({ childTaskId }) => {
         try {
@@ -8128,7 +8243,7 @@ function buildPackTools(connection) {
       "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: z11.string().describe("The child task ID whose build should be stopped")
+        childTaskId: z12.string().describe("The child task ID whose build should be stopped")
       },
       async ({ childTaskId }) => {
         try {
@@ -8148,7 +8263,7 @@ function buildPackTools(connection) {
       "approve_and_merge_pr",
       "Approve and merge a child task's PR. Preconditions: child in ReviewPR. Returns { merged }: true = merged (status\u2192ReviewDev); false = automerge queued, wait for ReviewDev.",
       {
-        childTaskId: z11.string().describe("The child task ID whose PR should be approved and merged")
+        childTaskId: z12.string().describe("The child task ID whose PR should be approved and merged")
       },
       async ({ childTaskId }) => {
         try {
@@ -8186,7 +8301,7 @@ function buildPmTools(connection, options) {
 }
 
 // src/tools/discovery-tools.ts
-import { z as z12 } from "zod";
+import { z as z13 } 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";
 function buildDiscoveryTools(connection) {
@@ -8195,11 +8310,11 @@ function buildDiscoveryTools(connection) {
       "update_task_properties",
       "Set one or more task properties in a single call. Valid keys: title, storyPointValue, tagNames, githubPRUrl, githubBranch. All are optional \u2014 include only the ones you want to update (at least one). Unknown keys are rejected.",
       {
-        title: z12.string().optional().describe("The new task title"),
-        storyPointValue: z12.number().optional().describe(SP_DESCRIPTION2),
-        tagNames: z12.array(z12.string()).optional().describe("Array of tag names to assign"),
-        githubPRUrl: z12.string().url().optional().describe("GitHub pull request URL to link to this task"),
-        githubBranch: z12.string().optional().describe("Set the GitHub branch name for this task (e.g. 'conveyor/my-feature-abc123')")
+        title: z13.string().optional().describe("The new task title"),
+        storyPointValue: z13.number().optional().describe(SP_DESCRIPTION2),
+        tagNames: z13.array(z13.string()).optional().describe("Array of tag names to assign"),
+        githubPRUrl: z13.string().url().optional().describe("GitHub pull request URL to link to this task"),
+        githubBranch: z13.string().optional().describe("Set the GitHub branch name for this task (e.g. 'conveyor/my-feature-abc123')")
       },
       async ({ title, storyPointValue, tagNames, githubPRUrl, githubBranch }) => {
         try {
@@ -8240,20 +8355,25 @@ function buildDiscoveryTools(connection) {
 }
 
 // src/tools/code-review-tools.ts
-import { z as z13 } from "zod";
+import { z as z14 } from "zod";
 async function endReviewSession(connection, reason) {
   await connection.call("endReviewSession", {
     sessionId: connection.sessionId,
     reason
   });
 }
+function riskFromIssues(issues) {
+  if (issues.some((i) => i.severity === "critical")) return "critical";
+  if (issues.some((i) => i.severity === "major")) return "high";
+  return "medium";
+}
 function buildCodeReviewTools(connection) {
   return [
     defineTool(
       "approve_code_review",
       "Approve the code review and exit. Use when the diff passes all review criteria. Takes only a summary \u2014 for changes, use request_code_changes with a structured issues[] list.",
       {
-        summary: z13.string().describe("Brief summary of what was reviewed and why it looks good")
+        summary: z14.string().describe("Brief summary of what was reviewed and why it looks good")
       },
       async ({ summary }) => {
         const content = `**Code Review: Approved** :white_check_mark:
@@ -8262,7 +8382,8 @@ ${summary}`;
         await connection.call("submitCodeReviewResult", {
           sessionId: connection.sessionId,
           approved: true,
-          content
+          content,
+          risk: "low"
         });
         connection.sendEvent({
           type: "code_review_complete",
@@ -8277,15 +8398,15 @@ ${summary}`;
       "request_code_changes",
       "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 }.",
       {
-        issues: z13.array(
-          z13.object({
-            file: z13.string().describe("File path where the issue was found"),
-            line: z13.number().optional().describe("Line number (if applicable)"),
-            severity: z13.enum(["critical", "major", "minor"]).describe("Issue severity"),
-            description: z13.string().describe("What is wrong and how to fix it")
+        issues: z14.array(
+          z14.object({
+            file: z14.string().describe("File path where the issue was found"),
+            line: z14.number().optional().describe("Line number (if applicable)"),
+            severity: z14.enum(["critical", "major", "minor"]).describe("Issue severity"),
+            description: z14.string().describe("What is wrong and how to fix it")
           })
         ).describe("List of issues found during review"),
-        summary: z13.string().describe("Brief overall summary of the review findings")
+        summary: z14.string().describe("Brief overall summary of the review findings")
       },
       async ({ issues, summary }) => {
         const issueLines = issues.map((issue) => {
@@ -8300,7 +8421,8 @@ ${issueLines}`;
         await connection.call("submitCodeReviewResult", {
           sessionId: connection.sessionId,
           approved: false,
-          content
+          content,
+          risk: riskFromIssues(issues)
         });
         connection.sendEvent({
           type: "code_review_complete",
@@ -10150,6 +10272,86 @@ function readAgentVersion() {
 // src/execution/usage-sampler.ts
 import { existsSync as existsSync3 } from "fs";
 
+// src/usage/reset-parse.ts
+var MONTHS = ["jan", "feb", "mar", "apr", "may", "jun", "jul", "aug", "sep", "oct", "nov", "dec"];
+function tzOffsetMs(utcMs, tz) {
+  const dtf = new Intl.DateTimeFormat("en-US", {
+    timeZone: tz,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  });
+  const map = {};
+  for (const part of dtf.formatToParts(new Date(utcMs))) {
+    if (part.type !== "literal") map[part.type] = part.value;
+  }
+  const hour = map.hour === "24" ? 0 : Number(map.hour);
+  const asUtc = Date.UTC(
+    Number(map.year),
+    Number(map.month) - 1,
+    Number(map.day),
+    hour,
+    Number(map.minute),
+    Number(map.second)
+  );
+  return asUtc - utcMs;
+}
+function zonedWallClockToUtc(y, mo, d, h, mi, tz) {
+  if (tz === "UTC" || tz === "Etc/UTC") return Date.UTC(y, mo, d, h, mi);
+  const naiveUtc = Date.UTC(y, mo, d, h, mi);
+  const firstGuess = naiveUtc - tzOffsetMs(naiveUtc, tz);
+  return naiveUtc - tzOffsetMs(firstGuess, tz);
+}
+function parseResetInstant(rowText, now) {
+  const m = /resets\s+(?:([a-z]{3})\s+(\d{1,2})(?:,|\s+at)?\s+)?(\d{1,2})(?::(\d{2}))?\s*(am|pm)\s*\(([^)]+)\)/i.exec(
+    rowText
+  );
+  if (!m) return null;
+  const [, monStr, dayStr, hourStr, minStr, meridiem, tzRaw] = m;
+  const tz = tzRaw.trim();
+  let hour = Number(hourStr) % 12;
+  if (/pm/i.test(meridiem)) hour += 12;
+  const minute = minStr ? Number(minStr) : 0;
+  const nowDate = new Date(now);
+  try {
+    if (monStr && dayStr) {
+      const month = MONTHS.indexOf(monStr.toLowerCase());
+      if (month < 0) return null;
+      const day = Number(dayStr);
+      let utc2 = zonedWallClockToUtc(nowDate.getUTCFullYear(), month, day, hour, minute, tz);
+      if (utc2 < now - 24 * 60 * 60 * 1e3) {
+        utc2 = zonedWallClockToUtc(nowDate.getUTCFullYear() + 1, month, day, hour, minute, tz);
+      }
+      return new Date(utc2).toISOString();
+    }
+    let utc = zonedWallClockToUtc(
+      nowDate.getUTCFullYear(),
+      nowDate.getUTCMonth(),
+      nowDate.getUTCDate(),
+      hour,
+      minute,
+      tz
+    );
+    if (utc <= now) {
+      utc = zonedWallClockToUtc(
+        nowDate.getUTCFullYear(),
+        nowDate.getUTCMonth(),
+        nowDate.getUTCDate() + 1,
+        hour,
+        minute,
+        tz
+      );
+    }
+    return new Date(utc).toISOString();
+  } catch {
+    return null;
+  }
+}
+
 // src/usage/parse-usage.ts
 var ESC = "\\u001b";
 var ANSI_CSI2 = new RegExp(`${ESC}\\[[0-9;?]*[ -/]*[@-~]`, "g");
@@ -10158,22 +10360,27 @@ var BAR_GLYPHS = /[─-▟]/g;
 function normalizeUsageText(stdout) {
   return stdout.replace(ANSI_CSI2, "").replace(ANSI_OSC, "").replace(BAR_GLYPHS, " ").replace(/\r/g, "");
 }
-function parseUsageGauges(stdout) {
+function parseUsageGauges(stdout, now = Date.now()) {
   const text = normalizeUsageText(stdout);
   const rows = [
     ...text.matchAll(
-      /Current (session|week)\s*(\([^)\n]*\))?[^%\n]*?(\d+(?:\.\d+)?)\s*%(?:\s*used)?/gi
+      /Current (session|week)\s*(\([^)\n]*\))?[^%\n]*?(\d+(?:\.\d+)?)\s*%(?:\s*used)?([^\n]*?)(?=Current\s+(?:session|week)\b|\n|$)/gi
     )
   ];
   const gauges = rows.map((m) => ({
     label: `Current ${m[1].toLowerCase()}${m[2] ? ` ${m[2]}` : ""}`,
-    utilization: Number(m[3]) / 100
+    utilization: Number(m[3]) / 100,
+    resetsAt: parseResetInstant(m[4] ?? "", now)
   }));
   const session = gauges.find((g) => g.label.startsWith("Current session"));
   const weekly = gauges.filter((g) => g.label.startsWith("Current week"));
+  const weeklyResets = weekly.map((g) => g.resetsAt).filter((r) => r !== null);
   return {
     sessionUsage: session ? session.utilization : null,
     weeklyUsage: weekly.length ? Math.max(...weekly.map((g) => g.utilization)) : null,
+    sessionResetsAt: session?.resetsAt ?? null,
+    // Soonest weekly reset (all weekly rows share one instant in practice).
+    weeklyResetsAt: weeklyResets.length ? new Date(Math.min(...weeklyResets.map((r) => new Date(r).getTime()))).toISOString() : null,
     gauges
   };
 }
@@ -10308,13 +10515,14 @@ async function sampleKeyUsage(token, probe = () => runUsageProbe(), hasSubscript
       return [];
     }
     const stdout = await probe();
-    const { sessionUsage, weeklyUsage, gauges } = parseUsageGauges(stdout);
+    const { sessionUsage, weeklyUsage, sessionResetsAt, weeklyResetsAt, gauges } = parseUsageGauges(stdout);
     const samples = [];
     if (sessionUsage !== null) {
       samples.push({
         rateLimitType: "five_hour",
         utilization: sessionUsage,
         status: "allowed",
+        resetsAt: sessionResetsAt,
         gauges
       });
     }
@@ -10323,6 +10531,7 @@ async function sampleKeyUsage(token, probe = () => runUsageProbe(), hasSubscript
         rateLimitType: "seven_day",
         utilization: weeklyUsage,
         status: "allowed",
+        resetsAt: weeklyResetsAt,
         gauges
       });
     }
@@ -10914,7 +11123,7 @@ var SessionRunner = class _SessionRunner {
     }
     this.mode.applyServerMode(this.fullContext?.agentMode, this.fullContext?.isAuto);
     this.mode.resolveInitialMode(this.taskContext);
-    if (this.fullContext?.isAuto && PRE_BUILD_TASK_STATUSES.has(this.taskContext.status) && this.mode.isBuildCapable) {
+    if (this.fullContext?.isAuto && PRE_BUILD_TASK_STATUSES.has(this.taskContext.status) && this.mode.isBuildCapable && hasTaskPlan(this.fullContext.plan)) {
       void this.connection.triggerIdentification().catch(() => {
       });
     }
@@ -11291,6 +11500,7 @@ var SessionRunner = class _SessionRunner {
         rateLimitType: sample.rateLimitType,
         utilization: sample.utilization,
         status: sample.status,
+        resetsAt: sample.resetsAt ?? void 0,
         gauges: sample.gauges
       });
     }
@@ -11831,4 +12041,4 @@ export {
   runStartCommand,
   unshallowRepo
 };
-//# sourceMappingURL=chunk-CXNWRIS7.js.map
+//# sourceMappingURL=chunk-CHJ7JPAQ.js.map