@rallycry/conveyor-agent 7.3.7 → 7.3.9

package/dist/{chunk-PC43BKMM.js → chunk-Y6IHF32X.js}

@@ -40,6 +40,8 @@ var AgentConnection = class _AgentConnection {
   softStopCallback = null;
   modeChangeCallback = null;
   apiKeyUpdateCallback = null;
+  pullBranchCallback = null;
+  earlyPullBranches = [];
   constructor(config) {
     this.config = config;
   }
@@ -130,6 +132,10 @@ var AgentConnection = class _AgentConnection {
       this.socket.on("agentRunner:updateApiKey", (data) => {
         if (this.apiKeyUpdateCallback) this.apiKeyUpdateCallback(data);
       });
+      this.socket.on("session:pullBranch", (data) => {
+        if (this.pullBranchCallback) this.pullBranchCallback(data);
+        else this.earlyPullBranches.push(data);
+      });
       this.socket.on("connect", () => {
         process.stderr.write("[conveyor-agent] Socket connected\n");
         if (!settled) {
@@ -251,6 +257,11 @@ var AgentConnection = class _AgentConnection {
   onApiKeyUpdate(callback) {
     this.apiKeyUpdateCallback = callback;
   }
+  onPullBranch(callback) {
+    this.pullBranchCallback = callback;
+    for (const data of this.earlyPullBranches) callback(data);
+    this.earlyPullBranches = [];
+  }
   // ── Convenience methods (thin wrappers around call / emit) ─────────
   async emitStatus(status) {
     this.lastEmittedStatus = status;
@@ -1384,6 +1395,8 @@ var DeleteSubtaskResponseSchema = z.object({
 });
 var RegisterProjectAgentResponseSchema = z.object({
   registered: z.boolean(),
+  /** ProjectCodespaceSession id — used by the runner to filter targeted chat messages. */
+  sessionId: z.string(),
   agentName: z.string(),
   agentInstructions: z.string(),
   model: z.string(),
@@ -1456,7 +1469,8 @@ var CreateProjectTaskRequestSchema = z2.object({
   title: z2.string().min(1),
   description: z2.string().optional(),
   plan: z2.string().optional(),
-  status: z2.string().optional()
+  status: z2.string().optional(),
+  requestingUserId: z2.string().optional()
 });
 var UpdateProjectTaskRequestSchema = z2.object({
   projectId: z2.string(),
@@ -1465,7 +1479,8 @@ var UpdateProjectTaskRequestSchema = z2.object({
   description: z2.string().optional(),
   plan: z2.string().optional(),
   status: z2.string().optional(),
-  assignedUserId: z2.string().nullish()
+  assignedUserId: z2.string().nullish(),
+  requestingUserId: z2.string().optional()
 });
 var ReportProjectAgentEventRequestSchema = z2.object({
   projectId: z2.string(),
@@ -1528,7 +1543,8 @@ var GetProjectCliHistoryRequestSchema = z2.object({
 var PostToProjectTaskChatRequestSchema = z2.object({
   projectId: z2.string(),
   taskId: z2.string(),
-  content: z2.string()
+  content: z2.string(),
+  requestingUserId: z2.string().optional()
 });
 var GetProjectTaskCliRequestSchema = z2.object({
   projectId: z2.string(),
@@ -1538,15 +1554,71 @@ var GetProjectTaskCliRequestSchema = z2.object({
 });
 var StartProjectBuildRequestSchema = z2.object({
   projectId: z2.string(),
-  taskId: z2.string()
+  taskId: z2.string(),
+  requestingUserId: z2.string().optional()
 });
 var StopProjectBuildRequestSchema = z2.object({
   projectId: z2.string(),
-  taskId: z2.string()
+  taskId: z2.string(),
+  requestingUserId: z2.string().optional()
 });
 var ApproveProjectMergePRRequestSchema = z2.object({
   projectId: z2.string(),
-  childTaskId: z2.string()
+  childTaskId: z2.string(),
+  requestingUserId: z2.string().optional()
+});
+var ListProjectSubtasksRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string()
+});
+var CreateProjectSubtaskRequestSchema = z2.object({
+  projectId: z2.string(),
+  parentTaskId: z2.string(),
+  title: z2.string().min(1),
+  description: z2.string().optional(),
+  plan: z2.string().optional(),
+  ordinal: z2.number().int().nonnegative().optional(),
+  storyPointValue: z2.number().int().positive().optional(),
+  requestingUserId: z2.string().optional()
+});
+var UpdateProjectSubtaskRequestSchema = z2.object({
+  projectId: z2.string(),
+  subtaskId: z2.string(),
+  title: z2.string().optional(),
+  description: z2.string().optional(),
+  plan: z2.string().optional(),
+  status: z2.string().optional(),
+  ordinal: z2.number().int().nonnegative().optional(),
+  storyPointValue: z2.number().int().positive().optional(),
+  requestingUserId: z2.string().optional()
+});
+var DeleteProjectSubtaskRequestSchema = z2.object({
+  projectId: z2.string(),
+  subtaskId: z2.string(),
+  requestingUserId: z2.string().optional()
+});
+var GetProjectTaskChatRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  limit: z2.number().int().positive().optional().default(20)
+});
+var AddProjectTaskDependencyRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  dependsOnSlugOrId: z2.string(),
+  requestingUserId: z2.string().optional()
+});
+var RemoveProjectTaskDependencyRequestSchema = z2.object({
+  projectId: z2.string(),
+  taskId: z2.string(),
+  dependsOnSlugOrId: z2.string(),
+  requestingUserId: z2.string().optional()
+});
+var VoteProjectSuggestionRequestSchema = z2.object({
+  projectId: z2.string(),
+  suggestionId: z2.string(),
+  value: z2.union([z2.literal(1), z2.literal(-1)]),
+  requestingUserId: z2.string().optional()
 });
 var StartTaskAuditRequestSchema = z3.object({
   projectId: z3.string(),
@@ -1566,7 +1638,8 @@ var CreateProjectSuggestionRequestSchema = z3.object({
   projectId: z3.string(),
   title: z3.string().min(1),
   description: z3.string().optional(),
-  tagNames: z3.array(z3.string()).optional()
+  tagNames: z3.array(z3.string()).optional(),
+  requestingUserId: z3.string().optional()
 });
 var ReportTaskAuditBatchCompleteRequestSchema = z3.object({
   projectId: z3.string(),
@@ -6572,6 +6645,48 @@ function readAgentVersion() {
   return null;
 }
 
+// src/runner/parent-pull-handler.ts
+import { execSync as execSync2 } from "child_process";
+function handlePullBranch(workDir, branch) {
+  if (!branch) return;
+  const current = getCurrentBranch(workDir);
+  if (current !== branch) {
+    process.stderr.write(
+      `[conveyor-agent] pull_branch ignored \u2014 current branch ${current ?? "(detached)"} != ${branch}
+`
+    );
+    return;
+  }
+  if (hasUncommittedChanges(workDir)) {
+    process.stderr.write(
+      `[conveyor-agent] pull_branch ignored \u2014 uncommitted changes on ${branch}
+`
+    );
+    return;
+  }
+  try {
+    execSync2(`git fetch origin ${branch}`, { cwd: workDir, stdio: "ignore", timeout: 6e4 });
+  } catch {
+    process.stderr.write(`[conveyor-agent] pull_branch: fetch failed for ${branch}
+`);
+    return;
+  }
+  try {
+    execSync2(`git pull --ff-only origin ${branch}`, {
+      cwd: workDir,
+      stdio: "ignore",
+      timeout: 6e4
+    });
+    process.stderr.write(`[conveyor-agent] pull_branch: pulled origin/${branch}
+`);
+  } catch {
+    process.stderr.write(
+      `[conveyor-agent] pull_branch: ff-only pull failed for ${branch} (likely diverged)
+`
+    );
+  }
+}
+
 // src/runner/session-runner.ts
 var SessionRunner = class _SessionRunner {
   connection;
@@ -7134,6 +7249,9 @@ var SessionRunner = class _SessionRunner {
         delete process.env.CLAUDE_CODE_OAUTH_TOKEN;
       }
     });
+    this.connection.onPullBranch(({ branch }) => {
+      handlePullBranch(this.config.workspaceDir, branch);
+    });
   }
   /**
    * Rehydrate CostTracker from server. Caps at 3s so a slow API call never
@@ -7417,7 +7535,7 @@ var ProjectConnection = class {
 };
 
 // src/runner/commit-watcher.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 var logger5 = createServiceLogger("CommitWatcher");
 var CommitWatcher = class {
   constructor(config, callbacks) {
@@ -7451,7 +7569,7 @@ var CommitWatcher = class {
     this.isSyncing = false;
   }
   getLocalHeadSha() {
-    return execSync2("git rev-parse HEAD", {
+    return execSync3("git rev-parse HEAD", {
       cwd: this.config.projectDir,
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim();
@@ -7459,12 +7577,12 @@ var CommitWatcher = class {
   poll() {
     if (!this.branch || this.isSyncing) return;
     try {
-      execSync2(`git fetch origin ${this.branch} --quiet`, {
+      execSync3(`git fetch origin ${this.branch} --quiet`, {
         cwd: this.config.projectDir,
         stdio: "ignore",
         timeout: 3e4
       });
-      const remoteSha = execSync2(`git rev-parse origin/${this.branch}`, {
+      const remoteSha = execSync3(`git rev-parse origin/${this.branch}`, {
         cwd: this.config.projectDir,
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().trim();
@@ -7485,12 +7603,12 @@ var CommitWatcher = class {
     let latestMessage = "";
     let latestAuthor = "";
     try {
-      const countOutput = execSync2(`git rev-list --count ${previousSha}..origin/${this.branch}`, {
+      const countOutput = execSync3(`git rev-list --count ${previousSha}..origin/${this.branch}`, {
         cwd: this.config.projectDir,
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().trim();
       commitCount = parseInt(countOutput, 10) || 1;
-      const logOutput = execSync2(`git log -1 --format="%s|||%an" origin/${this.branch}`, {
+      const logOutput = execSync3(`git log -1 --format="%s|||%an" origin/${this.branch}`, {
         cwd: this.config.projectDir,
         stdio: ["ignore", "pipe", "ignore"]
       }).toString().trim();
@@ -7525,7 +7643,7 @@ var CommitWatcher = class {
 };
 
 // src/runner/worktree.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 import { existsSync as existsSync2 } from "fs";
 import { join as join4 } from "path";
 var WORKTREE_DIR = ".worktrees";
@@ -7540,7 +7658,7 @@ function ensureWorktree(projectDir, taskId, branch) {
         return worktreePath;
       }
       try {
-        execSync3(`git checkout --detach origin/${branch}`, {
+        execSync4(`git checkout --detach origin/${branch}`, {
           cwd: worktreePath,
           stdio: "ignore"
         });
@@ -7550,7 +7668,7 @@ function ensureWorktree(projectDir, taskId, branch) {
     return worktreePath;
   }
   const ref = branch ? `origin/${branch}` : "HEAD";
-  execSync3(`git worktree add --detach "${worktreePath}" ${ref}`, {
+  execSync4(`git worktree add --detach "${worktreePath}" ${ref}`, {
     cwd: projectDir,
     stdio: "ignore"
   });
@@ -7558,7 +7676,7 @@ function ensureWorktree(projectDir, taskId, branch) {
 }
 function detachWorktreeBranch(projectDir, branch) {
   try {
-    const output = execSync3("git worktree list --porcelain", {
+    const output = execSync4("git worktree list --porcelain", {
       cwd: projectDir,
       encoding: "utf-8"
     });
@@ -7571,7 +7689,7 @@ function detachWorktreeBranch(projectDir, branch) {
       const worktreePath = worktreeLine.replace("worktree ", "");
       if (!worktreePath.includes(`/${WORKTREE_DIR}/`)) continue;
       try {
-        execSync3("git checkout --detach", { cwd: worktreePath, stdio: "ignore" });
+        execSync4("git checkout --detach", { cwd: worktreePath, stdio: "ignore" });
       } catch {
       }
     }
@@ -7582,7 +7700,7 @@ function removeWorktree(projectDir, taskId) {
   const worktreePath = join4(projectDir, WORKTREE_DIR, taskId);
   if (!existsSync2(worktreePath)) return;
   try {
-    execSync3(`git worktree remove "${worktreePath}" --force`, {
+    execSync4(`git worktree remove "${worktreePath}" --force`, {
       cwd: projectDir,
       stdio: "ignore"
     });
@@ -7591,7 +7709,7 @@ function removeWorktree(projectDir, taskId) {
 }
 
 // src/setup/commands.ts
-import { spawn, execSync as execSync4 } from "child_process";
+import { spawn, execSync as execSync5 } from "child_process";
 function runSetupCommand(cmd, cwd, onOutput) {
   return new Promise((resolve2, reject) => {
     const child = spawn("sh", ["-c", cmd], {
@@ -7620,7 +7738,7 @@ function runSetupCommand(cmd, cwd, onOutput) {
 var AUTH_TOKEN_TIMEOUT_MS = 3e4;
 function runAuthTokenCommand(cmd, userEmail, cwd) {
   try {
-    const output = execSync4(`${cmd} ${JSON.stringify(userEmail)}`, {
+    const output = execSync5(`${cmd} ${JSON.stringify(userEmail)}`, {
       cwd,
       timeout: AUTH_TOKEN_TIMEOUT_MS,
       stdio: ["ignore", "pipe", "ignore"],
@@ -7650,158 +7768,645 @@ function runStartCommand(cmd, cwd, onOutput) {
 }
 
 // src/tools/project-tools.ts
+import { z as z14 } from "zod";
+
+// src/tools/project-action-tools.ts
 import { z as z13 } from "zod";
-function buildTaskListTools(connection) {
+var SP_DESCRIPTION3 = "Story point value (1=Common, 2=Magic, 3=Rare, 5=Unique)";
+function withRequestingUser(payload, getRequestingUserId) {
+  const requestingUserId = getRequestingUserId();
+  return requestingUserId ? { ...payload, requestingUserId } : payload;
+}
+function buildCreateTaskTool(connection, getRequestingUserId) {
   const projectId = connection.projectId;
-  return [
-    defineTool(
-      "list_tasks",
-      "List tasks in the project. Optionally filter by status or assignee.",
-      {
-        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 {
-          const tasks = await connection.call("listProjectTasks", { projectId, ...params });
-          return textResult(JSON.stringify(tasks, null, 2));
-        } catch (error) {
-          return textResult(
-            `Failed to list tasks: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      },
-      { annotations: { readOnlyHint: true } }
-    ),
-    defineTool(
-      "get_project_task",
-      "Get detailed information about a task in this project (chat messages, child tasks, session). Project-runner scope.",
-      { 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 });
-          return textResult(JSON.stringify(task, null, 2));
-        } catch (error) {
+  return defineTool(
+    "create_task",
+    "Create a new task in the project.",
+    {
+      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 {
+        const result = await connection.call(
+          "createProjectTask",
+          withRequestingUser({ projectId, ...params }, getRequestingUserId)
+        );
+        return textResult(`Task created: ${result.slug} (ID: ${result.id})`);
+      } catch (error) {
+        return textResult(`Failed to create task: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildUpdateProjectTaskTool(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "update_project_task",
+    "Update an existing task's title, description, plan, status, or assignee. Project-runner scope.",
+    {
+      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 {
+        await connection.call(
+          "updateProjectTask",
+          withRequestingUser({ projectId, taskId: task_id, ...fields }, getRequestingUserId)
+        );
+        return textResult("Task updated successfully.");
+      } catch (error) {
+        return textResult(`Failed to update task: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildUpdateTaskPlanTool(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "update_task_plan",
+    "Save a plan or description to a task. Convenience wrapper around update_project_task for the common Plan-mode case.",
+    {
+      task_id: z13.string().describe("The task ID to update"),
+      plan: z13.string().optional().describe("The task plan in markdown"),
+      description: z13.string().optional().describe("Updated task description")
+    },
+    async ({ task_id, plan, description }) => {
+      try {
+        await connection.call(
+          "updateProjectTask",
+          withRequestingUser(
+            {
+              projectId,
+              taskId: task_id,
+              ...plan !== void 0 && { plan },
+              ...description !== void 0 && { description }
+            },
+            getRequestingUserId
+          )
+        );
+        return textResult("Task updated successfully.");
+      } catch (error) {
+        return textResult(`Failed to update task: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildForceUpdateStatusTool(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "force_update_task_status",
+    "EMERGENCY ONLY: force-override a task's Kanban status. Use when an automatic transition failed and the task is wedged. Normal flow transitions status automatically.",
+    {
+      task_id: z13.string().describe("The task ID to update"),
+      status: z13.enum(["Planning", "Open", "InProgress", "ReviewPR", "ReviewDev", "ReviewLive", "Complete"]).describe("The new status for the task")
+    },
+    async ({ task_id, status }) => {
+      try {
+        await connection.call(
+          "updateProjectTask",
+          withRequestingUser({ projectId, taskId: task_id, status }, getRequestingUserId)
+        );
+        return textResult(`Task status updated to ${status}.`);
+      } catch (error) {
+        return textResult(`Failed to update status: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildCreateSubtaskTool2(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "create_subtask",
+    "Create a subtask under a parent task in this project. Use for breaking parent tasks into smaller pieces during planning.",
+    {
+      parent_task_id: z13.string().describe("The parent task ID"),
+      title: z13.string().describe("Subtask title"),
+      description: z13.string().optional().describe("Brief description"),
+      plan: z13.string().optional().describe("Implementation plan in markdown"),
+      ordinal: z13.number().optional().describe("Step/order number (0-based)"),
+      storyPointValue: z13.number().optional().describe(SP_DESCRIPTION3)
+    },
+    async ({ parent_task_id, title, description, plan, ordinal, storyPointValue }) => {
+      try {
+        const result = await connection.call(
+          "createProjectSubtask",
+          withRequestingUser(
+            {
+              projectId,
+              parentTaskId: parent_task_id,
+              title,
+              ...description !== void 0 && { description },
+              ...plan !== void 0 && { plan },
+              ...ordinal !== void 0 && { ordinal },
+              ...storyPointValue !== void 0 && { storyPointValue }
+            },
+            getRequestingUserId
+          )
+        );
+        return textResult(`Subtask created: ${result.slug} (ID: ${result.id})`);
+      } catch (error) {
+        return textResult(`Failed to create subtask: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildUpdateSubtaskTool2(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "update_subtask",
+    "Update an existing subtask's fields (title, description, plan, status, ordinal, storyPointValue).",
+    {
+      subtask_id: z13.string().describe("The subtask ID to update"),
+      title: z13.string().optional(),
+      description: z13.string().optional(),
+      plan: z13.string().optional(),
+      status: z13.string().optional(),
+      ordinal: z13.number().optional(),
+      storyPointValue: z13.number().optional().describe(SP_DESCRIPTION3)
+    },
+    async ({ subtask_id, ...fields }) => {
+      try {
+        await connection.call(
+          "updateProjectSubtask",
+          withRequestingUser({ projectId, subtaskId: subtask_id, ...fields }, getRequestingUserId)
+        );
+        return textResult("Subtask updated.");
+      } catch (error) {
+        return textResult(`Failed: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildDeleteSubtaskTool2(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "delete_subtask",
+    "Delete a subtask by id. Use when a subtask was created in error or is no longer needed.",
+    { subtask_id: z13.string().describe("The subtask ID to delete") },
+    async ({ subtask_id }) => {
+      try {
+        await connection.call(
+          "deleteProjectSubtask",
+          withRequestingUser({ projectId, subtaskId: subtask_id }, getRequestingUserId)
+        );
+        return textResult("Subtask deleted.");
+      } catch (error) {
+        return textResult(`Failed: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildStartTaskTool(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "start_task",
+    "Start a cloud build (codespace) for a task. Preconditions: task has a story point value and an agent assigned.",
+    { task_id: z13.string().describe("The task ID to start a build for") },
+    async ({ task_id }) => {
+      try {
+        const result = await connection.call(
+          "startProjectBuild",
+          withRequestingUser({ projectId, taskId: task_id }, getRequestingUserId)
+        );
+        return textResult(
+          `Cloud build started for task ${result.taskId} (status: ${result.status})`
+        );
+      } catch (error) {
+        return textResult(`Failed to start task: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildStopTaskTool(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "stop_task",
+    "Send a stop signal to a running task's cloud build. Not a force-kill \u2014 the agent may take a moment to wind down.",
+    { task_id: z13.string().describe("The task ID whose build should be stopped") },
+    async ({ task_id }) => {
+      try {
+        await connection.call(
+          "stopProjectBuild",
+          withRequestingUser({ projectId, taskId: task_id }, getRequestingUserId)
+        );
+        return textResult(`Stop signal sent for task ${task_id}.`);
+      } catch (error) {
+        return textResult(`Failed to stop task: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildMergePRTool(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "merge_pr",
+    "Approve and merge a task's PR. Preconditions: task in ReviewPR with an open PR. Returns { merged }: false means automerge queued \u2014 wait for status to flip to ReviewDev.",
+    { task_id: z13.string().describe("The task ID whose PR should be approved and merged") },
+    async ({ task_id }) => {
+      try {
+        const result = await connection.call(
+          "approveProjectMergePR",
+          withRequestingUser({ projectId, childTaskId: task_id }, getRequestingUserId)
+        );
+        if (result.merged) {
           return textResult(
-            `Failed to get task: ${error instanceof Error ? error.message : "Unknown error"}`
+            `PR #${result.prNumber} approved and merged for task ${result.childTaskId}.`
           );
         }
-      },
-      { annotations: { readOnlyHint: true } }
-    ),
-    defineTool(
-      "search_tasks",
-      "Search tasks by tags, text query, or status filters.",
-      {
-        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 {
-          const tasks = await connection.call("searchProjectTasks", { projectId, ...params });
-          return textResult(JSON.stringify(tasks, null, 2));
-        } catch (error) {
+        return textResult(
+          `PR #${result.prNumber} merge queued for task ${result.childTaskId}. The PR will auto-merge when checks pass \u2014 wait for status to flip to ReviewDev.`
+        );
+      } catch (error) {
+        return textResult(`Failed to merge PR: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildCreateSuggestionTool2(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "create_suggestion",
+    "Suggest a feature, improvement, rule, or idea for the project. Duplicates are deduped and your upvote is recorded.",
+    {
+      title: z13.string().describe("Short title for the suggestion"),
+      description: z13.string().optional().describe("1-2 sentence description of what should change and why."),
+      tag_names: z13.array(z13.string()).optional().describe("Tag names to categorize the suggestion")
+    },
+    async ({ title, description, tag_names }) => {
+      try {
+        const result = await connection.call(
+          "createProjectSuggestion",
+          withRequestingUser(
+            {
+              projectId,
+              title,
+              ...description !== void 0 && { description },
+              ...tag_names !== void 0 && { tagNames: tag_names }
+            },
+            getRequestingUserId
+          )
+        );
+        if (result.merged) {
           return textResult(
-            `Failed to search tasks: ${error instanceof Error ? error.message : "Unknown error"}`
+            `Your suggestion was merged into an existing one (ID: ${result.mergedIntoId ?? result.id}). Your upvote has been recorded.`
           );
         }
-      },
-      { annotations: { readOnlyHint: true } }
-    )
-  ];
+        return textResult(`Suggestion created (ID: ${result.id}).`);
+      } catch (error) {
+        return textResult(`Failed to create suggestion: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildVoteSuggestionTool2(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "vote_suggestion",
+    "Vote +1 or -1 on a project suggestion.",
+    {
+      suggestion_id: z13.string().describe("The suggestion ID to vote on"),
+      value: z13.number().refine((v) => v === 1 || v === -1, { message: "Value must be 1 or -1" }).describe("+1 to upvote, -1 to downvote")
+    },
+    async ({ suggestion_id, value }) => {
+      try {
+        const result = await connection.call(
+          "voteProjectSuggestion",
+          withRequestingUser(
+            {
+              projectId,
+              suggestionId: suggestion_id,
+              value
+            },
+            getRequestingUserId
+          )
+        );
+        return textResult(`Vote recorded. Current score: ${result.score}`);
+      } catch (error) {
+        return textResult(`Failed to vote: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildAddDependencyTool2(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "add_dependency",
+    "Add a blocking dependency \u2014 a task cannot start until the named task is merged to dev.",
+    {
+      task_id: z13.string().describe("The task that should be blocked"),
+      depends_on_slug_or_id: z13.string().describe("Slug or ID of the task this task depends on")
+    },
+    async ({ task_id, depends_on_slug_or_id }) => {
+      try {
+        await connection.call(
+          "addProjectTaskDependency",
+          withRequestingUser(
+            {
+              projectId,
+              taskId: task_id,
+              dependsOnSlugOrId: depends_on_slug_or_id
+            },
+            getRequestingUserId
+          )
+        );
+        return textResult(
+          `Dependency added: task ${task_id} now depends on "${depends_on_slug_or_id}"`
+        );
+      } catch (error) {
+        return textResult(`Failed to add dependency: ${errorMessage(error)}`);
+      }
+    }
+  );
 }
-function buildProjectInfoTools(connection) {
+function buildRemoveDependencyTool2(connection, getRequestingUserId) {
   const projectId = connection.projectId;
+  return defineTool(
+    "remove_dependency",
+    "Remove a previously added dependency from a task.",
+    {
+      task_id: z13.string().describe("The task to update"),
+      depends_on_slug_or_id: z13.string().describe("Slug or ID of the task to remove as dependency")
+    },
+    async ({ task_id, depends_on_slug_or_id }) => {
+      try {
+        await connection.call(
+          "removeProjectTaskDependency",
+          withRequestingUser(
+            {
+              projectId,
+              taskId: task_id,
+              dependsOnSlugOrId: depends_on_slug_or_id
+            },
+            getRequestingUserId
+          )
+        );
+        return textResult("Dependency removed");
+      } catch (error) {
+        return textResult(`Failed to remove dependency: ${errorMessage(error)}`);
+      }
+    }
+  );
+}
+function buildProjectActionTools(connection, getRequestingUserId = () => void 0) {
   return [
-    defineTool(
-      "list_tags",
-      "List all tags available in the project.",
-      {},
-      async () => {
-        try {
-          const tags = await connection.call("listProjectTags", { projectId });
-          return textResult(JSON.stringify(tags, null, 2));
-        } catch (error) {
-          return textResult(
-            `Failed to list tags: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      },
-      { annotations: { readOnlyHint: true } }
-    ),
-    defineTool(
-      "get_project_summary",
-      "Get a summary of the project including task counts by status and active builds.",
-      {},
-      async () => {
-        try {
-          const summary = await connection.call("getProjectSummary", { projectId });
-          return textResult(JSON.stringify(summary, null, 2));
-        } catch (error) {
-          return textResult(
-            `Failed to get project summary: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
-      },
-      { annotations: { readOnlyHint: true } }
-    )
+    buildCreateTaskTool(connection, getRequestingUserId),
+    buildUpdateProjectTaskTool(connection, getRequestingUserId),
+    buildUpdateTaskPlanTool(connection, getRequestingUserId),
+    buildForceUpdateStatusTool(connection, getRequestingUserId),
+    buildCreateSubtaskTool2(connection, getRequestingUserId),
+    buildUpdateSubtaskTool2(connection, getRequestingUserId),
+    buildDeleteSubtaskTool2(connection, getRequestingUserId),
+    buildStartTaskTool(connection, getRequestingUserId),
+    buildStopTaskTool(connection, getRequestingUserId),
+    buildMergePRTool(connection, getRequestingUserId),
+    buildCreateSuggestionTool2(connection, getRequestingUserId),
+    buildVoteSuggestionTool2(connection, getRequestingUserId),
+    buildAddDependencyTool2(connection, getRequestingUserId),
+    buildRemoveDependencyTool2(connection, getRequestingUserId)
   ];
 }
-function buildMutationTools2(connection) {
+
+// src/tools/project-tools.ts
+function errorMessage(error) {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+function buildListTasksTool(connection) {
   const projectId = connection.projectId;
-  return [
-    defineTool(
-      "create_task",
-      "Create a new task in the project.",
-      {
-        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 {
-          const result = await connection.call("createProjectTask", { projectId, ...params });
-          return textResult(`Task created: ${result.slug} (ID: ${result.id})`);
-        } catch (error) {
-          return textResult(
-            `Failed to create task: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
-        }
+  return defineTool(
+    "list_tasks",
+    "List tasks in the project. Optionally filter by status or assignee.",
+    {
+      status: z14.string().optional().describe("Filter by task status"),
+      assigneeId: z14.string().optional().describe("Filter by assigned user ID"),
+      limit: z14.number().optional().describe("Max number of tasks to return (default 50)")
+    },
+    async (params) => {
+      try {
+        const tasks = await connection.call("listProjectTasks", { projectId, ...params });
+        return textResult(JSON.stringify(tasks, null, 2));
+      } catch (error) {
+        return textResult(`Failed to list tasks: ${errorMessage(error)}`);
       }
-    ),
-    defineTool(
-      "update_project_task",
-      "Update an existing task's title, description, plan, status, or assignee. Project-runner scope.",
-      {
-        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 {
-          await connection.call("updateProjectTask", { projectId, taskId: task_id, ...fields });
-          return textResult("Task updated successfully.");
-        } catch (error) {
-          return textResult(
-            `Failed to update task: ${error instanceof Error ? error.message : "Unknown error"}`
-          );
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildGetProjectTaskTool(connection) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "get_project_task",
+    "Get detailed information about a task in this project (chat messages, child tasks, session). Project-runner scope.",
+    { task_id: z14.string().describe("The task ID to look up") },
+    async ({ task_id }) => {
+      try {
+        const task = await connection.call("getProjectTask", { projectId, taskId: task_id });
+        return textResult(JSON.stringify(task, null, 2));
+      } catch (error) {
+        return textResult(`Failed to get task: ${errorMessage(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildSearchTasksTool(connection) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "search_tasks",
+    "Search tasks by tags, text query, or status filters.",
+    {
+      tagNames: z14.array(z14.string()).optional().describe("Filter by tag names"),
+      searchQuery: z14.string().optional().describe("Text search in title/description"),
+      statusFilters: z14.array(z14.string()).optional().describe("Filter by statuses"),
+      limit: z14.number().optional().describe("Max results (default 20)")
+    },
+    async (params) => {
+      try {
+        const tasks = await connection.call("searchProjectTasks", { projectId, ...params });
+        return textResult(JSON.stringify(tasks, null, 2));
+      } catch (error) {
+        return textResult(`Failed to search tasks: ${errorMessage(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildListSubtasksTool2(connection) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "list_subtasks",
+    "List the immediate child tasks under a parent task. Use to coordinate subtask work \u2014 see status, ordering, and PR state.",
+    { task_id: z14.string().describe("Parent task ID") },
+    async ({ task_id }) => {
+      try {
+        const subtasks = await connection.call("listProjectSubtasks", {
+          projectId,
+          taskId: task_id
+        });
+        return textResult(JSON.stringify(subtasks, null, 2));
+      } catch (error) {
+        return textResult(`Failed to list subtasks: ${errorMessage(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildListTagsTool(connection) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "list_tags",
+    "List all tags available in the project.",
+    {},
+    async () => {
+      try {
+        const tags = await connection.call("listProjectTags", { projectId });
+        return textResult(JSON.stringify(tags, null, 2));
+      } catch (error) {
+        return textResult(`Failed to list tags: ${errorMessage(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildGetProjectSummaryTool(connection) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "get_project_summary",
+    "Get a summary of the project including task counts by status and active builds.",
+    {},
+    async () => {
+      try {
+        const summary = await connection.call("getProjectSummary", { projectId });
+        return textResult(JSON.stringify(summary, null, 2));
+      } catch (error) {
+        return textResult(`Failed to get project summary: ${errorMessage(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildPostToChatTool2(connection, getRequestingUserId) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "post_to_chat",
+    "Post an out-of-band message into a chat. Omit task_id to post into the project chat; pass task_id to post into a specific task's chat. Normal replies already appear in chat automatically.",
+    {
+      message: z14.string().describe("The message content to post"),
+      task_id: z14.string().optional().describe("Task ID to post into a specific task's chat. Omit for the project chat.")
+    },
+    async ({ message, task_id }) => {
+      try {
+        const requestingUserId = getRequestingUserId();
+        if (task_id) {
+          await connection.call("postToProjectTaskChat", {
+            projectId,
+            taskId: task_id,
+            content: message,
+            ...requestingUserId ? { requestingUserId } : {}
+          });
+          return textResult(JSON.stringify({ posted: true, target: `task:${task_id}` }));
         }
+        await connection.call("postProjectAgentMessage", { projectId, content: message });
+        return textResult(JSON.stringify({ posted: true, target: "project" }));
+      } catch (error) {
+        return textResult(`Failed to post message: ${errorMessage(error)}`);
       }
-    )
-  ];
+    }
+  );
+}
+function buildReadChatHistoryTool(connection) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "read_chat_history",
+    "Read recent messages from a chat. Omit chat_id to read the project chat; pass a chat_id to read a specific chat.",
+    {
+      chat_id: z14.string().optional().describe("Chat ID to read. Omit for the project chat."),
+      limit: z14.number().optional().describe("Number of recent messages to fetch (default 50)")
+    },
+    async ({ chat_id, limit }) => {
+      try {
+        const messages = await connection.call("getProjectChatHistory", {
+          projectId,
+          ...chat_id !== void 0 && { chatId: chat_id },
+          ...limit !== void 0 && { limit }
+        });
+        return textResult(JSON.stringify(messages, null, 2));
+      } catch (error) {
+        return textResult(`Failed to read chat history: ${errorMessage(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
 }
-function buildProjectTools(connection) {
+function buildReadTaskChatTool2(connection) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "read_task_chat",
+    "Read recent human/user chat messages for a specific task in this project. For agent execution logs use get_task_logs.",
+    {
+      task_id: z14.string().describe("The task ID whose chat to read"),
+      limit: z14.number().optional().describe("Number of recent messages to fetch (default 20)")
+    },
+    async ({ task_id, limit }) => {
+      try {
+        const messages = await connection.call("getProjectTaskChat", {
+          projectId,
+          taskId: task_id,
+          ...limit !== void 0 && { limit }
+        });
+        return textResult(JSON.stringify(messages, null, 2));
+      } catch (error) {
+        return textResult(`Failed to read task chat: ${errorMessage(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildGetTaskLogsTool(connection) {
+  const projectId = connection.projectId;
+  return defineTool(
+    "get_task_logs",
+    "Read CLI execution logs for a task \u2014 agent reasoning, tool calls, and setup/dev-server output. For human chat use read_task_chat.",
+    {
+      task_id: z14.string().describe("Task ID to read logs from"),
+      source: z14.enum(["agent", "application"]).optional().describe("Filter by log source. Omit for all logs."),
+      limit: z14.number().optional().describe("Max number of log entries to return (default 50, max 500).")
+    },
+    async ({ task_id, source, limit }) => {
+      try {
+        const logs = await connection.call("getProjectTaskCli", {
+          projectId,
+          taskId: task_id,
+          ...source !== void 0 && { source },
+          ...limit !== void 0 && { limit }
+        });
+        return textResult(JSON.stringify(logs, null, 2));
+      } catch (error) {
+        return textResult(`Failed to fetch task logs: ${errorMessage(error)}`);
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildProjectTools(connection, getRequestingUserId = () => void 0) {
   return [
-    ...buildTaskListTools(connection),
-    ...buildProjectInfoTools(connection),
-    ...buildMutationTools2(connection)
+    buildListTasksTool(connection),
+    buildGetProjectTaskTool(connection),
+    buildSearchTasksTool(connection),
+    buildListSubtasksTool2(connection),
+    buildListTagsTool(connection),
+    buildGetProjectSummaryTool(connection),
+    buildPostToChatTool2(connection, getRequestingUserId),
+    buildReadChatHistoryTool(connection),
+    buildReadTaskChatTool2(connection),
+    buildGetTaskLogsTool(connection),
+    ...buildProjectActionTools(connection, getRequestingUserId)
   ];
 }
 
@@ -7867,13 +8472,13 @@ async function fetchContext(connection, chatId) {
   }
   return { agentCtx, chatHistory };
 }
-function buildChatQueryOptions(agentCtx, projectDir, connection) {
+function buildChatQueryOptions(agentCtx, projectDir, connection, getRequestingUserId) {
   const model = agentCtx?.model || FALLBACK_MODEL;
   const settings = agentCtx?.agentSettings ?? {};
   const harness = createHarness();
   const mcpServer = harness.createMcpServer({
     name: "conveyor",
-    tools: buildProjectTools(connection)
+    tools: buildProjectTools(connection, getRequestingUserId)
   });
   return {
     options: {
@@ -7942,7 +8547,13 @@ function emitResultCost(event, connection) {
 }
 async function runChatQuery(message, connection, projectDir, sessionId) {
   const { agentCtx, chatHistory } = await fetchContext(connection, message.chatId);
-  const { options, harness } = buildChatQueryOptions(agentCtx, projectDir, connection);
+  const requestingUserId = message.userId;
+  const { options, harness } = buildChatQueryOptions(
+    agentCtx,
+    projectDir,
+    connection,
+    () => requestingUserId
+  );
   const prompt = buildPrompt(message, chatHistory);
   connection.emitStatus("busy");
   const events = harness.executeQuery({
@@ -8003,15 +8614,15 @@ function parseErrorMessage(error) {
 
 // src/runner/project-runner-children.ts
 import { fork } from "child_process";
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync8 } from "child_process";
 import * as path from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/runner/project-runner-git.ts
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync7 } from "child_process";
 
 // src/runner/project-runner-sync.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 var logger7 = createServiceLogger("ProjectRunner");
 var START_CMD_KILL_TIMEOUT_MS = 5e3;
 async function executeSetupCommand(projectDir, connection) {
@@ -8108,7 +8719,7 @@ async function handleSyncEnvironment(projectDir, branchSwitchCommand, state, con
 }
 function getChangedFiles(projectDir, previousSha, newSha) {
   try {
-    return execSync5(`git diff --name-only ${previousSha}..${newSha}`, {
+    return execSync6(`git diff --name-only ${previousSha}..${newSha}`, {
       cwd: projectDir,
       stdio: ["ignore", "pipe", "ignore"]
     }).toString().trim().split("\n").filter(Boolean);
@@ -8119,7 +8730,7 @@ function getChangedFiles(projectDir, previousSha, newSha) {
 function runIndividualSyncSteps(projectDir, needsInstall, needsPrisma, stepsRun) {
   if (needsInstall) {
     try {
-      execSync5("bun install", { cwd: projectDir, timeout: 12e4, stdio: "pipe" });
+      execSync6("bun install", { cwd: projectDir, timeout: 12e4, stdio: "pipe" });
       stepsRun.push("install");
     } catch (err) {
       const msg = parseErrorMessage(err);
@@ -8128,8 +8739,8 @@ function runIndividualSyncSteps(projectDir, needsInstall, needsPrisma, stepsRun)
   }
   if (needsPrisma) {
     try {
-      execSync5("bunx prisma generate", { cwd: projectDir, timeout: 6e4, stdio: "pipe" });
-      execSync5("bunx prisma db push --accept-data-loss", {
+      execSync6("bunx prisma generate", { cwd: projectDir, timeout: 6e4, stdio: "pipe" });
+      execSync6("bunx prisma db push --accept-data-loss", {
         cwd: projectDir,
         timeout: 6e4,
         stdio: "pipe"
@@ -8173,7 +8784,7 @@ async function smartSync(projectDir, branchSwitchCommand, state, connection, pre
   }
   await killStartCommand(state);
   try {
-    execSync5(`git pull origin ${branch}`, {
+    execSync6(`git pull origin ${branch}`, {
       cwd: projectDir,
       stdio: "pipe",
       timeout: 6e4
@@ -8209,10 +8820,10 @@ function setupWorkDir(projectDir, assignment) {
       logger8.warn("Uncommitted changes, skipping checkout", { taskId: shortId, branch });
     } else {
       try {
-        execSync6(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
+        execSync7(`git checkout ${branch}`, { cwd: workDir, stdio: "ignore" });
       } catch {
         try {
-          execSync6(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
+          execSync7(`git checkout -b ${branch}`, { cwd: workDir, stdio: "ignore" });
         } catch {
           logger8.warn("Could not checkout branch", { taskId: shortId, branch });
         }
@@ -8231,8 +8842,8 @@ function checkoutWorkspaceBranch(projectDir) {
     return;
   }
   try {
-    execSync6(`git fetch origin ${workspaceBranch}`, { cwd: projectDir, stdio: "pipe" });
-    execSync6(`git checkout ${workspaceBranch}`, { cwd: projectDir, stdio: "pipe" });
+    execSync7(`git fetch origin ${workspaceBranch}`, { cwd: projectDir, stdio: "pipe" });
+    execSync7(`git checkout ${workspaceBranch}`, { cwd: projectDir, stdio: "pipe" });
     logger8.info("Checked out workspace branch", { workspaceBranch });
   } catch {
     logger8.warn("Failed to checkout workspace branch", { workspaceBranch });
@@ -8241,20 +8852,20 @@ function checkoutWorkspaceBranch(projectDir) {
 async function handleSwitchBranch(projectDir, branchSwitchCommand, startCmd, connection, commitWatcher, data, callback) {
   try {
     try {
-      execSync6("git fetch origin", { cwd: projectDir, stdio: "pipe" });
+      execSync7("git fetch origin", { cwd: projectDir, stdio: "pipe" });
     } catch {
       logger8.warn("Git fetch failed during branch switch");
     }
     detachWorktreeBranch(projectDir, data.branch);
     try {
-      execSync6(`git checkout ${data.branch}`, { cwd: projectDir, stdio: "pipe" });
+      execSync7(`git checkout ${data.branch}`, { cwd: projectDir, stdio: "pipe" });
     } catch (err) {
       const msg = parseErrorMessage(err);
       callback({ ok: false, error: `Failed to checkout branch: ${msg}` });
       return;
     }
     try {
-      execSync6(`git pull origin ${data.branch}`, { cwd: projectDir, stdio: "pipe" });
+      execSync7(`git pull origin ${data.branch}`, { cwd: projectDir, stdio: "pipe" });
     } catch {
       logger8.warn("Git pull failed during branch switch");
     }
@@ -8397,7 +9008,7 @@ async function handleAssignment(assignment, activeAgents, projectDir, connection
   }
   try {
     try {
-      execSync7("git fetch origin", { cwd: projectDir, stdio: "ignore" });
+      execSync8("git fetch origin", { cwd: projectDir, stdio: "ignore" });
     } catch {
       logger9.warn("Git fetch failed", { taskId: shortId });
     }
@@ -8458,6 +9069,10 @@ var ProjectRunner = class {
   stopping = false;
   resolveLifecycle = null;
   chatSessionIds = /* @__PURE__ */ new Map();
+  /** ProjectCodespaceSession id assigned at register time. Used to filter
+   *  targeted incoming chat messages so we only react to ones addressed
+   *  to this specific runner. */
+  projectSessionId = null;
   startCmd = { child: null, running: false };
   setupComplete = false;
   branchSwitchCommand;
@@ -8497,6 +9112,7 @@ var ProjectRunner = class {
       projectId: this.connection.projectId,
       capabilities: ["task", "pm", "code-review", "audit"]
     });
+    this.projectSessionId = registration.sessionId;
     this.branchSwitchCommand = registration.branchSwitchCommand ?? process.env.CONVEYOR_BRANCH_SWITCH_COMMAND;
     logger10.info("Registered as project agent", { agentName: registration.agentName });
     try {
@@ -8603,6 +9219,9 @@ var ProjectRunner = class {
     );
     this.connection.onShutdown(() => void this.stop());
     this.connection.onChatMessage((msg) => {
+      if (msg.targetSessionId && this.projectSessionId && msg.targetSessionId !== this.projectSessionId) {
+        return;
+      }
       const chatId = msg.chatId ?? "default";
       const existingSessionId = this.chatSessionIds.get(chatId);
       void handleProjectChatMessage(msg, this.connection, this.projectDir, existingSessionId).then(
@@ -8641,10 +9260,11 @@ var ProjectRunner = class {
   }
   async handleReconnect() {
     try {
-      await this.connection.call("registerProjectAgent", {
+      const registration = await this.connection.call("registerProjectAgent", {
         projectId: this.connection.projectId,
         capabilities: ["task", "pm", "code-review", "audit"]
       });
+      this.projectSessionId = registration.sessionId;
       this.connection.emitStatus(this.activeAgents.size > 0 ? "busy" : "idle");
       logger10.info("Re-registered after reconnect");
     } catch (error) {
@@ -8804,4 +9424,4 @@ export {
   buildSessionPreviewPorts,
   loadConveyorConfig
 };
-//# sourceMappingURL=chunk-PC43BKMM.js.map
+//# sourceMappingURL=chunk-Y6IHF32X.js.map