@rallycry/conveyor-agent 7.3.8 → 7.3.10

package/dist/{chunk-RX7NQCWK.js → chunk-24NCVM4T.js}

@@ -700,6 +700,7 @@ var Lifecycle = class {
   // ── Periodic git flush ────────────────────────────────────────────
   startGitFlush() {
     this.stopGitFlush();
+    if (this.config.gitFlushIntervalMs <= 0) return;
     this.gitFlushTimer = setInterval(() => {
       this.callbacks.onGitFlush();
     }, this.config.gitFlushIntervalMs);
@@ -1395,6 +1396,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(),
@@ -1467,7 +1470,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(),
@@ -1476,7 +1480,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(),
@@ -1539,7 +1544,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(),
@@ -1549,15 +1555,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(),
@@ -1577,7 +1639,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(),
@@ -7706,158 +7769,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 buildProjectInfoTools(connection) {
+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 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 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 buildProjectTools(connection) {
+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)
   ];
 }
 
@@ -7923,13 +8473,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: {
@@ -7998,7 +8548,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({
@@ -8514,6 +9070,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;
@@ -8553,6 +9113,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 {
@@ -8659,6 +9220,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(
@@ -8697,10 +9261,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) {
@@ -8860,4 +9425,4 @@ export {
   buildSessionPreviewPorts,
   loadConveyorConfig
 };
-//# sourceMappingURL=chunk-RX7NQCWK.js.map
+//# sourceMappingURL=chunk-24NCVM4T.js.map