@rallycry/conveyor-agent 7.3.2 → 7.3.4

package/dist/{chunk-WDGSLU5S.js → chunk-TP5WEBQE.js}

@@ -28,6 +28,7 @@ var AgentConnection = class _AgentConnection {
   recentMessages = [];
   static DEDUP_WINDOW_MS = 3e4;
   static DEDUP_SIMILARITY_THRESHOLD = 0.7;
+  static DEDUP_PREVIEW_LIMIT = 120;
   // Early-buffering: events that arrive before callbacks are registered
   earlyMessages = [];
   earlyStop = false;
@@ -276,18 +277,43 @@ var AgentConnection = class _AgentConnection {
   }
   postChatMessage(content) {
     if (!this.socket) return;
-    if (this.isDuplicateMessage(content)) {
-      process.stderr.write(`[dedup] Suppressed near-duplicate message
-`);
-      return;
-    }
+    if (this.suppressIfDuplicate(content)) return;
     void this.call("postAgentMessage", {
       sessionId: this.config.sessionId,
       content
     }).catch(() => {
     });
   }
-  isDuplicateMessage(content) {
+  // Awaitable variant of postChatMessage for callers that need to guarantee
+  // the message is acknowledged by the server before proceeding (e.g. before
+  // aborting the session). Dedup still applies; a suppressed message resolves
+  // immediately without hitting the wire.
+  async postChatMessageAwait(content) {
+    if (!this.socket) return;
+    if (this.suppressIfDuplicate(content)) return;
+    try {
+      await this.call("postAgentMessage", {
+        sessionId: this.config.sessionId,
+        content
+      });
+    } catch (err) {
+      process.stderr.write(
+        `[conveyor-agent] postChatMessageAwait failed: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  suppressIfDuplicate(content) {
+    const d = this.checkAndTrackDuplicate(content);
+    if (!d.duplicate) return false;
+    process.stderr.write(
+      `[dedup] Suppressed near-duplicate (matched: "${d.matchedMessagePreview}")
+`
+    );
+    return true;
+  }
+  // Exposed so `post_to_chat` can surface suppression back to the agent.
+  checkAndTrackDuplicate(content) {
     const now = Date.now();
     this.recentMessages = this.recentMessages.filter(
       (m) => now - m.timestamp < _AgentConnection.DEDUP_WINDOW_MS
@@ -295,22 +321,20 @@ var AgentConnection = class _AgentConnection {
     const words = new Set(
       content.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/).filter((w) => w.length >= 3)
     );
-    if (words.size === 0) return false;
+    if (words.size === 0) return { duplicate: false };
     for (const recent of this.recentMessages) {
       let intersection = 0;
-      for (const w of words) {
-        if (recent.words.has(w)) intersection++;
-      }
+      for (const w of words) if (recent.words.has(w)) intersection++;
       const union = (/* @__PURE__ */ new Set([...words, ...recent.words])).size;
       if (union > 0 && intersection / union > _AgentConnection.DEDUP_SIMILARITY_THRESHOLD) {
-        return true;
+        return { duplicate: true, matchedMessagePreview: recent.preview };
       }
     }
-    this.recentMessages.push({ words, timestamp: now });
-    if (this.recentMessages.length > 3) {
-      this.recentMessages.shift();
-    }
-    return false;
+    const max = _AgentConnection.DEDUP_PREVIEW_LIMIT;
+    const preview = content.length > max ? content.slice(0, max) + "\u2026" : content;
+    this.recentMessages.push({ words, timestamp: now, preview });
+    if (this.recentMessages.length > 3) this.recentMessages.shift();
+    return { duplicate: false };
   }
   sendHeartbeat() {
     if (!this.socket) return;
@@ -332,21 +356,20 @@ var AgentConnection = class _AgentConnection {
   emitModeChanged(agentMode) {
     this.sendEvent({ type: "mode_changed", agentMode });
   }
-  updateTaskFields(fields) {
-    if (!this.socket) return;
-    void this.call("updateTaskFields", {
-      sessionId: this.config.sessionId,
-      ...fields
-    }).catch(() => {
-    });
+  async updateTaskFields(fields) {
+    if (!this.socket) return { ok: false, error: "socket not connected" };
+    try {
+      await this.call("updateTaskFields", { sessionId: this.config.sessionId, ...fields });
+      return { ok: true };
+    } catch (err) {
+      return { ok: false, error: err instanceof Error ? err.message : String(err) };
+    }
   }
   storeSessionId(sdkSessionId) {
-    if (!this.socket) return;
-    void this.call("storeSessionId", {
-      sessionId: this.config.sessionId,
-      sdkSessionId
-    }).catch(() => {
-    });
+    void this.call("storeSessionId", { sessionId: this.config.sessionId, sdkSessionId }).catch(
+      () => {
+      }
+    );
   }
   // ── Typing indicators ───────────────────────────────────────────────
   sendTypingStart() {
@@ -411,6 +434,9 @@ ${q.question}${q.options.length ? "\n" + q.options.map((o) => `- ${o.label}: ${o
   triggerIdentification() {
     return this.call("triggerIdentification", { sessionId: this.config.sessionId });
   }
+  getCumulativeSpending() {
+    return this.call("getCumulativeSpending", { sessionId: this.config.sessionId });
+  }
   async refreshAuthToken() {
     const codespaceName = process.env.CODESPACE_NAME || process.env.CLAUDESPACE_NAME;
     const apiUrl = this.config.apiUrl;
@@ -924,8 +950,8 @@ var PlanSync = class {
         for (const file of readdirSync(plansDir).filter((f) => f.endsWith(".md"))) {
           try {
             const fullPath = join(plansDir, file);
-            const stat = statSync(fullPath);
-            this.planFileSnapshot.set(fullPath, stat.mtimeMs);
+            const stat2 = statSync(fullPath);
+            this.planFileSnapshot.set(fullPath, stat2.mtimeMs);
           } catch {
             continue;
           }
@@ -946,11 +972,11 @@ var PlanSync = class {
       for (const file of files) {
         const fullPath = join(plansDir, file);
         try {
-          const stat = statSync(fullPath);
+          const stat2 = statSync(fullPath);
           const prevMtime = this.planFileSnapshot.get(fullPath);
-          const isNew = prevMtime === void 0 || stat.mtimeMs > prevMtime;
-          if (isNew && (!newest || stat.mtimeMs > newest.mtime)) {
-            newest = { path: fullPath, mtime: stat.mtimeMs };
+          const isNew = prevMtime === void 0 || stat2.mtimeMs > prevMtime;
+          if (isNew && (!newest || stat2.mtimeMs > newest.mtime)) {
+            newest = { path: fullPath, mtime: stat2.mtimeMs };
           }
         } catch {
           continue;
@@ -959,31 +985,35 @@ var PlanSync = class {
     }
     return newest;
   }
-  syncPlanFile() {
-    if (this.lockedPlanFile) {
-      try {
-        const content = readFileSync(this.lockedPlanFile, "utf-8").trim();
-        if (content) {
-          this.connection.updateTaskFields({ plan: content });
-          const fileName = this.lockedPlanFile.split("/").pop() ?? "plan";
-          this.connection.postChatMessage(`Synced local plan file (${fileName}) to the task plan.`);
-        }
-      } catch {
-      }
+  async syncPlanFile() {
+    const isInitialDetection = this.lockedPlanFile === null;
+    const target = this.lockedPlanFile ?? this.findNewestPlanFile()?.path ?? null;
+    if (!target) return;
+    if (isInitialDetection) {
+      this.lockedPlanFile = target;
+    }
+    const fileName = target.split("/").pop() ?? "plan";
+    let content;
+    try {
+      content = readFileSync(target, "utf-8").trim();
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      this.connection.postChatMessage(
+        `Plan sync warning: could not read local plan file (${fileName}): ${reason}. The task plan was not updated.`
+      );
       return;
     }
-    const newest = this.findNewestPlanFile();
-    if (newest) {
-      this.lockedPlanFile = newest.path;
-      const content = readFileSync(newest.path, "utf-8").trim();
-      if (content) {
-        this.connection.updateTaskFields({ plan: content });
-        const fileName = newest.path.split("/").pop() ?? "plan";
-        this.connection.postChatMessage(
-          `Detected local plan file (${fileName}) and synced it to the task plan.`
-        );
-      }
+    if (!content) return;
+    const result = await this.connection.updateTaskFields({ plan: content });
+    if (!result.ok) {
+      this.connection.postChatMessage(
+        `Plan sync failed: the local plan file (${fileName}) was not persisted to the task (${result.error ?? "unknown error"}). Retry update_task_plan or re-run ExitPlanMode.`
+      );
+      return;
     }
+    const verb = isInitialDetection ? "Detected local plan file" : "Synced local plan file";
+    const suffix = isInitialDetection ? " and synced it to the task plan." : " to the task plan.";
+    this.connection.postChatMessage(`${verb} (${fileName})${suffix}`);
   }
 };
 
@@ -993,6 +1023,558 @@ import { existsSync } from "fs";
 import { homedir } from "os";
 import { join as join2 } from "path";
 
+// ../shared/dist/index.js
+import { z } from "zod";
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+var MAX_FILE_SIZE_BYTES = 25 * 1024 * 1024;
+var EMBED_THRESHOLD_IMAGES = 5 * 1024 * 1024;
+var EMBED_THRESHOLD_TEXT = 2 * 1024 * 1024;
+var AgentHeartbeatSchema = z.object({
+  sessionId: z.string().optional(),
+  timestamp: z.string(),
+  status: z.enum(["active", "idle", "building"]),
+  currentAction: z.string().optional()
+});
+var CreatePRInputSchema = z.object({
+  title: z.string().min(1),
+  body: z.string(),
+  head: z.string().optional(),
+  base: z.string().optional()
+});
+var PostToChatInputSchema = z.object({
+  message: z.string().min(1),
+  type: z.enum(["message", "question", "update"]).optional().default("message")
+});
+var GetTaskContextRequestSchema = z.object({
+  sessionId: z.string(),
+  includeHistory: z.boolean().optional().default(false)
+});
+var GetChatMessagesRequestSchema = z.object({
+  sessionId: z.string(),
+  limit: z.number().int().positive().optional().default(50),
+  offset: z.number().int().nonnegative().optional().default(0)
+});
+var GetTaskFilesRequestSchema = z.object({
+  sessionId: z.string()
+});
+var GetTaskFileRequestSchema = z.object({
+  sessionId: z.string(),
+  fileId: z.string()
+});
+var GetTaskRequestSchema = z.object({
+  sessionId: z.string(),
+  taskSlugOrId: z.string()
+});
+var GetCliHistoryRequestSchema = z.object({
+  sessionId: z.string(),
+  limit: z.number().int().positive().optional().default(100),
+  source: z.enum(["agent", "application"]).optional()
+});
+var ListSubtasksRequestSchema = z.object({
+  sessionId: z.string()
+});
+var GetDependenciesRequestSchema = z.object({
+  sessionId: z.string()
+});
+var GetSuggestionsRequestSchema = z.object({
+  sessionId: z.string(),
+  status: z.string().optional(),
+  limit: z.number().int().min(1).max(100).optional()
+});
+var CreatePullRequestRequestSchema = CreatePRInputSchema.extend({ sessionId: z.string() });
+var UpdateTaskStatusRequestSchema = z.object({
+  sessionId: z.string(),
+  status: z.string(),
+  force: z.boolean().optional().default(false)
+});
+var StoreSessionIdRequestSchema = z.object({
+  sessionId: z.string(),
+  sdkSessionId: z.string()
+});
+var TrackSpendingRequestSchema = z.object({
+  sessionId: z.string(),
+  inputTokens: z.number().int().nonnegative(),
+  outputTokens: z.number().int().nonnegative(),
+  costUsd: z.number().nonnegative(),
+  model: z.string()
+});
+var SessionStartRequestSchema = z.object({
+  sessionId: z.string(),
+  agentVersion: z.string(),
+  capabilities: z.array(z.string())
+});
+var SessionStopRequestSchema = z.object({
+  sessionId: z.string(),
+  reason: z.string().optional()
+});
+var ConnectAgentRequestSchema = z.object({
+  sessionId: z.string()
+});
+var ReportAgentStatusRequestSchema = z.object({
+  sessionId: z.string(),
+  status: z.string()
+});
+var NotifyAgentVersionRequestSchema = z.object({
+  sessionId: z.string(),
+  agentVersion: z.string()
+});
+var CreateSubtaskRequestSchema = z.object({
+  sessionId: z.string(),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  plan: z.string().optional(),
+  storyPointValue: z.number().int().positive().optional(),
+  ordinal: z.number().int().nonnegative().optional()
+});
+var UpdateSubtaskRequestSchema = z.object({
+  sessionId: z.string(),
+  subtaskId: z.string(),
+  title: z.string().min(1).optional(),
+  description: z.string().optional(),
+  plan: z.string().optional(),
+  status: z.string().optional(),
+  storyPointValue: z.number().int().positive().optional()
+});
+var DeleteSubtaskRequestSchema = z.object({
+  sessionId: z.string(),
+  subtaskId: z.string()
+});
+var GetTaskPropertiesRequestSchema = z.object({
+  sessionId: z.string()
+});
+var GetCumulativeSpendingRequestSchema = z.object({
+  sessionId: z.string()
+});
+var ModelUsageEntrySchema = z.object({
+  model: z.string(),
+  inputTokens: z.number().nonnegative(),
+  outputTokens: z.number().nonnegative(),
+  cacheReadInputTokens: z.number().nonnegative(),
+  cacheCreationInputTokens: z.number().nonnegative(),
+  costUSD: z.number().nonnegative()
+});
+var GetCumulativeSpendingResponseSchema = z.object({
+  totalCostUsd: z.number().nonnegative(),
+  modelUsage: z.array(ModelUsageEntrySchema)
+});
+var UpdateTaskFieldsRequestSchema = z.object({
+  sessionId: z.string(),
+  plan: z.string().optional(),
+  description: z.string().optional()
+});
+var UpdateTaskPropertiesRequestSchema = z.object({
+  sessionId: z.string(),
+  title: z.string().optional(),
+  storyPointValue: z.number().int().positive().optional(),
+  tagIds: z.array(z.string()).optional(),
+  tagNames: z.array(z.string()).optional(),
+  githubPRUrl: z.string().url().optional(),
+  githubBranch: z.string().optional()
+});
+var ListIconsRequestSchema = z.object({
+  sessionId: z.string()
+});
+var GenerateTaskIconRequestSchema = z.object({
+  sessionId: z.string(),
+  prompt: z.string().min(1),
+  aspectRatio: z.string().optional()
+});
+var SearchFaIconsRequestSchema = z.object({
+  sessionId: z.string(),
+  query: z.string().min(1),
+  first: z.number().int().positive().optional()
+});
+var PickFaIconRequestSchema = z.object({
+  sessionId: z.string(),
+  fontAwesomeId: z.string().min(1),
+  fontAwesomeStyle: z.string().optional()
+});
+var CreateFollowUpTaskRequestSchema = z.object({
+  sessionId: z.string(),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  plan: z.string().optional(),
+  storyPointValue: z.number().int().positive().optional()
+});
+var AddDependencyRequestSchema = z.object({
+  sessionId: z.string(),
+  dependsOnSlugOrId: z.string()
+});
+var RemoveDependencyRequestSchema = z.object({
+  sessionId: z.string(),
+  dependsOnSlugOrId: z.string()
+});
+var CreateSuggestionRequestSchema = z.object({
+  sessionId: z.string(),
+  title: z.string().min(1),
+  description: z.string().optional(),
+  tagNames: z.array(z.string()).optional()
+});
+var VoteSuggestionRequestSchema = z.object({
+  sessionId: z.string(),
+  suggestionId: z.string(),
+  value: z.union([z.literal(1), z.literal(-1)])
+});
+var TriggerIdentificationRequestSchema = z.object({
+  sessionId: z.string()
+});
+var SubmitCodeReviewResultRequestSchema = z.object({
+  sessionId: z.string(),
+  approved: z.boolean(),
+  content: z.string()
+});
+var StartChildCloudBuildRequestSchema = z.object({
+  sessionId: z.string(),
+  childTaskId: z.string()
+});
+var StopChildBuildRequestSchema = z.object({
+  sessionId: z.string(),
+  childTaskId: z.string()
+});
+var ApproveAndMergePRRequestSchema = z.object({
+  sessionId: z.string(),
+  childTaskId: z.string()
+});
+var PostChildChatMessageRequestSchema = z.object({
+  sessionId: z.string(),
+  childTaskId: z.string(),
+  message: z.string().min(1)
+});
+var UpdateChildStatusRequestSchema = z.object({
+  sessionId: z.string(),
+  childTaskId: z.string(),
+  status: z.string()
+});
+var GetAgentStatusRequestSchema = z.object({
+  taskId: z.string()
+});
+var GetUiCliHistoryRequestSchema = z.object({
+  taskId: z.string()
+});
+var SendSoftStopRequestSchema = z.object({
+  taskId: z.string().optional(),
+  projectId: z.string().optional()
+});
+var FlushTaskQueueRequestSchema = z.object({
+  taskId: z.string(),
+  softStop: z.boolean().optional()
+});
+var FlushProjectQueueRequestSchema = z.object({
+  projectId: z.string()
+});
+var CancelTaskQueuedMessageRequestSchema = z.object({
+  taskId: z.string(),
+  messageId: z.string()
+});
+var FlushSingleQueuedMessageRequestSchema = z.object({
+  taskId: z.string(),
+  messageId: z.string(),
+  softStop: z.boolean().optional()
+});
+var FlushSingleProjectQueuedMessageRequestSchema = z.object({
+  projectId: z.string(),
+  index: z.number().int().nonnegative()
+});
+var AnswerAgentQuestionRequestSchema = z.object({
+  taskId: z.string(),
+  requestId: z.string(),
+  answers: z.record(z.string(), z.string())
+});
+var ClearAgentTodosRequestSchema = z.object({
+  taskId: z.string()
+});
+var AgentQuestionOptionSchema = z.object({
+  label: z.string(),
+  description: z.string(),
+  preview: z.string().optional()
+});
+var AgentQuestionSchema = z.object({
+  question: z.string(),
+  header: z.string(),
+  options: z.array(AgentQuestionOptionSchema),
+  multiSelect: z.boolean().optional()
+});
+var AskUserQuestionRequestSchema = z.object({
+  sessionId: z.string(),
+  question: z.string().min(1),
+  requestId: z.string().min(1),
+  questions: z.array(AgentQuestionSchema).min(1)
+});
+var AgentEventSchema = z.object({
+  type: z.string().min(1)
+}).catchall(z.unknown());
+var EmitAgentEventRequestSchema = z.object({
+  sessionId: z.string(),
+  events: z.array(AgentEventSchema).max(500)
+});
+var RefreshGithubTokenRequestSchema = z.object({
+  sessionId: z.string()
+});
+var RefreshGithubTokenResponseSchema = z.object({
+  token: z.string()
+});
+var CreatePRResponseSchema = z.object({
+  prNumber: z.number().int().positive(),
+  prUrl: z.string().url()
+});
+var PostToChatResponseSchema = z.object({
+  messageId: z.string()
+});
+var UpdateTaskStatusResponseSchema = z.object({
+  taskId: z.string(),
+  status: z.string()
+});
+var StoreSessionIdResponseSchema = z.object({
+  success: z.boolean()
+});
+var HeartbeatResponseSchema = z.object({
+  acknowledged: z.boolean()
+});
+var SessionStartResponseSchema = z.object({
+  sessionId: z.string(),
+  startedAt: z.string()
+});
+var SessionStopResponseSchema = z.object({
+  sessionId: z.string(),
+  stoppedAt: z.string()
+});
+var DeleteSubtaskResponseSchema = z.object({
+  deleted: z.boolean()
+});
+var RegisterProjectAgentResponseSchema = z.object({
+  registered: z.boolean(),
+  agentName: z.string(),
+  agentInstructions: z.string(),
+  model: z.string(),
+  agentSettings: z.record(z.string(), z.unknown()).nullable(),
+  branchSwitchCommand: z.string().nullable()
+});
+var RegisterProjectAgentRequestSchema = z2.object({
+  projectId: z2.string(),
+  capabilities: z2.array(z2.string())
+});
+var ProjectRunnerHeartbeatRequestSchema = z2.object({
+  projectId: z2.string()
+});
+var ReportProjectAgentStatusRequestSchema = z2.object({
+  projectId: z2.string(),
+  status: z2.enum(["busy", "idle"]),
+  activeChatId: z2.string().nullish(),
+  activeTaskId: z2.string().nullish(),
+  activeBranch: z2.string().nullish()
+});
+var DisconnectProjectRunnerRequestSchema = z2.object({
+  projectId: z2.string()
+});
+var GetProjectAgentContextRequestSchema = z2.object({
+  projectId: z2.string()
+});
+var GetProjectAgentContextByRoleRequestSchema = z2.object({
+  projectId: z2.string(),
+  role: z2.string()
+});
+var GetProjectFunctionConfigRequestSchema = z2.object({
+  projectId: z2.string(),
+  functionId: z2.string()
+});
+var GetProjectChatHistoryRequestSchema = z2.object({
+  projectId: z2.string(),
+  limit: z2.number().int().positive().optional().default(50),
+  chatId: z2.string().optional()
+});
+var PostProjectAgentMessageRequestSchema = z2.object({
+  projectId: z2.string(),
+  content: z2.string().min(1),
+  chatId: z2.string().optional()
+});
+var ListProjectTasksRequestSchema = z2.object({
+  projectId: z2.string(),
+  status: z2.string().optional(),
+  assigneeId: z2.string().optional(),
+  limit: z2.number().int().positive().optional().default(50)
+});
+var GetProjectTaskRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string()
+});
+var SearchProjectTasksRequestSchema = z2.object({
+  projectId: z2.string(),
+  tagNames: z2.array(z2.string()).optional(),
+  searchQuery: z2.string().optional(),
+  statusFilters: z2.array(z2.string()).optional(),
+  limit: z2.number().int().positive().optional().default(20)
+});
+var ListProjectTagsRequestSchema = z2.object({
+  projectId: z2.string()
+});
+var GetProjectSummaryRequestSchema = z2.object({
+  projectId: z2.string()
+});
+var CreateProjectTaskRequestSchema = z2.object({
+  projectId: z2.string(),
+  title: z2.string().min(1),
+  description: z2.string().optional(),
+  plan: z2.string().optional(),
+  status: z2.string().optional()
+});
+var UpdateProjectTaskRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  plan: z2.string().optional(),
+  status: z2.string().optional(),
+  assignedUserId: z2.string().nullish()
+});
+var ReportProjectAgentEventRequestSchema = z2.object({
+  projectId: z2.string(),
+  event: z2.record(z2.string(), z2.unknown())
+});
+var ReportTagAuditProgressRequestSchema = z2.object({
+  projectId: z2.string(),
+  requestId: z2.string(),
+  activity: z2.object({
+    tool: z2.string(),
+    input: z2.string().optional(),
+    timestamp: z2.string()
+  })
+});
+var ReportTagAuditResultRequestSchema = z2.object({
+  projectId: z2.string(),
+  requestId: z2.string(),
+  recommendations: z2.array(z2.record(z2.string(), z2.unknown())),
+  summary: z2.string(),
+  complete: z2.boolean()
+});
+var ReportNewCommitsDetectedRequestSchema = z2.object({
+  projectId: z2.string(),
+  commits: z2.array(
+    z2.object({
+      sha: z2.string(),
+      message: z2.string(),
+      author: z2.string()
+    })
+  ),
+  branch: z2.string()
+});
+var ReportEnvironmentReadyRequestSchema = z2.object({
+  projectId: z2.string(),
+  branch: z2.string(),
+  setupComplete: z2.boolean(),
+  startCommandRunning: z2.boolean()
+});
+var ReportEnvSwitchProgressRequestSchema = z2.object({
+  projectId: z2.string(),
+  step: z2.string(),
+  progress: z2.number(),
+  message: z2.string().optional()
+});
+var ForwardProjectChatMessageRequestSchema = z2.object({
+  projectId: z2.string(),
+  chatId: z2.string(),
+  content: z2.string().min(1),
+  targetUserId: z2.string().optional()
+});
+var CancelQueuedProjectMessageRequestSchema = z2.object({
+  projectId: z2.string(),
+  index: z2.number().int().nonnegative()
+});
+var GetProjectCliHistoryRequestSchema = z2.object({
+  projectId: z2.string(),
+  limit: z2.number().int().positive().optional().default(50),
+  source: z2.string().optional()
+});
+var PostToProjectTaskChatRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  content: z2.string()
+});
+var GetProjectTaskCliRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  limit: z2.number().int().positive().optional().default(50),
+  source: z2.string().optional()
+});
+var StartProjectBuildRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string()
+});
+var StopProjectBuildRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string()
+});
+var ApproveProjectMergePRRequestSchema = z2.object({
+  projectId: z2.string(),
+  childTaskId: z2.string()
+});
+var StartTaskAuditRequestSchema = z3.object({
+  projectId: z3.string(),
+  taskIds: z3.array(z3.string()).min(1)
+});
+var ReportTaskAuditProgressRequestSchema = z3.object({
+  projectId: z3.string(),
+  requestId: z3.string(),
+  taskId: z3.string(),
+  activity: z3.object({
+    tool: z3.string(),
+    input: z3.string().optional(),
+    timestamp: z3.string()
+  })
+});
+var CreateProjectSuggestionRequestSchema = z3.object({
+  projectId: z3.string(),
+  title: z3.string().min(1),
+  description: z3.string().optional(),
+  tagNames: z3.array(z3.string()).optional()
+});
+var ReportTaskAuditBatchCompleteRequestSchema = z3.object({
+  projectId: z3.string(),
+  requestId: z3.string()
+});
+var ReportTaskAuditResultRequestSchema = z3.object({
+  projectId: z3.string(),
+  requestId: z3.string(),
+  taskId: z3.string(),
+  summary: z3.string(),
+  turnGrades: z3.array(
+    z3.object({
+      turnIndex: z3.number(),
+      phase: z3.enum(["planning", "building", "human"]),
+      grade: z3.enum(["correct", "neutral", "blunder"]),
+      reasoning: z3.string(),
+      eventType: z3.string(),
+      eventSummary: z3.string()
+    })
+  ),
+  planningAccuracy: z3.number().nullable(),
+  buildingAccuracy: z3.number().nullable(),
+  humanAccuracy: z3.number().nullable(),
+  planningCorrect: z3.number(),
+  planningNeutral: z3.number(),
+  planningBlunder: z3.number(),
+  buildingCorrect: z3.number(),
+  buildingNeutral: z3.number(),
+  buildingBlunder: z3.number(),
+  humanCorrect: z3.number(),
+  humanNeutral: z3.number(),
+  humanBlunder: z3.number(),
+  humanEvaluations: z3.array(
+    z3.object({
+      messageIndex: z3.number(),
+      rating: z3.number().int().min(-1).max(1),
+      reasoning: z3.string()
+    })
+  ).optional().default([]),
+  suggestionIds: z3.array(z3.string()),
+  auditCostUsd: z3.number().nullable(),
+  model: z3.string().nullable(),
+  error: z3.string().optional()
+});
+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;
+
 // src/execution/pack-runner-prompt.ts
 function findLastAgentMessageIndex(history) {
   for (let i = history.length - 1; i >= 0; i--) {
@@ -1040,7 +1622,7 @@ function buildPackRunnerSystemPrompt(context, config, setupLog) {
     `2. Evaluate children by status and dependency readiness:`,
     `   - "ReviewPR": Review and merge its PR with approve_and_merge_pr. (Highest priority)`,
     `     - If merge fails due to pending CI: post a status update to chat, state you are going idle.`,
-    `     - If merge fails due to failed CI: use get_task_cli(childTaskId) to check. Escalate to team.`,
+    `     - If merge fails due to failed CI: use get_execution_logs(childTaskId) to check. Escalate to team.`,
     `   - "InProgress": A Task Runner is actively working. Do nothing \u2014 wait.`,
     `   - "Open" + allDependenciesMet=true: Ready to fire. Use start_child_cloud_build.`,
     `   - "Open" + allDependenciesMet=false: Blocked \u2014 skip for now. Will be unblocked when deps complete.`,
@@ -1060,7 +1642,7 @@ function buildPackRunnerSystemPrompt(context, config, setupLog) {
     `- When NO dependencies are set on any children, fall back to ordinal order (one at a time). This preserves backward compatibility.`,
     `- After firing builds OR when waiting on CI, explicitly state you are going idle. The system will disconnect you and relaunch when there's a status change.`,
     `- Do NOT attempt to write code yourself. Your role is coordination only.`,
-    `- If a child is stuck in "InProgress" for an unusually long time, use get_task_cli(childTaskId) to check its logs and escalate to the team if it appears stuck.`,
+    `- If a child is stuck in "InProgress" for an unusually long time, use get_execution_logs(childTaskId) to check its logs and escalate to the team if it appears stuck.`,
     `- You can use get_task(childTaskId) to get a child's full details including PR URL and branch.`,
     `- list_subtasks returns PR info (githubPRNumber, githubPRUrl), agent assignment (agentId), and dependency info for each child \u2014 use this to verify readiness before firing builds.`,
     `- You can use read_task_chat to check for team messages.`
@@ -1124,7 +1706,6 @@ After addressing the feedback, resume your autonomous loop: call list_subtasks a
 }
 
 // src/execution/prompt-formatters.ts
-var PM_CHAT_HISTORY_LIMIT = 40;
 function formatFileSize(bytes) {
   if (bytes === void 0) return "";
   if (bytes < 1024) return `${bytes}B`;
@@ -1146,7 +1727,7 @@ function formatChatFile(file) {
   }
   if (file.content && file.contentEncoding === "base64") {
     return [
-      `[Attached image: ${file.fileName} (${file.mimeType}${sizeStr}) \u2014 use get_task_file("${file.fileId}") to view]`
+      `[Attached image: ${file.fileName} (${file.mimeType}${sizeStr}) \u2014 use get_attachment("${file.fileId}") to view]`
     ];
   }
   return [`[Attached: ${file.fileName} (${file.mimeType}${sizeStr})]`];
@@ -1159,7 +1740,7 @@ function formatTaskFile(file) {
   if (file.content && file.contentEncoding === "base64") {
     const size = formatFileSize(file.fileSize);
     return [
-      `- [Attached image: ${file.fileName} (${file.mimeType}${size ? `, ${size}` : ""}) \u2014 use get_task_file("${file.fileId}") to view]`
+      `- [Attached image: ${file.fileName} (${file.mimeType}${size ? `, ${size}` : ""}) \u2014 use get_attachment("${file.fileId}") to view]`
     ];
   }
   if (!file.content) {
@@ -1236,7 +1817,7 @@ function formatIncidents(incidents) {
 }
 
 // src/execution/tag-context-resolver.ts
-import { readFile, readdir } from "fs/promises";
+import { readFile, readdir, stat } from "fs/promises";
 var TYPE_PRIORITY = { rule: 0, file: 1, folder: 2, doc: 3 };
 var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
   ".png",
@@ -1271,6 +1852,10 @@ function isBinaryPath(filePath) {
   const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
   return BINARY_EXTENSIONS.has(ext);
 }
+var fileContentCache = /* @__PURE__ */ new Map();
+var folderListingCache = /* @__PURE__ */ new Map();
+var fileReadCount = 0;
+var folderReadCount = 0;
 function getContextBudgetChars(_model, betas, runnerMode) {
   const contextWindow = betas?.some((b) => b.includes("context-1m")) ? 1e6 : 2e5;
   const budgetPct = runnerMode === "task" ? 0.15 : 0.25;
@@ -1279,21 +1864,50 @@ function getContextBudgetChars(_model, betas, runnerMode) {
 async function readFileContent(filePath, maxChars) {
   try {
     if (isBinaryPath(filePath)) return null;
-    const content = await readFile(filePath, "utf-8");
-    if (content.length > maxChars) {
-      const omitted = content.length - maxChars;
-      return content.slice(0, maxChars) + `
+    let rawContent;
+    let mtimeMs;
+    try {
+      const st = await stat(filePath);
+      mtimeMs = st.mtimeMs;
+    } catch {
+      return null;
+    }
+    const cached = fileContentCache.get(filePath);
+    if (cached && cached.mtimeMs === mtimeMs) {
+      rawContent = cached.content;
+    } else {
+      rawContent = await readFile(filePath, "utf-8");
+      fileReadCount++;
+      fileContentCache.set(filePath, { mtimeMs, content: rawContent });
+    }
+    if (rawContent.length > maxChars) {
+      const omitted = rawContent.length - maxChars;
+      return rawContent.slice(0, maxChars) + `
 [... truncated, ${omitted} chars omitted]`;
     }
-    return content;
+    return rawContent;
   } catch {
     return null;
   }
 }
 async function readFolderListing(folderPath) {
   try {
+    let mtimeMs;
+    try {
+      const st = await stat(folderPath);
+      mtimeMs = st.mtimeMs;
+    } catch {
+      return null;
+    }
+    const cached = folderListingCache.get(folderPath);
+    if (cached && cached.mtimeMs === mtimeMs) {
+      return cached.listing;
+    }
     const entries = await readdir(folderPath);
-    return `Files: ${entries.join(", ")}`;
+    folderReadCount++;
+    const listing = `Files: ${entries.join(", ")}`;
+    folderListingCache.set(folderPath, { mtimeMs, listing });
+    return listing;
   } catch {
     return null;
   }
@@ -1414,6 +2028,18 @@ async function resolveTagContext(projectTags, taskTagIds, model, betas, runnerMo
   };
 }
 
+// src/execution/prompt-truncation.ts
+var PLAN_SOFT_CAP = 4e3;
+var PLAN_HEAD_CHARS = 3e3;
+var PLAN_TAIL_CHARS = 500;
+var PLAN_TRUNCATION_MARKER = "\n\n... plan truncated \u2014 call get_current_plan for full text ...\n\n";
+function truncatePlanForPrompt(plan) {
+  if (plan.length <= PLAN_SOFT_CAP) return plan;
+  const head = plan.slice(0, PLAN_HEAD_CHARS);
+  const tail = plan.slice(plan.length - PLAN_TAIL_CHARS);
+  return `${head}${PLAN_TRUNCATION_MARKER}${tail}`;
+}
+
 // src/execution/mode-prompt.ts
 var SP_DESC_MAX_CHARS = 80;
 function truncateDescription(desc, maxChars) {
@@ -1473,7 +2099,19 @@ function buildExplorationMethodology() {
     `- Search first, read second: use grep/glob to locate relevant code, then read only the files that matter`,
     `- Never re-read a file already in your context \u2014 you have a large context window, scroll up instead`,
     `- Start with 3-5 critical files, form a hypothesis about the approach, then validate with targeted reads`,
-    `- Stop exploring when you can write specific file paths and function names in your plan \u2014 that's enough`
+    `- Stop exploring when you can cite specific \`file.ts:line\` locations and function names for every step in your plan \u2014 that's enough`
+  ];
+}
+function buildPlanCitationFormat() {
+  return [
+    ``,
+    `### Plan Citation Format`,
+    `Plans must ground each change in the code. For every step that touches code:`,
+    `- Cite the exact location as \`path/from/repo/root.ts:lineNumber\` (e.g. \`packages/conveyor-agent/src/execution/mode-prompt.ts:129\`).`,
+    `- Name the specific function, class, constant, or JSX element being touched.`,
+    `- When behavior hinges on a short piece of code, quote 1\u20133 lines inline instead of paraphrasing.`,
+    `- Ranges are fine for larger edits (\`foo.ts:120-145\`). Do not cite whole files without a line.`,
+    `- If a file doesn't exist yet, write \`NEW: path/to/new-file.ts\` and describe the surrounding module it fits into.`
   ];
 }
 function buildDiscoveryPrompt(context, runnerMode) {
@@ -1493,15 +2131,16 @@ function buildDiscoveryPrompt(context, runnerMode) {
     `Your PRIMARY goal is to create a thorough plan. Complete these steps in order:`,
     `1. Read the task description and chat history \u2014 respond to what's been discussed`,
     `2. Investigate the codebase using the methodology below \u2014 search first, read targeted files`,
-    `3. Save a detailed plan via \`update_task\``,
+    `3. Save a detailed plan via \`update_task_plan\``,
     `4. Set story points, tags, and title via \`update_task_properties\` (icon is set automatically)`,
     `5. Discuss the plan with the team if they're engaged, incorporate feedback`,
     `6. THEN call ExitPlanMode \u2014 it is the LAST step, not the first`,
     ...buildExplorationMethodology(),
+    ...buildPlanCitationFormat(),
     ``,
     `### Self-Identification Tools`,
     `Use these MCP tools to set your own task properties:`,
-    `- \`update_task\` \u2014 save your plan and description`,
+    `- \`update_task_plan\` \u2014 save your plan and description`,
     `- \`update_task_properties\` \u2014 set title, story points, and tags (any combination)`,
     `Note: Icons are assigned automatically during identification after planning is complete.`,
     ``,
@@ -1524,21 +2163,20 @@ function buildDiscoveryPrompt(context, runnerMode) {
     `### Subtask Plan Requirements`,
     `When creating subtasks, each MUST include a detailed \`plan\` field:`,
     `- Plans should be multi-step implementation guides, not vague descriptions`,
-    `- Include specific file paths, function names, and code patterns to modify`,
+    `- Include concrete \`file.ts:line\` citations, function/symbol names, and short code snippets where relevant`,
     `- Reference existing implementations when relevant (e.g., "follow the pattern in src/services/foo.ts")`,
     `- Include testing requirements and acceptance criteria`,
     `- Set \`storyPointValue\` based on estimated complexity`,
     ``,
     `### Plan Verification Requirements`,
-    `Every plan MUST include a **Testing / Verification** section enumerating:`,
-    `- The quality gates: \`bun run lint\`, \`bun run typecheck\`, \`bun run test\` (or scoped equivalents)`,
+    `Every plan MUST include a **Testing / Verification** section so the build agent has a clear definition of "done". Enumerate:`,
+    `- The quality gates the build agent should run: \`bun run lint\`, \`bun run typecheck\`, \`bun run test\` (or scoped equivalents)`,
     `- Any task-specific end-to-end checks (manual UI walk-through, API smoke test, migration dry-run, etc.)`,
-    `- For refactors: line-count / file-size expectations and a public-API-surface diff check`,
-    `This ensures executing agents and reviewers have a clear definition of "done" and prevents silent regressions.`,
+    `You are NOT expected to run these gates yourself \u2014 discovery is read-only. Just describe them in the plan.`,
     ``,
     `### Completing Planning`,
     `Once ALL checklist items above are done, call the **ExitPlanMode** tool.`,
-    `- Required before ExitPlanMode will succeed: **plan** (via update_task), **story points** (via update_task_properties), **title** (via update_task_properties)`,
+    `- Required before ExitPlanMode will succeed: **plan** (via update_task_plan), **story points** (via update_task_properties), **title** (via update_task_properties)`,
     `- ExitPlanMode validates these properties and marks planning as complete`,
     `- It does NOT start building \u2014 the team controls when to switch to Build mode`,
     `- Do NOT call ExitPlanMode until you have thoroughly explored the codebase and saved a detailed plan`
@@ -1554,11 +2192,11 @@ function buildAutoPrompt(context, runnerMode) {
     ``,
     `### Phase 1: Discovery & Planning (current)`,
     `- You are in the SDK's plan mode \u2014 read-only access is enforced automatically`,
-    `- You have MCP tools for task properties: update_task, update_task_properties`,
+    `- You have MCP tools for task properties: update_task_plan, update_task_properties`,
     ``,
     `### Required before transitioning:`,
     `Before calling ExitPlanMode, you MUST fill in ALL of these:`,
-    `1. **Plan** \u2014 Save a clear implementation plan using update_task`,
+    `1. **Plan** \u2014 Save a clear implementation plan using update_task_plan`,
     `2. **Story Points** \u2014 Assign via update_task_properties`,
     `3. **Title** \u2014 Set an accurate title via update_task_properties (if the current one is vague or "Untitled")`,
     ``,
@@ -1571,11 +2209,13 @@ function buildAutoPrompt(context, runnerMode) {
     `### Subtask Plan Requirements`,
     `When creating subtasks, each MUST include a detailed \`plan\` field:`,
     `- Plans should be multi-step implementation guides, not vague descriptions`,
-    `- Include specific file paths, function names, and code patterns to modify`,
+    `- Include concrete \`file.ts:line\` citations, function/symbol names, and short code snippets where relevant`,
     `- Reference existing implementations when relevant`,
     `- Include testing requirements and acceptance criteria`,
     `- Set \`storyPointValue\` based on estimated complexity`,
     ``,
+    ...buildPlanCitationFormat(),
+    ``,
     ...context?.isParentTask ? [
       ``,
       `### Parent Task Guidance`,
@@ -1645,7 +2285,7 @@ function buildReviewPrompt(context) {
       `You are reviewing and coordinating child tasks.`,
       `- Use \`list_subtasks\` to see current child task state and progress.`,
       `- For children in ReviewPR status: review their code quality and merge with \`approve_and_merge_pr\`.`,
-      `- For children with failing CI: check with \`get_task_cli(childTaskId)\` and escalate if stuck.`,
+      `- For children with failing CI: check with \`get_execution_logs(childTaskId)\` and escalate if stuck.`,
       `- Fire next child builds with \`start_child_cloud_build\` when ready.`,
       `- Create follow-up tasks for issues discovered during review.`,
       ``,
@@ -1722,7 +2362,7 @@ Environment (ready, no setup required):`,
     `
 Workflow:`,
     `- You can draft and iterate on plans in .claude/plans/*.md \u2014 these files are automatically synced to the task.`,
-    `- You can also use update_task directly to save the plan to the task.`,
+    `- You can also use update_task_plan directly to save the plan to the task.`,
     `- After saving the plan, end your turn with a summary reply (the team sees your responses in chat automatically). Do NOT attempt to execute the plan yourself.`,
     `- A separate task agent will handle execution after the team reviews and approves your plan.`
   ];
@@ -1749,7 +2389,7 @@ function buildActivePreamble(context, workspaceDir) {
     `You are an AI project manager in ACTIVE mode for the "${context.title}" project.`,
     `You have direct coding access to the repository at ${workspaceDir}.`,
     `You can edit files, run tests, and make commits.`,
-    `You still have access to all PM tools (subtasks, update_task, chat).`,
+    `You still have access to all PM tools (subtasks, update_task_plan, chat).`,
     `
 Environment (ready, no setup required):`,
     `- Repository is cloned at your current working directory.`,
@@ -1876,17 +2516,26 @@ Your responses are sent directly to the task chat \u2014 the team sees everythin
 }
 
 // src/execution/prompt-builder.ts
-var TASK_CHAT_HISTORY_LIMIT = 20;
 function findLastAgentMessageIndex2(history) {
   for (let i = history.length - 1; i >= 0; i--) {
     if (history[i].role === "assistant") return i;
   }
   return -1;
 }
+function messagesAfterCursor(history, lastSeenMessageId) {
+  if (!lastSeenMessageId) return history;
+  const idx = history.findIndex((m) => m.id === lastSeenMessageId);
+  return idx === -1 ? history : history.slice(idx + 1);
+}
 function detectRelaunchScenario(context, trustChatHistory = false) {
+  if (context.lastSeenMessageId) {
+    const newMessages = messagesAfterCursor(context.chatHistory, context.lastSeenMessageId);
+    const hasNewUserMessages2 = newMessages.some((m) => m.role === "user");
+    return hasNewUserMessages2 ? "feedback_relaunch" : "idle_relaunch";
+  }
   const lastAgentIdx = findLastAgentMessageIndex2(context.chatHistory);
   if (lastAgentIdx === -1) return "fresh";
-  const hasPriorWork = !!context.githubPRUrl || !!context.claudeSessionId || trustChatHistory;
+  const hasPriorWork = !!context.githubPRUrl || trustChatHistory;
   if (!hasPriorWork) return "fresh";
   const messagesAfterAgent = context.chatHistory.slice(lastAgentIdx + 1);
   const hasNewUserMessages = messagesAfterAgent.some((m) => m.role === "user");
@@ -1925,7 +2574,7 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
       parts.push(
         `
 You are in auto mode. A plan already exists for this task.`,
-        `Verify that story points, title, and tags are set via get_task_plan, then call ExitPlanMode immediately to transition to building.`,
+        `Verify that story points, title, and tags are set via get_current_plan, then call ExitPlanMode immediately to transition to building.`,
         `Do NOT wait for team input \u2014 proceed autonomously.`
       );
     } else {
@@ -1947,13 +2596,14 @@ You are the project manager for this task.`,
 }
 function buildRelaunchWithSession(mode, context, agentMode, isAuto) {
   const scenario = detectRelaunchScenario(context);
-  if (!context.claudeSessionId || scenario === "fresh") return null;
+  const hasPriorTurn = !!context.lastSeenMessageId || !!context.claudeSessionId;
+  if (!hasPriorTurn || scenario === "fresh") return null;
   const parts = [];
   const lastAgentIdx = findLastAgentMessageIndex2(context.chatHistory);
   if (mode === "pm") {
     parts.push(...buildPmRelaunchParts(context, lastAgentIdx, isAuto, agentMode));
   } else if (scenario === "feedback_relaunch") {
-    const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
+    const newMessages = (context.lastSeenMessageId ? messagesAfterCursor(context.chatHistory, context.lastSeenMessageId) : context.chatHistory.slice(lastAgentIdx + 1)).filter((m) => m.role === "user");
     parts.push(
       `You have been relaunched with new feedback.`,
       `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
@@ -2024,7 +2674,7 @@ ${context.description}`);
   if (context.plan) {
     parts.push(`
 ## Plan
-${context.plan}`);
+${truncatePlanForPrompt(context.plan)}`);
   }
   if (context.files && context.files.length > 0) {
     parts.push(`
@@ -2081,7 +2731,7 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
     return [
       `You are operating autonomously. Begin planning immediately.`,
       `1. Search the codebase (grep/glob) to locate relevant files, then read the critical ones`,
-      `2. Draft a clear implementation plan and save it with update_task`,
+      `2. Draft a clear implementation plan and save it with update_task_plan`,
       `3. Set story points, tags, and title (update_task_properties)`,
       `4. When the plan and all required properties are set, call ExitPlanMode to transition to building`,
       `Do NOT wait for team input \u2014 proceed autonomously.`
@@ -2093,7 +2743,7 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
       `Review existing subtasks via \`list_subtasks\` and the chat history before taking action.`,
       `Read the task description and chat history carefully \u2014 the team has provided the initial context below. Acknowledge what they've asked for and respond in chat before taking silent tool actions.`,
       `Start planning now \u2014 explore the codebase, ask clarifying questions if needed, and propose a subtask breakdown. Do not wait for additional team input before engaging.`,
-      `When you finish planning, save the plan with update_task and end your turn. Your reply will be visible to the team in chat.`
+      `When you finish planning, save the plan with update_task_plan and end your turn. Your reply will be visible to the team in chat.`
     ];
   }
   if (isPm) {
@@ -2101,7 +2751,7 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
       `You are the project manager for this task.`,
       `Read the task description and chat history carefully \u2014 the team has provided the initial context below. Acknowledge what they've asked for and respond in chat before taking silent tool actions.`,
       `Start planning now \u2014 explore the codebase, ask clarifying questions if needed, and draft a plan. Do not wait for additional team input before engaging; the initial message IS the team engaging.`,
-      `When you finish planning, save the plan with update_task and end your turn. Your reply summarizing the plan will be visible in chat. A separate task agent will execute the plan after review.`
+      `When you finish planning, save the plan with update_task_plan and end your turn. Your reply summarizing the plan will be visible in chat. A separate task agent will execute the plan after review.`
     ];
   }
   const parts = [
@@ -2145,7 +2795,7 @@ Your plan has been approved. Address the feedback above, then begin implementing
     } else if (isAuto) {
       parts2.push(
         `
-You are in auto mode. Address the feedback above \u2014 update the plan accordingly using update_task.`,
+You are in auto mode. Address the feedback above \u2014 update the plan accordingly using update_task_plan.`,
         `When the plan and all required properties are set, call ExitPlanMode to transition to building.`,
         `Do NOT wait for additional team input \u2014 the messages above ARE the team's input. Proceed autonomously.`
       );
@@ -2256,14 +2906,14 @@ async function buildInitialPrompt(mode, context, isAuto, agentMode) {
 }
 
 // src/tools/task-context-tools.ts
-import { z } from "zod";
+import { z as z4 } from "zod";
 function buildReadTaskChatTool(connection) {
   return defineTool(
     "read_task_chat",
-    "Read recent human/user chat messages for a task. When to use: you need to see user instructions, questions, or feedback posted to the task chat. Omit task_id for the current task, or pass a child task ID to read a child's chat. When NOT to use: for agent reasoning, tool calls, or setup/dev-server output \u2014 use get_task_cli instead. Returns: JSON array of recent chat messages (default 20).",
+    "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: z.number().optional().describe("Number of recent messages to fetch (default 20)"),
-      task_id: z.string().optional().describe("Child task ID to read chat from. Omit to read the current task's chat.")
+      limit: z4.number().optional().describe("Number of recent messages to fetch (default 20)"),
+      task_id: z4.string().optional().describe("Child task ID to read chat from. Omit to read the current task's chat.")
     },
     async ({ limit, task_id }) => {
       try {
@@ -2284,10 +2934,10 @@ function buildReadTaskChatTool(connection) {
     { annotations: { readOnlyHint: true } }
   );
 }
-function buildGetTaskPlanTool(connection) {
+function buildGetCurrentPlanTool(connection) {
   return defineTool(
-    "get_task_plan",
-    "Re-read the current task's plan. When to use: the user just said they updated the plan mid-session or explicitly asked you to re-read it. When NOT to use: to fetch general task info (title, status, description) \u2014 use get_task. The plan was already included in your initial context, so do not call this speculatively. Returns: the plan markdown string.",
+    "get_current_plan",
+    "Re-read the current task's plan. Use when the user updated the plan or asked you to re-read it \u2014 otherwise the plan is already in initial context. For task metadata use get_task.",
     {},
     async () => {
       try {
@@ -2305,9 +2955,9 @@ function buildGetTaskPlanTool(connection) {
 function buildGetTaskTool(connection) {
   return defineTool(
     "get_task",
-    "Look up any task by slug or ID. When to use: you need the current title, description, plan, status, branch, PR info, or story points for this or a related task. When NOT to use: to list child tasks (use list_subtasks), or to re-read only the current plan (use get_task_plan). Returns: JSON task object including id, slug, title, description, plan, status, branch, githubPRNumber, githubPRUrl, storyPointValue.",
+    "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: z.string().describe("The task slug (e.g. 'my-task') or CUID")
+      slug_or_id: z4.string().describe("The task slug (e.g. 'my-task') or CUID")
     },
     async ({ slug_or_id }) => {
       try {
@@ -2325,14 +2975,14 @@ function buildGetTaskTool(connection) {
     { annotations: { readOnlyHint: true } }
   );
 }
-function buildGetTaskCliTool(connection) {
+function buildGetExecutionLogsTool(connection) {
   return defineTool(
-    "get_task_cli",
-    "Read CLI execution logs from a task \u2014 agent reasoning, tool calls, and setup/dev-server output. When to use: inspecting what another agent did, debugging build/setup output, or reviewing prior tool calls. Filter with source='agent' for reasoning and tool calls only, source='application' for setup/dev-server output only. When NOT to use: for human/user chat \u2014 use read_task_chat. Returns: newline-joined event log lines each prefixed with `[timestamp] [type]` and formatted content.",
+    "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: z.string().optional().describe("Task ID or slug. Omit to read logs from the current task."),
-      source: z.enum(["agent", "application"]).optional().describe("Filter by log source. Omit for all logs."),
-      limit: z.number().optional().describe("Max number of log entries to return (default 50, max 500).")
+      task_id: z4.string().optional().describe("Task ID or slug. Omit to read logs from the current task."),
+      source: z4.enum(["agent", "application"]).optional().describe("Filter by log source. Omit for all logs."),
+      limit: z4.number().optional().describe("Max number of log entries to return (default 50, max 500).")
     },
     async ({ task_id, source, limit }) => {
       try {
@@ -2361,7 +3011,7 @@ function buildGetTaskCliTool(connection) {
 function buildListTaskFilesTool(connection) {
   return defineTool(
     "list_task_files",
-    "List all files attached to this task with metadata. When to use: before fetching a specific file, to see what is available and how large each is. When NOT to use: to read a file's contents \u2014 use get_task_file. Returns: JSON array of file metadata (id, name, mimeType, size, downloadUrl), plus inline image blocks for any attached images.",
+    "List all files attached to this task with metadata. Use before fetching a specific file to see what is available and how large each is. For file contents use get_attachment.",
     {},
     async () => {
       try {
@@ -2388,11 +3038,11 @@ function buildListTaskFilesTool(connection) {
     { annotations: { readOnlyHint: true } }
   );
 }
-function buildGetTaskFileTool(connection) {
+function buildGetAttachmentTool(connection) {
   return defineTool(
-    "get_task_file",
-    "Fetch one task file's content plus metadata by file ID. When to use: you have a file ID from list_task_files and need its content or download URL. Call list_task_files first to discover IDs and check sizes \u2014 large binaries may be truncated by the service's size limit. When NOT to use: to enumerate attachments \u2014 use list_task_files. Returns: JSON metadata; for images an inline image block is also returned, and text content is embedded inline when available.",
-    { fileId: z.string().describe("The file ID to retrieve") },
+    "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: z4.string().describe("The file ID to retrieve") },
     async ({ fileId }) => {
       try {
         const file = await connection.call("getTaskFile", {
@@ -2421,20 +3071,20 @@ function buildGetTaskFileTool(connection) {
 function buildTaskContextTools(connection) {
   return [
     buildReadTaskChatTool(connection),
-    buildGetTaskPlanTool(connection),
+    buildGetCurrentPlanTool(connection),
     buildGetTaskTool(connection),
-    buildGetTaskCliTool(connection),
+    buildGetExecutionLogsTool(connection),
     buildListTaskFilesTool(connection),
-    buildGetTaskFileTool(connection)
+    buildGetAttachmentTool(connection)
   ];
 }
 
 // src/tools/dependency-suggestion-tools.ts
-import { z as z2 } from "zod";
+import { z as z5 } from "zod";
 function buildGetDependenciesTool(connection) {
   return defineTool(
     "get_dependencies",
-    "Get this task's dependencies and their current met/unmet status. When to use: confirming that blockers have been merged before starting work, or investigating why a task cannot start. When NOT to use: to look up a specific task's state \u2014 use get_task. Returns: JSON array of dependency objects (slug, title, status, and whether the dependency is met \u2014 met means merged to dev).",
+    "Get this task's dependencies and their met/unmet status (met = merged to dev). Use to confirm blockers merged, or see why a task cannot start. For task state use get_task.",
     {},
     async () => {
       try {
@@ -2454,12 +3104,12 @@ function buildGetDependenciesTool(connection) {
 function buildGetSuggestionsTool(connection) {
   return defineTool(
     "get_suggestions",
-    "List project suggestions sorted by vote score. When to use: seeing what the team thinks is important, finding a suggestion to vote on, or checking for duplicates before create_suggestion. Filter by status (Planning, Open, InProgress, ReviewPR, ReviewDev, ReviewLive, Complete, Cancelled) or cap results with limit (default 20). When NOT to use: for task lists \u2014 suggestions are project-level idea records, not tasks. Returns: JSON array of suggestions with id, title, description, status, score.",
+    "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: z2.string().optional().describe(
+      status: z5.string().optional().describe(
         "Filter by status: Planning, Open, InProgress, ReviewPR, ReviewDev, ReviewLive, Complete, Cancelled"
       ),
-      limit: z2.number().int().min(1).max(100).optional().describe("Max results (default 20)")
+      limit: z5.number().int().min(1).max(100).optional().describe("Max results (default 20)")
     },
     async ({ status, limit }) => {
       try {
@@ -2483,14 +3133,14 @@ function buildGetSuggestionsTool(connection) {
 }
 
 // src/tools/mutation-tools.ts
-import { z as z3 } from "zod";
+import { z as z6 } from "zod";
 function buildPostToChatTool(connection) {
   return defineTool(
     "post_to_chat",
-    "Post an out-of-band message to a task chat. When to use: the user explicitly asked for a status update that must appear in chat, or you need to message a child task's chat (pass its ID as task_id). When NOT to use: for normal responses \u2014 your regular replies already appear in the current task's chat automatically. Returns: confirmation string.",
+    "Post an out-of-band chat message to a task. Use only when explicitly asked, or to message a child's chat (pass its ID). Normal replies already appear in chat automatically.",
     {
-      message: z3.string().describe("The message to post to the team"),
-      task_id: z3.string().optional().describe("Child task ID to post to. Omit to post to the current task's chat.")
+      message: z6.string().describe("The message to post to the team"),
+      task_id: z6.string().optional().describe("Child task ID to post to. Omit to post to the current task's chat.")
     },
     async ({ message, task_id }) => {
       try {
@@ -2500,10 +3150,21 @@ function buildPostToChatTool(connection) {
             childTaskId: task_id,
             message
           });
-          return textResult(`Message posted to child task ${task_id} chat.`);
+          return textResult(JSON.stringify({ posted: true, target: `child:${task_id}` }));
+        }
+        const dedup = connection.checkAndTrackDuplicate(message);
+        if (dedup.duplicate) {
+          return textResult(
+            JSON.stringify({
+              posted: false,
+              reason: "duplicate",
+              matchedMessagePreview: dedup.matchedMessagePreview,
+              hint: "A near-identical message (>70% word overlap) was posted within the last 30s. Rephrase with new information or skip this post."
+            })
+          );
         }
         await connection.call("postToChat", { message });
-        return textResult("Message posted to task chat.");
+        return textResult(JSON.stringify({ posted: true }));
       } catch (error) {
         return textResult(
           `Failed to post message: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -2515,10 +3176,10 @@ function buildPostToChatTool(connection) {
 function buildForceUpdateTaskStatusTool(connection) {
   return defineTool(
     "force_update_task_status",
-    "EMERGENCY ONLY: force-override a task's Kanban status. When to use: an automatic transition failed and the task is wedged \u2014 e.g. a PR was merged but status did not advance to ReviewDev, a build completed but status is still InProgress with no session running, or a child is stuck in ReviewPR after its PR was closed. When NOT to use: in normal flow \u2014 building, PR creation, and merge each transition status automatically. Omit task_id for the current task; pass a child task ID to update a child. Returns: confirmation string.",
+    "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: z3.enum(["InProgress", "ReviewPR", "ReviewDev", "Complete"]).describe("The new status for the task"),
-      task_id: z3.string().optional().describe("Child task ID to update. Omit to update the current task.")
+      status: z6.enum(["InProgress", "ReviewPR", "ReviewDev", "Complete"]).describe("The new status for the task"),
+      task_id: z6.string().optional().describe("Child task ID to update. Omit to update the current task.")
     },
     async ({ status, task_id }) => {
       try {
@@ -2547,17 +3208,17 @@ function buildForceUpdateTaskStatusTool(connection) {
 function buildCreatePullRequestTool(connection, config) {
   return defineTool(
     "create_pull_request",
-    "Create a GitHub pull request for this task. Runs in order: 1) stage any uncommitted changes, 2) commit them (using commitMessage, or a default derived from title), 3) push to origin, 4) create the PR via GitHub API. When to use: opening the PR for this task \u2014 always use this instead of the gh CLI or raw git. Common failures: missing remote branch, a PR already open for this branch, or an expired git token (retry after the refresh). Returns: confirmation string with the new PR number and URL.",
+    "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: z3.string().describe("The PR title"),
-      body: z3.string().describe("The PR description/body in markdown"),
-      branch: z3.string().optional().describe(
+      title: z6.string().describe("The PR title"),
+      body: z6.string().describe("The PR description/body in markdown"),
+      branch: z6.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: z3.string().optional().describe(
+      baseBranch: z6.string().optional().describe(
         "The base branch to target for the PR (e.g. 'main', 'develop'). Defaults to the project's configured dev branch."
       ),
-      commitMessage: z3.string().optional().describe(
+      commitMessage: z6.string().optional().describe(
         "Commit message for staging uncommitted changes. If not provided, a default message based on the PR title will be used."
       )
     },
@@ -2633,9 +3294,9 @@ Troubleshooting:
 function buildAddDependencyTool(connection) {
   return defineTool(
     "add_dependency",
-    "Add a blocking dependency \u2014 this task cannot start until the named task is merged to dev. When to use: you discovered work that must land before this task can proceed. When NOT to use: to track work that should happen after this task \u2014 use create_follow_up_task instead. Returns: confirmation string.",
+    "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: z3.string().describe("Slug or ID of the task this task depends on")
+      depends_on_slug_or_id: z6.string().describe("Slug or ID of the task this task depends on")
     },
     async ({ depends_on_slug_or_id }) => {
       try {
@@ -2657,7 +3318,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: z3.string().describe("Slug or ID of the task to remove as dependency")
+      depends_on_slug_or_id: z6.string().describe("Slug or ID of the task to remove as dependency")
     },
     async ({ depends_on_slug_or_id }) => {
       try {
@@ -2677,12 +3338,12 @@ function buildRemoveDependencyTool(connection) {
 function buildCreateFollowUpTaskTool(connection) {
   return defineTool(
     "create_follow_up_task",
-    "Create a follow-up task that depends on the current task. When to use: out-of-scope work, v1.1 features, or cleanup that should happen after this task merges. The new task will be unblocked once the current task is merged. When NOT to use: to add a blocker to this task \u2014 use add_dependency instead. Returns: confirmation string with the new task's slug.",
+    "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: z3.string().describe("Follow-up task title"),
-      description: z3.string().optional().describe("Brief description of the follow-up work"),
-      plan: z3.string().optional().describe("Implementation plan if known"),
-      story_point_value: z3.number().optional().describe("Story point estimate (1=Common, 2=Magic, 3=Rare, 5=Unique)")
+      title: z6.string().describe("Follow-up task title"),
+      description: z6.string().optional().describe("Brief description of the follow-up work"),
+      plan: z6.string().optional().describe("Implementation plan if known"),
+      story_point_value: z6.number().optional().describe("Story point estimate (1=Common, 2=Magic, 3=Rare, 5=Unique)")
     },
     async ({ title, description, plan, story_point_value }) => {
       try {
@@ -2707,13 +3368,13 @@ function buildCreateFollowUpTaskTool(connection) {
 function buildCreateSuggestionTool(connection) {
   return defineTool(
     "create_suggestion",
-    "Suggest a feature, improvement, rule, or idea for the project. When to use: recommending anything project-scoped \u2014 a document, a rule, a feature, a task, an optimization. If a similar suggestion already exists the service will dedupe and record your upvote instead. When NOT to use: for actionable work scoped to the current task \u2014 open a follow-up task. Returns: confirmation string with the suggestion id (and mergedIntoId if deduped).",
+    "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: z3.string().describe("Short title for the suggestion"),
-      description: z3.string().optional().describe(
+      title: z6.string().describe("Short title for the suggestion"),
+      description: z6.string().optional().describe(
         "1-2 sentence description of what should change and why. Keep concise and project-focused."
       ),
-      tag_names: z3.array(z3.string()).optional().describe("Tag names to categorize the suggestion")
+      tag_names: z6.array(z6.string()).optional().describe("Tag names to categorize the suggestion")
     },
     async ({ title, description, tag_names }) => {
       try {
@@ -2740,10 +3401,10 @@ function buildCreateSuggestionTool(connection) {
 function buildVoteSuggestionTool(connection) {
   return defineTool(
     "vote_suggestion",
-    "Vote +1 or -1 on a project suggestion. When to use: expressing support or disagreement with a specific suggestion returned from get_suggestions. Returns: confirmation string with the suggestion's updated score.",
+    "Vote +1 or -1 on a project suggestion. Use to express support or disagreement with a specific suggestion returned by get_suggestions.",
     {
-      suggestion_id: z3.string().describe("The suggestion ID to vote on"),
-      value: z3.number().refine((v) => v === 1 || v === -1, { message: "Value must be 1 or -1" }).describe("+1 to upvote, -1 to downvote")
+      suggestion_id: z6.string().describe("The suggestion ID to vote on"),
+      value: z6.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 {
@@ -2784,15 +3445,15 @@ function buildCommonTools(connection, config) {
 }
 
 // src/tools/pm-tools.ts
-import { z as z4 } from "zod";
+import { z as z7 } from "zod";
 var SP_DESCRIPTION = "Story point value (1=Common, 2=Magic, 3=Rare, 5=Unique)";
 function buildUpdateTaskTool(connection) {
   return defineTool(
-    "update_task",
-    "Save the finalized plan and/or description to the current task. When to use: in Plan mode, after reaching alignment with the user on the approach. When NOT to use: for child/subtasks \u2014 use update_subtask. This tool does not change status or other properties. Returns: confirmation string.",
+    "update_task_plan",
+    "Save the finalized plan and/or description to the current task. Use in Plan mode after alignment. For children use update_subtask; for title/tags/PR use update_task_properties.",
     {
-      plan: z4.string().optional().describe("The task plan in markdown"),
-      description: z4.string().optional().describe("Updated task description")
+      plan: z7.string().optional().describe("The task plan in markdown"),
+      description: z7.string().optional().describe("Updated task description")
     },
     async ({ plan, description }) => {
       try {
@@ -2811,13 +3472,13 @@ function buildUpdateTaskTool(connection) {
 function buildCreateSubtaskTool(connection) {
   return defineTool(
     "create_subtask",
-    "Create a subtask under the current parent task. When to use: breaking a complex parent task into smaller pieces during planning. When NOT to use: for follow-ups that depend on this task but are not children \u2014 use create_follow_up_task. Returns: confirmation string with the new subtask id.",
+    "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: z4.string().describe("Subtask title"),
-      description: z4.string().optional().describe("Brief description"),
-      plan: z4.string().optional().describe("Implementation plan in markdown"),
-      ordinal: z4.number().optional().describe("Step/order number (0-based)"),
-      storyPointValue: z4.number().optional().describe(SP_DESCRIPTION)
+      title: z7.string().describe("Subtask title"),
+      description: z7.string().optional().describe("Brief description"),
+      plan: z7.string().optional().describe("Implementation plan in markdown"),
+      ordinal: z7.number().optional().describe("Step/order number (0-based)"),
+      storyPointValue: z7.number().optional().describe(SP_DESCRIPTION)
     },
     async ({ title, description, plan, ordinal, storyPointValue }) => {
       try {
@@ -2841,14 +3502,14 @@ function buildCreateSubtaskTool(connection) {
 function buildUpdateSubtaskTool(connection) {
   return defineTool(
     "update_subtask",
-    "Update an existing subtask's fields (title, description, plan, ordinal, storyPointValue). When to use: refining a child's plan or reordering the subtask queue. When NOT to use: to change status (pack tools do that automatically) or to update the current task itself (use update_task). Returns: confirmation string.",
+    "Update an existing subtask's fields (title, description, plan, ordinal, storyPointValue). Use when refining a child's plan or reordering. For the current task use update_task_plan.",
     {
-      subtaskId: z4.string().describe("The subtask ID to update"),
-      title: z4.string().optional(),
-      description: z4.string().optional(),
-      plan: z4.string().optional(),
-      ordinal: z4.number().optional(),
-      storyPointValue: z4.number().optional().describe(SP_DESCRIPTION)
+      subtaskId: z7.string().describe("The subtask ID to update"),
+      title: z7.string().optional(),
+      description: z7.string().optional(),
+      plan: z7.string().optional(),
+      ordinal: z7.number().optional(),
+      storyPointValue: z7.number().optional().describe(SP_DESCRIPTION)
     },
     async ({ subtaskId, title, description, plan, storyPointValue }) => {
       try {
@@ -2871,7 +3532,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: z4.string().describe("The subtask ID to delete") },
+    { subtaskId: z7.string().describe("The subtask ID to delete") },
     async ({ subtaskId }) => {
       try {
         await connection.call("deleteSubtask", {
@@ -2888,7 +3549,7 @@ function buildDeleteSubtaskTool(connection) {
 function buildListSubtasksTool(connection) {
   return defineTool(
     "list_subtasks",
-    "List all subtasks under the current parent task. When to use: coordinating child work \u2014 check who is running, which children are ready for review, or which are blocked. When NOT to use: for non-child related tasks \u2014 use get_task. Returns: JSON array with id, slug, title, status, storyPointValue, githubPRNumber, githubPRUrl, agentId, and plan for each child.",
+    "List all subtasks under the current parent task. Use to coordinate child work \u2014 check who is running, ready for review, or blocked. For non-child tasks use get_task.",
     {},
     async () => {
       try {
@@ -2907,9 +3568,9 @@ function buildPackTools(connection) {
   return [
     defineTool(
       "start_child_cloud_build",
-      "Start a cloud build (codespace) for a child task. Preconditions: the child must be in Open status, have a story point value, and have an agent assigned. When NOT to use: if the child is already InProgress or past Open \u2014 it is already building or done. Returns: confirmation string including the child task id that the build was started for.",
+      "Start a cloud build (codespace) for a child task. Preconditions: child is in Open status, has a story point value, and has an agent assigned.",
       {
-        childTaskId: z4.string().describe("The child task ID to start a cloud build for")
+        childTaskId: z7.string().describe("The child task ID to start a cloud build for")
       },
       async ({ childTaskId }) => {
         try {
@@ -2927,9 +3588,9 @@ function buildPackTools(connection) {
     ),
     defineTool(
       "stop_child_build",
-      "Send a graceful stop signal to a running child build's agent. When to use: you decided the child should halt (plan changed, deadlock, scope pivot) and want the agent to exit cleanly. This is not a force-kill \u2014 the agent may take a moment to wind down. Returns: confirmation string.",
+      "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.",
       {
-        childTaskId: z4.string().describe("The child task ID whose build should be stopped")
+        childTaskId: z7.string().describe("The child task ID whose build should be stopped")
       },
       async ({ childTaskId }) => {
         try {
@@ -2947,9 +3608,9 @@ function buildPackTools(connection) {
     ),
     defineTool(
       "approve_and_merge_pr",
-      "Approve and merge a child task's PR. Preconditions: child is in ReviewPR and you have reviewed the diff. When NOT to use: if review surfaced issues \u2014 post to the child's chat or escalate instead. Returns: { childTaskId, prNumber, merged }. merged=true means the merge happened and status is now ReviewDev. merged=false means the merge is queued for GitHub automerge (CI still running) \u2014 do NOT proceed as if merged; wait for the child's status to transition to ReviewDev. If checks have failed, this call errors \u2014 investigate the failure.",
+      "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: z4.string().describe("The child task ID whose PR should be approved and merged")
+        childTaskId: z7.string().describe("The child task ID whose PR should be approved and merged")
       },
       async ({ childTaskId }) => {
         try {
@@ -2987,7 +3648,7 @@ function buildPmTools(connection, options) {
 }
 
 // src/tools/discovery-tools.ts
-import { z as z5 } from "zod";
+import { z as z8 } from "zod";
 var SP_DESCRIPTION2 = "Story point value (1=Common, 2=Magic, 3=Rare, 5=Unique)";
 function buildDiscoveryTools(connection) {
   return [
@@ -2995,11 +3656,11 @@ function buildDiscoveryTools(connection) {
       "update_task_properties",
       "Set one or more task properties in a single call. All fields are optional \u2014 only include the fields you want to update.",
       {
-        title: z5.string().optional().describe("The new task title"),
-        storyPointValue: z5.number().optional().describe(SP_DESCRIPTION2),
-        tagNames: z5.array(z5.string()).optional().describe("Array of tag names to assign"),
-        githubPRUrl: z5.string().url().optional().describe("GitHub pull request URL to link to this task"),
-        githubBranch: z5.string().optional().describe("Set the GitHub branch name for this task (e.g. 'conveyor/my-feature-abc123')")
+        title: z8.string().optional().describe("The new task title"),
+        storyPointValue: z8.number().optional().describe(SP_DESCRIPTION2),
+        tagNames: z8.array(z8.string()).optional().describe("Array of tag names to assign"),
+        githubPRUrl: z8.string().url().optional().describe("GitHub pull request URL to link to this task"),
+        githubBranch: z8.string().optional().describe("Set the GitHub branch name for this task (e.g. 'conveyor/my-feature-abc123')")
       },
       async ({ title, storyPointValue, tagNames, githubPRUrl, githubBranch }) => {
         try {
@@ -3030,14 +3691,14 @@ function buildDiscoveryTools(connection) {
 }
 
 // src/tools/code-review-tools.ts
-import { z as z6 } from "zod";
+import { z as z9 } from "zod";
 function buildCodeReviewTools(connection) {
   return [
     defineTool(
       "approve_code_review",
-      "Approve the code review and exit. When to use: the diff passes all review criteria and is ready to merge. When NOT to use: if any substantive issue remains \u2014 call request_code_changes with a structured issues[] list. This tool takes only a summary; it does not accept an issues array (by design \u2014 an approval should have no blocking issues). Returns: confirmation string.",
+      "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: z6.string().describe("Brief summary of what was reviewed and why it looks good")
+        summary: z9.string().describe("Brief summary of what was reviewed and why it looks good")
       },
       async ({ summary }) => {
         const content = `**Code Review: Approved** :white_check_mark:
@@ -3058,17 +3719,17 @@ ${summary}`;
     ),
     defineTool(
       "request_code_changes",
-      "Request changes during code review and exit. When to use: substantive issues were found that must be fixed before merge. Each entry in issues[] is { file: string, line?: number, severity: 'critical' | 'major' | 'minor', description: string }. When NOT to use: for an approval \u2014 use approve_code_review. Returns: confirmation string.",
+      "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: z6.array(
-          z6.object({
-            file: z6.string().describe("File path where the issue was found"),
-            line: z6.number().optional().describe("Line number (if applicable)"),
-            severity: z6.enum(["critical", "major", "minor"]).describe("Issue severity"),
-            description: z6.string().describe("What is wrong and how to fix it")
+        issues: z9.array(
+          z9.object({
+            file: z9.string().describe("File path where the issue was found"),
+            line: z9.number().optional().describe("Line number (if applicable)"),
+            severity: z9.enum(["critical", "major", "minor"]).describe("Issue severity"),
+            description: z9.string().describe("What is wrong and how to fix it")
           })
         ).describe("List of issues found during review"),
-        summary: z6.string().describe("Brief overall summary of the review findings")
+        summary: z9.string().describe("Brief overall summary of the review findings")
       },
       async ({ issues, summary }) => {
         const issueLines = issues.map((issue) => {
@@ -3098,10 +3759,10 @@ ${issueLines}`;
 }
 
 // src/tools/debug-tools.ts
-import { z as z9 } from "zod";
+import { z as z12 } from "zod";
 
 // src/tools/telemetry-tools.ts
-import { z as z7 } from "zod";
+import { z as z10 } from "zod";
 
 // src/debug/telemetry-injector.ts
 var BUFFER_SIZE = 200;
@@ -3494,14 +4155,14 @@ function formatError(error) {
 function buildGetTelemetryTool(manager) {
   return defineTool(
     "debug_get_telemetry",
-    "Query structured telemetry events (HTTP requests, database queries, Socket.IO events, errors) captured from the running dev server. Returns filtered, structured data instead of raw logs.",
+    "Query structured telemetry events (HTTP, DB, Socket.IO, errors) captured from the dev server. Returns filtered structured data instead of raw logs.",
     {
-      type: z7.enum(["http", "db", "socket", "error"]).optional().describe("Filter by event type"),
-      urlPattern: z7.string().optional().describe("Regex pattern to filter HTTP events by URL"),
-      minDuration: z7.number().optional().describe("Minimum duration in ms \u2014 only return events slower than this"),
-      errorOnly: z7.boolean().optional().describe("Only return error events and HTTP 4xx/5xx responses"),
-      since: z7.number().optional().describe("Only return events after this timestamp (ms since epoch)"),
-      limit: z7.number().optional().describe("Max events to return (default: 20, from most recent)")
+      type: z10.enum(["http", "db", "socket", "error"]).optional().describe("Filter by event type"),
+      urlPattern: z10.string().optional().describe("Regex pattern to filter HTTP events by URL"),
+      minDuration: z10.number().optional().describe("Minimum duration in ms \u2014 only return events slower than this"),
+      errorOnly: z10.boolean().optional().describe("Only return error events and HTTP 4xx/5xx responses"),
+      since: z10.number().optional().describe("Only return events after this timestamp (ms since epoch)"),
+      limit: z10.number().optional().describe("Max events to return (default: 20, from most recent)")
     },
     async ({ type, urlPattern, minDuration, errorOnly, since, limit }) => {
       const clientOrErr = requireDebugClient(manager);
@@ -3571,7 +4232,7 @@ function buildTelemetryTools(manager) {
 }
 
 // src/tools/client-debug-tools.ts
-import { z as z8 } from "zod";
+import { z as z11 } from "zod";
 function requirePlaywrightClient(manager) {
   if (!manager.isClientDebugMode()) {
     return "Client debug mode is not active. Use debug_enter_mode with clientSide: true first.";
@@ -3589,13 +4250,13 @@ function buildClientBreakpointTools(manager) {
   return [
     defineTool(
       "debug_set_client_breakpoint",
-      "Set a breakpoint in client-side code running in the headless Chromium browser. V8 resolves source maps automatically, so original .tsx/.ts file paths work. Use this for React components, client utilities, and browser-side code.",
+      "Set a breakpoint in client-side code running in headless Chromium. V8 resolves source maps automatically \u2014 use original .tsx/.ts file paths.",
       {
-        file: z8.string().describe(
+        file: z11.string().describe(
           "Original source file path (e.g., src/components/App.tsx) \u2014 source maps resolve automatically"
         ),
-        line: z8.number().describe("Line number (1-based) in the original source file"),
-        condition: z8.string().optional().describe("JavaScript condition expression \u2014 breakpoint only triggers when truthy")
+        line: z11.number().describe("Line number (1-based) in the original source file"),
+        condition: z11.string().optional().describe("JavaScript condition expression \u2014 breakpoint only triggers when truthy")
       },
       async ({ file, line, condition }) => {
         const clientOrErr = requirePlaywrightClient(manager);
@@ -3617,7 +4278,7 @@ Breakpoint ID: ${breakpointId}${sourceMapNote}`
       "debug_remove_client_breakpoint",
       "Remove a previously set client-side breakpoint by its ID.",
       {
-        breakpointId: z8.string().describe("The breakpoint ID returned by debug_set_client_breakpoint")
+        breakpointId: z11.string().describe("The breakpoint ID returned by debug_set_client_breakpoint")
       },
       async ({ breakpointId }) => {
         const clientOrErr = requirePlaywrightClient(manager);
@@ -3652,7 +4313,7 @@ function buildClientInspectionTools(manager) {
   return [
     defineTool(
       "debug_inspect_client_paused",
-      "When the client-side (browser) debugger is paused at a breakpoint, returns the call stack and local variables from the paused frame. When to use: after a client breakpoint hits, to see what is in scope in the browser. When NOT to use: for server pauses \u2014 use debug_inspect_paused. Returns: JSON with side='client', reason, hitBreakpoints, callStack, and localVariables. If the debugger paused between turns and has since resumed, queued breakpoint hits are returned instead.",
+      "When the client (browser) debugger is paused, returns call stack and local variables. For server pauses use debug_inspect_paused. Queued hits returned if already resumed.",
       {},
       async () => {
         const clientOrErr = requirePlaywrightClient(manager);
@@ -3695,10 +4356,10 @@ ${JSON.stringify(queuedHits, null, 2)}`
     ),
     defineTool(
       "debug_evaluate_client",
-      "Evaluate a JavaScript expression in the browser context. When paused at a client breakpoint, runs in the paused scope (use frameIndex to pick a frame); otherwise runs in the page's global scope with access to DOM, window, and React internals. Side effects are real \u2014 navigations, DOM mutations, and function calls execute. Prefer read-only expressions unless you specifically want to mutate page state. Returns: `(type) value`.",
+      "Evaluate a JavaScript expression in the browser context. When paused, runs in the paused frame's scope; otherwise the page's global scope. Side effects execute \u2014 prefer read-only.",
       {
-        expression: z8.string().describe("JavaScript expression to evaluate in the browser context"),
-        frameIndex: z8.number().optional().describe("Call stack frame index (0 = top frame). Defaults to the top frame.")
+        expression: z11.string().describe("JavaScript expression to evaluate in the browser context"),
+        frameIndex: z11.number().optional().describe("Call stack frame index (0 = top frame). Defaults to the top frame.")
       },
       async ({ expression, frameIndex }) => {
         const clientOrErr = requirePlaywrightClient(manager);
@@ -3769,9 +4430,9 @@ function buildClientInteractionTools(manager) {
     ),
     defineTool(
       "debug_navigate_client",
-      "Navigate the headless browser to a URL. When to use: reproducing a specific flow or visiting a different page. Waits for `domcontentloaded` before returning (Playwright's default ~30s navigation timeout applies). Returns: confirmation string with the resolved current URL.",
+      "Navigate the headless browser to a URL. Waits for domcontentloaded (Playwright's default ~30s timeout applies).",
       {
-        url: z8.string().describe("URL to navigate to (e.g., http://localhost:3000/dashboard)")
+        url: z11.string().describe("URL to navigate to (e.g., http://localhost:3000/dashboard)")
       },
       async ({ url }) => {
         const clientOrErr = requirePlaywrightClient(manager);
@@ -3786,9 +4447,9 @@ function buildClientInteractionTools(manager) {
     ),
     defineTool(
       "debug_click_client",
-      "Click an element in the headless browser by CSS selector. When to use: reproducing bugs by interacting with the UI programmatically. Playwright auto-waits for the element to be visible, stable, and enabled before clicking, up to a 10s timeout \u2014 a miss throws and is reported in the failure message. Returns: confirmation string.",
+      "Click an element in the headless browser by CSS selector. Playwright auto-waits for visibility/stability/enabled up to 10s \u2014 a miss throws with a failure message.",
       {
-        selector: z8.string().describe(
+        selector: z11.string().describe(
           "CSS selector of the element to click (e.g., 'button.submit', '#login-form input[type=submit]')"
         )
       },
@@ -3810,8 +4471,8 @@ function buildClientConsoleTool(manager) {
     "debug_get_client_console",
     "Get console messages captured from the headless browser. Includes console.log, warn, error, etc.",
     {
-      level: z8.string().optional().describe("Filter by console level: log, warn, error, info, debug"),
-      limit: z8.number().optional().describe("Maximum number of recent messages to return (default: all)")
+      level: z11.string().optional().describe("Filter by console level: log, warn, error, info, debug"),
+      limit: z11.number().optional().describe("Maximum number of recent messages to return (default: all)")
     },
     // oxlint-disable-next-line require-await
     async ({ level, limit }) => {
@@ -3838,8 +4499,8 @@ function buildClientNetworkTool(manager) {
     "debug_get_client_network",
     "Get network requests captured from the headless browser. Shows URLs, methods, status codes, and timing.",
     {
-      filter: z8.string().optional().describe("Regex pattern to filter requests by URL"),
-      limit: z8.number().optional().describe("Maximum number of recent requests to return (default: all)")
+      filter: z11.string().optional().describe("Regex pattern to filter requests by URL"),
+      limit: z11.number().optional().describe("Maximum number of recent requests to return (default: all)")
     },
     // oxlint-disable-next-line require-await
     async ({ filter, limit }) => {
@@ -3867,7 +4528,7 @@ function buildClientErrorsTool(manager) {
     "debug_get_client_errors",
     "Get uncaught errors captured from the headless browser. Includes error messages and source-mapped stack traces.",
     {
-      limit: z8.number().optional().describe("Maximum number of recent errors to return (default: all)")
+      limit: z11.number().optional().describe("Maximum number of recent errors to return (default: all)")
     },
     // oxlint-disable-next-line require-await
     async ({ limit }) => {
@@ -3959,14 +4620,14 @@ function buildDebugLifecycleTools(manager) {
   return [
     defineTool(
       "debug_enter_mode",
-      "Activate debug mode. When to use: at the start of a debug session before setting breakpoints or probes. Restarts the dev server with Node.js --inspect for server-side CDP, and/or launches a headless Chromium via Playwright for client-side. Default: if neither serverSide nor clientSide is passed, server-side only is activated. Pass clientSide=true for frontend debugging (previewUrl required), or set both for full-stack. Returns: activation status string listing active modes, an echoed hypothesis if given, and a warning if source maps are missing.",
+      "Activate debug mode. Default: server-only (Node --inspect via CDP). Set clientSide=true (previewUrl required) or both flags for full-stack (adds headless Chromium via Playwright).",
       {
-        hypothesis: z9.string().optional().describe("Your hypothesis about the bug \u2014 helps track debugging intent"),
-        serverSide: z9.boolean().optional().describe(
+        hypothesis: z12.string().optional().describe("Your hypothesis about the bug \u2014 helps track debugging intent"),
+        serverSide: z12.boolean().optional().describe(
           "Enable server-side Node.js debugging (default: true if clientSide is not set)"
         ),
-        clientSide: z9.boolean().optional().describe("Enable client-side browser debugging via headless Chromium + Playwright"),
-        previewUrl: z9.string().optional().describe(
+        clientSide: z12.boolean().optional().describe("Enable client-side browser debugging via headless Chromium + Playwright"),
+        previewUrl: z12.string().optional().describe(
           "Preview URL for client-side debugging (e.g., http://localhost:3000). Required when clientSide is true."
         )
       },
@@ -4002,9 +4663,9 @@ function buildBreakpointTools(manager) {
       "debug_set_breakpoint",
       "Set a breakpoint at the specified file and line number. Optionally provide a condition expression that must evaluate to true for the breakpoint to pause execution.",
       {
-        file: z9.string().describe("Absolute or relative file path to set the breakpoint in"),
-        line: z9.number().describe("Line number (1-based) to set the breakpoint on"),
-        condition: z9.string().optional().describe("JavaScript condition expression \u2014 breakpoint only triggers when truthy")
+        file: z12.string().describe("Absolute or relative file path to set the breakpoint in"),
+        line: z12.number().describe("Line number (1-based) to set the breakpoint on"),
+        condition: z12.string().optional().describe("JavaScript condition expression \u2014 breakpoint only triggers when truthy")
       },
       async ({ file, line, condition }) => {
         const clientOrErr = requireDebugClient2(manager);
@@ -4026,7 +4687,7 @@ Breakpoint ID: ${breakpointId}`
       "debug_remove_breakpoint",
       "Remove a previously set breakpoint by its ID.",
       {
-        breakpointId: z9.string().describe("The breakpoint ID returned by debug_set_breakpoint")
+        breakpointId: z12.string().describe("The breakpoint ID returned by debug_set_breakpoint")
       },
       async ({ breakpointId }) => {
         const clientOrErr = requireDebugClient2(manager);
@@ -4105,10 +4766,10 @@ ${JSON.stringify(queuedHits, null, 2)}`
     ),
     defineTool(
       "debug_evaluate",
-      "Evaluate a JavaScript expression server-side in the Node process. When paused at a breakpoint the expression runs in that frame's scope (use frameIndex to pick a different frame); otherwise it runs in the global scope. Side effects are real \u2014 assignments, function calls, and I/O all execute. Prefer read-only expressions unless you specifically want to mutate state. Returns: `(type) value`.",
+      "Evaluate a JavaScript expression server-side in the Node process. When paused, runs in the frame's scope (frameIndex selects frame). Side effects execute \u2014 prefer read-only.",
       {
-        expression: z9.string().describe("The JavaScript expression to evaluate"),
-        frameIndex: z9.number().optional().describe("Call stack frame index (0 = top frame). Defaults to the top frame.")
+        expression: z12.string().describe("The JavaScript expression to evaluate"),
+        frameIndex: z12.number().optional().describe("Call stack frame index (0 = top frame). Defaults to the top frame.")
       },
       async ({ expression, frameIndex }) => {
         const clientOrErr = requireDebugClient2(manager);
@@ -4134,14 +4795,14 @@ function buildProbeManagementTools(manager) {
   return [
     defineTool(
       "debug_add_probe",
-      "Add a debug probe at a specific code location. Captures expression values each time the line executes \u2014 without pausing or modifying source files. Like console.log but better: structured, no diff pollution, auto-cleaned on debug exit.",
+      "Add a debug probe at a code location. Captures expression values each time the line executes, without pausing or modifying source. Auto-cleaned on debug exit.",
       {
-        file: z9.string().describe("File path to probe"),
-        line: z9.number().describe("Line number (1-based) to probe"),
-        expressions: z9.array(z9.string()).describe(
+        file: z12.string().describe("File path to probe"),
+        line: z12.number().describe("Line number (1-based) to probe"),
+        expressions: z12.array(z12.string()).describe(
           'JavaScript expressions to capture when the line executes (e.g., ["req.params.id", "user.role"])'
         ),
-        label: z9.string().optional().describe("Optional label for this probe (defaults to file:line)")
+        label: z12.string().optional().describe("Optional label for this probe (defaults to file:line)")
       },
       async ({ file, line, expressions, label }) => {
         const clientOrErr = requireDebugClient2(manager);
@@ -4166,7 +4827,7 @@ Trigger the code path, then use debug_get_probe_results to see captured values.`
       "debug_remove_probe",
       "Remove a previously set debug probe by its ID.",
       {
-        probeId: z9.string().describe("The probe ID returned by debug_add_probe")
+        probeId: z12.string().describe("The probe ID returned by debug_add_probe")
       },
       async ({ probeId }) => {
         const clientOrErr = requireDebugClient2(manager);
@@ -4204,11 +4865,11 @@ function buildProbeResultTools(manager) {
   return [
     defineTool(
       "debug_get_probe_results",
-      "Fetch captured probe hit data. When to use: after triggering the code path for a probe set by debug_add_probe. Filtering: pass label to filter directly, or probeId to look up and filter by that probe's label; if both are passed, label wins and probeId is ignored. Returns: grouped text with per-probe hit count, timestamps, and captured expression values.",
+      "Fetch captured probe hit data. Filter by label (wins) or probeId. Returns grouped text with per-probe hit count, timestamps, and captured expression values.",
       {
-        probeId: z9.string().optional().describe("Filter results by probe ID (resolves to its label)"),
-        label: z9.string().optional().describe("Filter results by probe label"),
-        limit: z9.number().optional().describe("Maximum number of recent hits to return (default: all)")
+        probeId: z12.string().optional().describe("Filter results by probe ID (resolves to its label)"),
+        label: z12.string().optional().describe("Filter results by probe label"),
+        limit: z12.number().optional().describe("Maximum number of recent hits to return (default: all)")
       },
       async ({ probeId, label, limit }) => {
         const clientOrErr = requireDebugClient2(manager);
@@ -4802,7 +5463,7 @@ async function processEvents(events, context, host) {
 // src/execution/task-property-utils.ts
 function collectMissingProps(taskProps) {
   const missing = [];
-  if (!taskProps.plan?.trim()) missing.push("plan (save via update_task)");
+  if (!taskProps.plan?.trim()) missing.push("plan (save via update_task_plan)");
   if (!taskProps.storyPointId) missing.push("story points (use update_task_properties)");
   if (!taskProps.title || taskProps.title === "Untitled")
     missing.push("title (use update_task_properties)");
@@ -4811,7 +5472,31 @@ function collectMissingProps(taskProps) {
 
 // src/execution/tool-access.ts
 var PM_PLAN_FILE_TOOLS = /* @__PURE__ */ new Set(["Write", "Edit", "MultiEdit"]);
-var DESTRUCTIVE_CMD_PATTERN = /git\s+push\s+--force(?!\s*-with-lease)|git\s+reset\s+--hard|rm\s+-rf\s+\//;
+var DESTRUCTIVE_PATTERNS = [
+  {
+    name: "git push --force (without --force-with-lease)",
+    re: /git\s+push\s+(?:-f\b|--force(?!-with-lease))/
+  },
+  { name: "git push --delete", re: /git\s+push\s+(?:-d\b|--delete\b)/ },
+  { name: "git reset --hard", re: /git\s+reset\s+--hard\b/ },
+  {
+    name: "rm -rf /",
+    re: /rm\s+(?:-[a-zA-Z]*r[a-zA-Z]*f|-[a-zA-Z]*f[a-zA-Z]*r|--recursive\s+--force)\s+\/(?!\S)/
+  },
+  { name: "sudo rm", re: /\bsudo\s+rm\b/ },
+  { name: "chmod world-writable", re: /\bchmod\s+(?:-R\s+)?[0-7]*7{2,3}\b/ },
+  { name: "dd to device", re: /\bdd\s+.*\bof=\/dev\// },
+  { name: "redirect to block device", re: />\s*\/dev\/(?:sd[a-z]|nvme\d|xvd[a-z])/ },
+  { name: "mkfs filesystem creation", re: /\bmkfs(?:\.|\s)/ },
+  { name: "shutdown/poweroff/halt/reboot", re: /\b(?:shutdown|poweroff|halt|reboot)\b/ },
+  { name: "fork bomb", re: /:\(\)\s*\{\s*:\|\s*:&\s*\}\s*;\s*:/ }
+];
+function matchesDestructive(cmd) {
+  for (const { name, re } of DESTRUCTIVE_PATTERNS) {
+    if (re.test(cmd)) return name;
+  }
+  return null;
+}
 function isPlanFile(input) {
   const filePath = String(input.file_path ?? input.path ?? "");
   return filePath.includes(".claude/plans/");
@@ -4831,10 +5516,11 @@ function handleDiscoveryToolAccess(toolName, input) {
 function handleBuildingToolAccess(toolName, input) {
   if (toolName === "Bash") {
     const cmd = String(input.command ?? "");
-    if (DESTRUCTIVE_CMD_PATTERN.test(cmd)) {
+    const matched = matchesDestructive(cmd);
+    if (matched) {
       return {
         behavior: "deny",
-        message: "Destructive operation blocked. Use safer alternatives."
+        message: `Destructive operation blocked (${matched}). Use safer alternatives.`
       };
     }
   }
@@ -4849,13 +5535,32 @@ function handleAutoToolAccess(toolName, input, hasExitedPlanMode, isParentTask)
   }
   return { behavior: "allow", updatedInput: input };
 }
+function enforceMissingProps(host, input, missingProps) {
+  if (missingProps.length === 0) return null;
+  if (input.bypassValidation !== true) {
+    return {
+      behavior: "deny",
+      message: [
+        "Cannot exit plan mode. Required task properties are missing:",
+        ...missingProps.map((p) => `- ${p}`),
+        "",
+        "Fill these in using MCP tools (e.g. update_task_plan, update_task_properties), then call ExitPlanMode again.",
+        "",
+        "If you have a deliberate reason to proceed without them, you must explicitly bypass validation by calling ExitPlanMode with `bypassValidation: true` as a tool argument. Do not bypass unless the team has asked you to \u2014 it will be surfaced in chat."
+      ].join("\n")
+    };
+  }
+  host.connection.postChatMessage(
+    `\u26A0\uFE0F [BYPASS] ExitPlanMode forced through with \`bypassValidation: true\` despite missing required properties: ${missingProps.join(", ")}. Please backfill these.`
+  );
+  return null;
+}
 async function handleExitPlanMode(host, input) {
   if (host.hasExitedPlanMode) {
     return { behavior: "allow", updatedInput: input };
   }
-  host.exitPlanAttempts++;
   try {
-    host.syncPlanFile();
+    await host.syncPlanFile();
     const taskProps = await host.connection.getTaskProperties();
     const missingProps = collectMissingProps(taskProps);
     if (host.isParentTask) {
@@ -4875,30 +5580,22 @@ async function handleExitPlanMode(host, input) {
       } catch {
       }
     }
-    if (missingProps.length > 0) {
-      if (host.exitPlanAttempts <= 1) {
-        return {
-          behavior: "deny",
-          message: [
-            "Cannot exit plan mode yet. Required task properties are missing:",
-            ...missingProps.map((p) => `- ${p}`),
-            "",
-            "Fill these in using MCP tools, then try ExitPlanMode again."
-          ].join("\n")
-        };
-      }
-      host.connection.postChatMessage(
-        `\u26A0\uFE0F ExitPlanMode allowed with missing properties: ${missingProps.join(", ")}. Consider backfilling these later.`
-      );
-    }
+    const gate = enforceMissingProps(host, input, missingProps);
+    if (gate) return gate;
     if (host.agentMode === "discovery") {
       host.hasExitedPlanMode = true;
       host.discoveryCompleted = true;
-      host.requestStop();
-      void host.connection.triggerIdentification();
-      host.connection.postChatMessage(
-        "Plan complete. Running identification \u2014 icon and agent assignment will be set automatically."
+      try {
+        await host.connection.triggerIdentification();
+      } catch (triggerErr) {
+        host.connection.postChatMessage(
+          `Identification trigger encountered an issue (${triggerErr instanceof Error ? triggerErr.message : "unknown error"}). Icon and agent assignment may use fallbacks.`
+        );
+      }
+      await host.connection.postChatMessageAwait(
+        "Planning complete \u2014 awaiting team approval. Icon and agent assignment will be set automatically."
       );
+      host.requestStop();
       return { behavior: "allow", updatedInput: input };
     }
     try {
@@ -5017,6 +5714,65 @@ function buildCanUseTool(host) {
   };
 }
 
+// src/execution/redactor.ts
+var REDACTED = "<redacted>";
+var BEARER_RE = /\b(Bearer\s+)[A-Za-z0-9_\-.]{20,}/g;
+var VENDOR_KEY_RE = /\b(?:sk-[a-zA-Z0-9_-]{20,}|ghp_[A-Za-z0-9]{36}|github_pat_[A-Za-z0-9_]{22,}|xoxb-[A-Za-z0-9-]+|xai-[A-Za-z0-9-]{20,})\b/g;
+var AWS_ACCESS_KEY_RE = /\bAKIA[0-9A-Z]{16}\b/g;
+var JWT_RE = /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g;
+var ENV_SECRET_RE = /^(\s*(?:export\s+)?([A-Z][A-Z0-9_]*(?:TOKEN|SECRET|KEY|PASSWORD|PASS|CREDENTIAL|CREDENTIALS)[A-Z0-9_]*)\s*=\s*)['"]?([^\s'"]+)['"]?/gm;
+var COOKIE_HEADER_RE = /(Cookie:\s*)[^\r\n]+/gi;
+var BASIC_AUTH_URL_RE = /(https?:\/\/)([^:@\s/]+):([^@\s]+)@/g;
+var AWS_SECRET_LINE_RE = /^.*(?:secret|aws_secret).*$/gim;
+var AWS_SECRET_VALUE_RE = /\b([A-Za-z0-9/+=]{40})\b/g;
+var SYSTEM_REMINDER_RE = /<system-reminder>[\s\S]*?<\/system-reminder>/gi;
+function redact(input) {
+  if (!input) return { output: input, redacted: 0 };
+  let count = 0;
+  let output = input;
+  output = output.replace(SYSTEM_REMINDER_RE, () => {
+    count++;
+    return "<!-- stripped injection -->";
+  });
+  output = output.replace(BEARER_RE, (_match, prefix) => {
+    count++;
+    return `${prefix}${REDACTED}`;
+  });
+  output = output.replace(VENDOR_KEY_RE, () => {
+    count++;
+    return REDACTED;
+  });
+  output = output.replace(AWS_ACCESS_KEY_RE, () => {
+    count++;
+    return REDACTED;
+  });
+  output = output.replace(JWT_RE, () => {
+    count++;
+    return REDACTED;
+  });
+  output = output.replace(
+    AWS_SECRET_LINE_RE,
+    (line) => line.replace(AWS_SECRET_VALUE_RE, (match) => {
+      if (/^[a-f0-9]+$/i.test(match)) return match;
+      count++;
+      return REDACTED;
+    })
+  );
+  output = output.replace(ENV_SECRET_RE, (_match, prefix, _key, _value) => {
+    count++;
+    return `${prefix}${REDACTED}`;
+  });
+  output = output.replace(COOKIE_HEADER_RE, (_match, prefix) => {
+    count++;
+    return `${prefix}${REDACTED}`;
+  });
+  output = output.replace(BASIC_AUTH_URL_RE, (_match, scheme, user) => {
+    count++;
+    return `${scheme}${user}:${REDACTED}@`;
+  });
+  return { output, redacted: count };
+}
+
 // src/execution/query-executor.ts
 var logger2 = createServiceLogger("QueryExecutor");
 var IMAGE_ERROR_PATTERN2 = /Could not process image/i;
@@ -5029,12 +5785,15 @@ function buildHooks(host) {
           async (input) => {
             if (host.isStopped()) return await Promise.resolve({ continue: false });
             if (input.hook_event_name === "PostToolUse") {
-              const output = typeof input.tool_response === "string" ? input.tool_response.slice(0, 500) : JSON.stringify(input.tool_response).slice(0, 500);
+              const raw = typeof input.tool_response === "string" ? input.tool_response : JSON.stringify(input.tool_response);
+              const { output: redacted, redacted: redactedCount } = redact(raw);
+              const output = redacted.slice(0, 500);
               host.connection.sendEvent({
                 type: "tool_result",
                 tool: input.tool_name,
                 output,
-                isError: false
+                isError: false,
+                ...redactedCount > 0 ? { redactedCount } : {}
               });
               host.pendingToolOutputs.push({ tool: input.tool_name, output });
               if (input.tool_name === "mcp__conveyor__create_pull_request") {
@@ -5229,7 +5988,7 @@ async function runSdkQuery(host, context, followUpContent) {
     }
   }
   if (needsPlanSync) {
-    host.syncPlanFile();
+    await host.syncPlanFile();
   }
 }
 async function buildRetryQuery(host, context, options, lastErrorWasImage) {
@@ -5401,6 +6160,22 @@ async function runWithRetry(initialQuery, context, host, options) {
 var CostTracker = class {
   cumulativeCostUsd = 0;
   modelUsage = /* @__PURE__ */ new Map();
+  seeded = false;
+  /**
+   * Rehydrate cumulative spend from the server so `maxBudgetUsd` enforcement
+   * accounts for costs incurred by prior agent runs on the same task. Must be
+   * called before any `addQueryCost` / `addModelUsage` — re-seeding after
+   * costs have accumulated would clobber in-process totals.
+   */
+  seed(totalCostUsd, modelUsage) {
+    if (this.seeded) return;
+    if (this.cumulativeCostUsd > 0 || this.modelUsage.size > 0) return;
+    this.cumulativeCostUsd = totalCostUsd;
+    for (const entry of modelUsage) {
+      this.modelUsage.set(entry.model, { ...entry });
+    }
+    this.seeded = true;
+  }
   /** Add cost from a completed query and return the running total */
   addQueryCost(queryCostUsd) {
     this.cumulativeCostUsd += queryCostUsd;
@@ -5591,6 +6366,10 @@ var QueryBridge = class {
   resume() {
     this._stopped = false;
   }
+  /** Rehydrate CostTracker from server-side cumulative spend on agent boot. */
+  seedCostTracker(totalCostUsd, modelUsage) {
+    this.costTracker.seed(totalCostUsd, modelUsage);
+  }
   /**
    * Execute a Claude SDK query.
    * Without followUpContent: runs initial mode execution (build/plan).
@@ -5646,7 +6425,6 @@ var QueryBridge = class {
       set hasExitedPlanMode(val) {
         bridge.mode.hasExitedPlanMode = val;
       },
-      exitPlanAttempts: 0,
       get pendingModeRestart() {
         return bridge.mode.pendingModeRestart;
       },
@@ -5703,6 +6481,7 @@ import { fileURLToPath } from "url";
 function mapChatHistory(messages) {
   if (!messages) return [];
   return messages.map((m) => ({
+    id: m.id,
     role: m.role ?? "user",
     content: m.content ?? "",
     userId: m.userId,
@@ -5856,6 +6635,7 @@ var SessionRunner = class _SessionRunner {
       });
     }
     this.queryBridge = this.createQueryBridge();
+    await this.seedCostTrackerFromServer();
     this.logInitialization();
     const staleMessageCount = this.pendingMessages.length;
     const didExecuteInitialQuery = await this.executeInitialMode();
@@ -6130,6 +6910,7 @@ var SessionRunner = class _SessionRunner {
       projectDescription: ctx.projectDescription ?? null,
       githubPRUrl: ctx.githubPRUrl,
       claudeSessionId: ctx.claudeSessionId ?? null,
+      lastSeenMessageId: ctx.lastSeenMessageId ?? null,
       isParentTask: !!ctx.parentTaskId,
       storyPoints: ctx.storyPoints ?? void 0,
       projectAgents: ctx.projectAgents ?? void 0,
@@ -6217,6 +6998,36 @@ var SessionRunner = class _SessionRunner {
       }
     });
   }
+  /**
+   * Rehydrate CostTracker from server. Caps at 3s so a slow API call never
+   * blocks agent startup — on timeout/error we fall through with a $0 tracker
+   * (the existing behavior before this rehydration path was added).
+   */
+  async seedCostTrackerFromServer() {
+    if (!this.queryBridge) return;
+    const TIMEOUT_MS = 3e3;
+    try {
+      const timeout = new Promise((resolve2) => {
+        setTimeout(() => resolve2(null), TIMEOUT_MS);
+      });
+      const fetched = await Promise.race([this.connection.getCumulativeSpending(), timeout]);
+      if (fetched) {
+        this.queryBridge.seedCostTracker(fetched.totalCostUsd, fetched.modelUsage);
+        process.stderr.write(
+          `[conveyor-agent] CostTracker seeded: $${fetched.totalCostUsd.toFixed(4)} across ${fetched.modelUsage.length} model(s)
+`
+        );
+      } else {
+        process.stderr.write(
+          "[conveyor-agent] CostTracker seed timed out after 3s \u2014 starting at $0\n"
+        );
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      process.stderr.write(`[conveyor-agent] CostTracker seed failed: ${msg} \u2014 starting at $0
+`);
+    }
+  }
   /** Proactively refresh the GitHub token before the 1-hour expiry. */
   async refreshGithubToken() {
     try {
@@ -6695,7 +7506,7 @@ function runStartCommand(cmd, cwd, onOutput) {
 }
 
 // src/tools/project-tools.ts
-import { z as z10 } from "zod";
+import { z as z13 } from "zod";
 function buildTaskListTools(connection) {
   const projectId = connection.projectId;
   return [
@@ -6703,9 +7514,9 @@ function buildTaskListTools(connection) {
       "list_tasks",
       "List tasks in the project. Optionally filter by status or assignee.",
       {
-        status: z10.string().optional().describe("Filter by task status"),
-        assigneeId: z10.string().optional().describe("Filter by assigned user ID"),
-        limit: z10.number().optional().describe("Max number of tasks to return (default 50)")
+        status: z13.string().optional().describe("Filter by task status"),
+        assigneeId: z13.string().optional().describe("Filter by assigned user ID"),
+        limit: z13.number().optional().describe("Max number of tasks to return (default 50)")
       },
       async (params) => {
         try {
@@ -6722,7 +7533,7 @@ function buildTaskListTools(connection) {
     defineTool(
       "get_project_task",
       "Get detailed information about a task in this project (chat messages, child tasks, session). Project-runner scope.",
-      { task_id: z10.string().describe("The task ID to look up") },
+      { task_id: z13.string().describe("The task ID to look up") },
       async ({ task_id }) => {
         try {
           const task = await connection.call("getProjectTask", { projectId, taskId: task_id });
@@ -6739,10 +7550,10 @@ function buildTaskListTools(connection) {
       "search_tasks",
       "Search tasks by tags, text query, or status filters.",
       {
-        tagNames: z10.array(z10.string()).optional().describe("Filter by tag names"),
-        searchQuery: z10.string().optional().describe("Text search in title/description"),
-        statusFilters: z10.array(z10.string()).optional().describe("Filter by statuses"),
-        limit: z10.number().optional().describe("Max results (default 20)")
+        tagNames: z13.array(z13.string()).optional().describe("Filter by tag names"),
+        searchQuery: z13.string().optional().describe("Text search in title/description"),
+        statusFilters: z13.array(z13.string()).optional().describe("Filter by statuses"),
+        limit: z13.number().optional().describe("Max results (default 20)")
       },
       async (params) => {
         try {
@@ -6802,10 +7613,10 @@ function buildMutationTools2(connection) {
       "create_task",
       "Create a new task in the project.",
       {
-        title: z10.string().describe("Task title"),
-        description: z10.string().optional().describe("Task description"),
-        plan: z10.string().optional().describe("Implementation plan in markdown"),
-        status: z10.string().optional().describe("Initial status (default: Planning)")
+        title: z13.string().describe("Task title"),
+        description: z13.string().optional().describe("Task description"),
+        plan: z13.string().optional().describe("Implementation plan in markdown"),
+        status: z13.string().optional().describe("Initial status (default: Planning)")
       },
       async (params) => {
         try {
@@ -6822,12 +7633,12 @@ function buildMutationTools2(connection) {
       "update_project_task",
       "Update an existing task's title, description, plan, status, or assignee. Project-runner scope.",
       {
-        task_id: z10.string().describe("The task ID to update"),
-        title: z10.string().optional().describe("New title"),
-        description: z10.string().optional().describe("New description"),
-        plan: z10.string().optional().describe("New plan in markdown"),
-        status: z10.string().optional().describe("New status"),
-        assignedUserId: z10.string().nullable().optional().describe("Assign to user ID, or null to unassign")
+        task_id: z13.string().describe("The task ID to update"),
+        title: z13.string().optional().describe("New title"),
+        description: z13.string().optional().describe("New description"),
+        plan: z13.string().optional().describe("New plan in markdown"),
+        status: z13.string().optional().describe("New status"),
+        assignedUserId: z13.string().nullable().optional().describe("Assign to user ID, or null to unassign")
       },
       async ({ task_id, ...fields }) => {
         try {
@@ -7724,7 +8535,7 @@ var ProjectRunner = class {
   async handleAuditTasks(request) {
     this.connection.emitStatus("busy");
     try {
-      const { handleTaskAudit } = await import("./task-audit-handler-TJOM5OJS.js");
+      const { handleTaskAudit } = await import("./task-audit-handler-4675WBIX.js");
       await handleTaskAudit(request, this.connection, this.projectDir);
     } catch (error) {
       const msg = parseErrorMessage(error);
@@ -7825,4 +8636,4 @@ export {
   loadForwardPorts,
   loadConveyorConfig
 };
-//# sourceMappingURL=chunk-WDGSLU5S.js.map
+//# sourceMappingURL=chunk-TP5WEBQE.js.map