@rallycry/conveyor-agent 6.2.0 → 6.3.0

package/dist/{chunk-RMNWEID4.js → chunk-WBBX5AIX.js}

@@ -161,6 +161,21 @@ function getTaskIncidents(socket, taskId) {
 function requestScaleUp(socket, tier, reason) {
   return emitRpc(requireSocket(socket), "agentRunner:scaleUp", { tier, reason });
 }
+function addDependency(socket, dependsOnSlugOrId) {
+  return emitRpcVoid(requireSocket(socket), "agentRunner:addDependency", { dependsOnSlugOrId });
+}
+function removeDependency(socket, dependsOnSlugOrId) {
+  return emitRpcVoid(requireSocket(socket), "agentRunner:removeDependency", { dependsOnSlugOrId });
+}
+function getDependencies(socket) {
+  return emitRpc(requireSocket(socket), "agentRunner:getDependencies", {});
+}
+function createFollowUpTask(socket, data) {
+  return emitRpc(requireSocket(socket), "agentRunner:createFollowUpTask", data);
+}
+function queryGcpLogs(socket, params) {
+  return emitRpc(requireSocket(socket), "agentRunner:queryGcpLogs", params);
+}
 
 // src/connection/task-connection.ts
 var ConveyorConnection = class _ConveyorConnection {
@@ -464,7 +479,7 @@ var ConveyorConnection = class _ConveyorConnection {
     return triggerIdentification(this.socket);
   }
   async refreshAuthToken() {
-    const codespaceName = process.env.CODESPACE_NAME;
+    const codespaceName = process.env.CODESPACE_NAME || process.env.CLAUDESPACE_NAME;
     const apiUrl = process.env.CONVEYOR_API_URL ?? this.config.conveyorApiUrl;
     if (!codespaceName || !apiUrl) return false;
     try {
@@ -509,10 +524,29 @@ var ConveyorConnection = class _ConveyorConnection {
   requestScaleUp(tier, reason) {
     return requestScaleUp(this.socket, tier, reason);
   }
+  addDependency(dependsOnSlugOrId) {
+    return addDependency(this.socket, dependsOnSlugOrId);
+  }
+  removeDependency(dependsOnSlugOrId) {
+    return removeDependency(this.socket, dependsOnSlugOrId);
+  }
+  getDependencies() {
+    return getDependencies(this.socket);
+  }
+  createFollowUpTask(data) {
+    return createFollowUpTask(this.socket, data);
+  }
+  queryGcpLogs(params) {
+    return queryGcpLogs(this.socket, params);
+  }
   disconnect() {
     this.flushEvents();
-    this.socket?.disconnect();
-    this.socket = null;
+    if (this.socket) {
+      this.socket.io.reconnection(false);
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
   }
 };
 
@@ -805,8 +839,12 @@ var ProjectConnection = class {
     }
   }
   disconnect() {
-    this.socket?.disconnect();
-    this.socket = null;
+    if (this.socket) {
+      this.socket.io.reconnection(false);
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
   }
 };
 
@@ -862,6 +900,82 @@ function getCurrentBranch(cwd) {
     return null;
   }
 }
+function hasUnpushedCommits(cwd) {
+  try {
+    const currentBranch = getCurrentBranch(cwd);
+    if (!currentBranch) return false;
+    try {
+      execSync2(`git rev-parse origin/${currentBranch}`, {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+    } catch {
+      try {
+        execSync2("git rev-parse HEAD", {
+          cwd,
+          stdio: ["ignore", "pipe", "ignore"]
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    const ahead = execSync2(`git rev-list --count HEAD --not origin/${currentBranch}`, {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    return parseInt(ahead, 10) > 0;
+  } catch {
+    return false;
+  }
+}
+function stageAndCommit(cwd, message) {
+  try {
+    execSync2("git add -A", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (!hasUncommittedChanges(cwd)) {
+      return null;
+    }
+    execSync2(`git commit -m "${message}"`, {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const hash = execSync2("git rev-parse HEAD", {
+      cwd,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).toString().trim();
+    return hash;
+  } catch {
+    return null;
+  }
+}
+function pushToOrigin(cwd) {
+  try {
+    const currentBranch = getCurrentBranch(cwd);
+    if (!currentBranch) return false;
+    try {
+      execSync2(`git push origin ${currentBranch}`, {
+        cwd,
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      return true;
+    } catch {
+      try {
+        execSync2(`git push --force-with-lease origin ${currentBranch}`, {
+          cwd,
+          stdio: ["ignore", "pipe", "ignore"]
+        });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  } catch {
+    return false;
+  }
+}
 
 // src/runner/worktree.ts
 var WORKTREE_DIR = ".worktrees";
@@ -1691,11 +1805,11 @@ function buildPackRunnerSystemPrompt(context, config, setupLog) {
   const parts = [
     `You are an autonomous Pack Runner managing child tasks for the "${context.title}" project.`,
     `You are running locally with full access to the repository and task management tools.`,
-    `Your job is to sequentially execute child tasks by firing cloud builds, reviewing their PRs, and merging them.`,
+    `Your job is to execute child tasks by firing cloud builds, reviewing their PRs, and merging them \u2014 respecting dependency chains for parallel execution.`,
     ``,
     `## Child Task Status Lifecycle`,
     `- "Planning" \u2014 Not ready for execution. Skip it (or escalate if blocking).`,
-    `- "Open" \u2014 Ready to execute. Use start_child_cloud_build to fire it.`,
+    `- "Open" \u2014 Ready to execute (if dependencies are met). Use start_child_cloud_build to fire it.`,
     `- "InProgress" \u2014 Currently being worked on by a Task Runner. Wait \u2014 it will move to ReviewPR when done.`,
     `- "ReviewPR" \u2014 Task Runner finished and opened a PR. Review and merge it.`,
     `- "Hold" \u2014 PR exists but is on hold for team review. Do not merge \u2014 skip and move on.`,
@@ -1706,32 +1820,35 @@ function buildPackRunnerSystemPrompt(context, config, setupLog) {
     `Follow this loop each time you are launched or relaunched:`,
     ``,
     `1. Call list_subtasks to see the current state of all child tasks.`,
-    `   The response includes PR info (githubPRNumber, githubPRUrl) and agent assignment (agentId).`,
+    `   The response includes PR info, agent assignment, and **dependency info** (dependencies array + allDependenciesMet flag).`,
     ``,
-    `2. Evaluate each child by status (in ordinal order):`,
-    `   - "ReviewPR": Review and merge its PR with approve_and_merge_pr.`,
-    `     - If merge fails due to pending CI: post a status update to chat, state you are going idle, and the system will relaunch you to try again.`,
-    `     - If merge fails due to failed CI: use get_task_cli(childTaskId) to check what went wrong. Escalate to the team in chat.`,
-    `   - "InProgress": A Task Runner is actively working on this child. Do nothing \u2014 wait for it to finish.`,
-    `   - "Open": This is the next child to execute. Fire it with start_child_cloud_build.`,
-    `     - If it fails because the child is missing story points or an agent: notify the team in chat and go idle.`,
+    `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.`,
+    `   - "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.`,
     `   - "Hold": On hold \u2014 team must review before merge. Skip.`,
     `   - "ReviewDev" / "Complete": Already done. Skip.`,
-    `   - "Planning": Not ready. If this is blocking progress, notify the team.`,
+    `   - "Planning": Not ready. If blocking progress, notify team.`,
+    ``,
+    `3. Fire ALL ready "Open" tasks whose dependencies are met, not just one. Independent tasks can run in parallel.`,
     ``,
-    `3. After merging a PR: run \`git pull origin ${context.baseBranch}\` to get the merged changes before firing the next child.`,
+    `4. After merging a PR: run \`git pull origin ${context.baseBranch}\` then re-check list_subtasks \u2014 previously blocked tasks may now be ready.`,
     ``,
-    `4. After firing a child build: report which task you fired to chat, then explicitly state you are going idle. The system will relaunch you when the child completes or changes status.`,
+    `5. After firing all ready tasks: report which tasks you fired to chat, then state you are going idle.`,
     ``,
-    `5. When ALL children are in "ReviewDev", "Complete", or "Hold" (no "Open", "InProgress", or "ReviewPR" remaining): do a final review, summarize results in chat, and mark this parent task complete with force_update_task_status("Complete").`,
+    `6. When ALL children are in "ReviewDev", "Complete", or "Hold" (no "Open", "InProgress", or "ReviewPR" remaining): do a final review, summarize results in chat, and mark this parent task complete with force_update_task_status("Complete").`,
     ``,
     `## Important Rules`,
-    `- Process children ONE at a time, in ordinal order.`,
-    `- After firing a child build OR when waiting on CI, explicitly state you are going idle. The system will disconnect you and relaunch when there's a status change.`,
+    `- When dependencies are set on children, use them to determine execution order. Fire all ready tasks in parallel.`,
+    `- 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.`,
     `- 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) and agent assignment (agentId) for each child \u2014 use this to verify readiness before firing builds.`,
+    `- 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.`
   ];
   if (context.storyPoints && context.storyPoints.length > 0) {
@@ -1770,11 +1887,12 @@ function buildPackRunnerInstructions(context, scenario) {
     );
   } else if (scenario === "idle_relaunch") {
     parts.push(
-      `You have been relaunched \u2014 a child task likely changed status (completed work, opened a PR, or was merged).`,
+      `You have been relaunched \u2014 a child task likely changed status.`,
       `Call list_subtasks to check the current state of all children.`,
       `Look for children in "ReviewPR" status first \u2014 review and merge their PRs.`,
-      `If a child you previously fired is now in "ReviewDev", it was merged. Pull latest with \`git pull origin ${context.baseBranch}\` and continue to the next "Open" child.`,
-      `If no children need action (all InProgress or waiting), state you are going idle.`
+      `Check if any previously blocked tasks now have allDependenciesMet=true \u2014 fire them.`,
+      `If a child you previously fired is now in "ReviewDev", pull latest with \`git pull origin ${context.baseBranch}\`.`,
+      `If no children need action, state you are going idle.`
     );
   } else {
     const lastAgentIdx = findLastAgentMessageIndex(context.chatHistory);
@@ -2032,7 +2150,7 @@ function buildDiscoveryPrompt(context) {
     `### Finishing Planning`,
     `Once your plan is complete and all required properties are set, call the **ExitPlanMode** tool.`,
     `- Required before ExitPlanMode will succeed: **plan** (via update_task), **story points** (via update_task_properties), **title** (via update_task_properties)`,
-    `- ExitPlanMode validates these properties and moves the task to Open status`,
+    `- ExitPlanMode validates these properties and marks planning as complete`,
     `- It does NOT start building \u2014 the team controls when to switch to Build mode`
   ];
   if (context) parts.push(...buildPropertyInstructions(context));
@@ -2087,13 +2205,13 @@ function buildModePrompt(agentMode, context) {
         parts.push(
           ``,
           `### Resource Management`,
-          `Your pod starts with minimal resources (0.25 CPU / 1 Gi). Before running resource-intensive`,
-          `operations, use the \`scale_up_resources\` tool to request more capacity:`,
-          `- **light** (1 CPU / 4 Gi) \u2014 package installs, basic dev servers, light builds`,
+          `Your pod starts with minimal resources (0.25 CPU / 1 Gi). You MUST call \`scale_up_resources\``,
+          `BEFORE running any of these operations \u2014 they WILL fail or OOM at baseline resources:`,
+          `- **light** (1 CPU / 4 Gi) \u2014 bun/npm/yarn install, pip install, basic dev servers, light builds`,
           `- **standard** (2 CPU / 8 Gi) \u2014 full dev servers, test suites, typecheck, lint`,
           `- **heavy** (4 CPU / 16 Gi) \u2014 E2E/browser automation, large parallel builds`,
-          `Scaling is one-way (up only) and capped by project limits. If you forget to scale,`,
-          `operations may be slow or OOM \u2014 scale up proactively before running builds or tests.`
+          `Scaling is one-way (up only) and capped by project limits.`,
+          `CRITICAL: Always scale to at least "light" before running any package install command.`
         );
       }
       return parts.join("\n");
@@ -2332,7 +2450,7 @@ Your responses are sent directly to the task chat \u2014 the team sees everythin
   );
   if (!isPm || isPmActive) {
     parts.push(
-      `Use the mcp__conveyor__create_pull_request tool to open PRs \u2014 do NOT use gh CLI or shell commands for PR creation.`
+      `Use the mcp__conveyor__create_pull_request tool to open PRs \u2014 it automatically stages, commits, and pushes changes before creating the PR. Do NOT use gh CLI or shell commands for PR creation.`
     );
   }
   if (options?.hasDebugTools) {
@@ -2545,12 +2663,12 @@ function buildFreshInstructions(isPm, isAutoMode, context, agentMode) {
       `Your plan has been approved. Begin implementing it now.`,
       `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
       `Start by reading the relevant source files mentioned in the plan, then write code.`,
-      `When finished, commit and push your changes, then use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI.`,
+      `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI.`,
       `
 CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or go idle without making code changes.`,
       `Your FIRST action must be reading source files from the plan, then immediately writing code.`,
       `Do NOT summarize the plan or say "ready to implement" \u2014 start implementing.`,
-      `When all changes are committed and pushed, use mcp__conveyor__create_pull_request to open a PR.`,
+      `When all changes are ready, use mcp__conveyor__create_pull_request to open a PR.`,
       `If you are genuinely blocked, explain the specific blocker \u2014 do not go idle silently.`
     ];
   }
@@ -2584,14 +2702,14 @@ CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or g
     `Your FIRST action should be reading the relevant source files mentioned in the plan, then writing code. Do NOT run install, build, lint, test, or dev server commands first \u2014 the environment is already set up.`,
     `Work on the git branch "${context.githubBranch}". Stay on this branch for the entire task. Do not checkout or create other branches.`,
     `Your replies are visible to the team in chat \u2014 briefly describe what you're doing when you begin meaningful implementation, and again when the PR is ready.`,
-    `When finished, commit your changes, then run \`git fetch origin ${context.githubBranch}\` and \`git push origin ${context.githubBranch}\` (use --force-with-lease if push fails). Then use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
+    `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`
   ];
   if (isAutoMode) {
     parts.push(
       `
 CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or go idle without making code changes.`,
       `Do NOT summarize the plan or say "ready to implement" \u2014 start implementing immediately.`,
-      `When all changes are committed and pushed, you MUST use mcp__conveyor__create_pull_request to open a PR before finishing.`,
+      `When all changes are ready, you MUST use mcp__conveyor__create_pull_request to open a PR before finishing.`,
       `If you are genuinely blocked, explain the specific blocker \u2014 do not go idle silently.`
     );
   }
@@ -2620,7 +2738,7 @@ New messages since your last run:`,
     ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`),
     `
 Address the requested changes directly. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 go straight to implementing the feedback.`,
-    `Commit and push your updates.`
+    `Implement your updates and open a PR when finished.`
   ];
   if (context.githubPRUrl) {
     parts.push(
@@ -2671,7 +2789,7 @@ function buildInstructions(mode, context, scenario, agentMode, isAuto) {
       );
       if (agentMode === "auto" || agentMode === "building" && isAuto) {
         parts.push(
-          `If work is incomplete, continue implementing the plan. When finished, commit, push, and use mcp__conveyor__create_pull_request to open a PR.`,
+          `If work is incomplete, continue implementing the plan. When finished, use mcp__conveyor__create_pull_request to open a PR.`,
           `Do NOT go idle or wait for instructions \u2014 you are in auto mode.`
         );
       } else {
@@ -2950,20 +3068,56 @@ function buildGetTaskIncidentsTool(connection) {
     { annotations: { readOnlyHint: true } }
   );
 }
-function buildCreatePullRequestTool(connection) {
+function buildCreatePullRequestTool(connection, config) {
   return defineTool(
     "create_pull_request",
-    "Create a GitHub pull request for this task. Use this instead of gh CLI or git commands to create PRs.",
+    "Create a GitHub pull request for this task. Automatically stages uncommitted changes, commits them, and pushes before creating the PR. Use this instead of gh CLI or git commands to create PRs.",
     {
       title: z.string().describe("The PR title"),
       body: z.string().describe("The PR description/body in markdown"),
       branch: z.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: z.string().optional().describe(
+        "The base branch to target for the PR (e.g. 'main', 'develop'). Defaults to the project's configured dev branch."
+      ),
+      commitMessage: z.string().optional().describe(
+        "Commit message for staging uncommitted changes. If not provided, a default message based on the PR title will be used."
       )
     },
-    async ({ title, body, branch }) => {
+    async ({ title, body, branch, baseBranch, commitMessage }) => {
       try {
-        const result = await connection.createPR({ title, body, branch });
+        const cwd = config.workspaceDir;
+        if (hasUncommittedChanges(cwd)) {
+          const message = commitMessage || `${title}
+
+Co-Authored-By: Claude Sonnet 4 <noreply@anthropic.com>`;
+          const commitHash = stageAndCommit(cwd, message);
+          if (commitHash) {
+            connection.sendEvent({
+              type: "message",
+              content: `Auto-committed changes: ${commitHash.slice(0, 7)}`
+            });
+          } else {
+            return textResult(
+              "Failed to stage and commit changes. Please check git status and commit manually before creating PR."
+            );
+          }
+        }
+        if (hasUnpushedCommits(cwd)) {
+          const pushSuccess = pushToOrigin(cwd);
+          if (pushSuccess) {
+            connection.sendEvent({
+              type: "message",
+              content: "Auto-pushed committed changes to origin"
+            });
+          } else {
+            return textResult(
+              "Failed to push changes to origin. Please check git status and push manually before creating PR."
+            );
+          }
+        }
+        const result = await connection.createPR({ title, body, branch, baseBranch });
         connection.sendEvent({
           type: "pr_created",
           url: result.url,
@@ -2977,6 +3131,55 @@ function buildCreatePullRequestTool(connection) {
     }
   );
 }
+function buildQueryGcpLogsTool(connection) {
+  return defineTool(
+    "query_gcp_logs",
+    "Query GCP Cloud Logging for the current project. Returns log entries matching the given filters. Use severity to filter by minimum log level. The project's GCP credentials are used automatically.",
+    {
+      filter: z.string().optional().describe(
+        `Cloud Logging filter expression (e.g., 'resource.type="gce_instance"'). Max 1000 chars.`
+      ),
+      start_time: z.string().optional().describe("Start time in ISO 8601 format (e.g., '2024-01-01T00:00:00Z')"),
+      end_time: z.string().optional().describe("End time in ISO 8601 format (e.g., '2024-01-02T00:00:00Z')"),
+      severity: z.enum([
+        "DEFAULT",
+        "DEBUG",
+        "INFO",
+        "NOTICE",
+        "WARNING",
+        "ERROR",
+        "CRITICAL",
+        "ALERT",
+        "EMERGENCY"
+      ]).optional().describe("Minimum severity level to filter by (default: all levels)"),
+      page_size: z.number().optional().describe("Number of log entries to return (default 100, max 500)")
+    },
+    async ({ filter, start_time, end_time, severity, page_size }) => {
+      try {
+        const result = await connection.queryGcpLogs({
+          filter,
+          startTime: start_time,
+          endTime: end_time,
+          severity,
+          pageSize: page_size
+        });
+        if (result.entries.length === 0) {
+          return textResult("No log entries found matching the given filters.");
+        }
+        const summary = `Found ${result.entries.length} log entries${result.hasMore ? " (more available \u2014 refine filters or increase page_size)" : ""}.`;
+        const formatted = result.entries.map((e) => `[${e.timestamp}] [${e.severity}] ${e.message}`).join("\n");
+        return textResult(`${summary}
+
+${formatted}`);
+      } catch (error) {
+        return textResult(
+          `Failed to query GCP logs: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
 function buildScaleUpResourcesTool(connection) {
   return defineTool(
     "scale_up_resources",
@@ -3009,6 +3212,91 @@ function buildScaleUpResourcesTool(connection) {
     }
   );
 }
+function buildAddDependencyTool(connection) {
+  return defineTool(
+    "add_dependency",
+    "Add a dependency \u2014 this task cannot start until the specified task is merged to dev",
+    {
+      depends_on_slug_or_id: z.string().describe("Slug or ID of the task this task depends on")
+    },
+    async ({ depends_on_slug_or_id }) => {
+      try {
+        await connection.addDependency(depends_on_slug_or_id);
+        return textResult(`Dependency added: this task now depends on "${depends_on_slug_or_id}"`);
+      } catch (error) {
+        return textResult(
+          `Failed to add dependency: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  );
+}
+function buildRemoveDependencyTool(connection) {
+  return defineTool(
+    "remove_dependency",
+    "Remove a dependency from this task",
+    {
+      depends_on_slug_or_id: z.string().describe("Slug or ID of the task to remove as dependency")
+    },
+    async ({ depends_on_slug_or_id }) => {
+      try {
+        await connection.removeDependency(depends_on_slug_or_id);
+        return textResult("Dependency removed");
+      } catch (error) {
+        return textResult(
+          `Failed to remove dependency: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  );
+}
+function buildGetDependenciesTool(connection) {
+  return defineTool(
+    "get_dependencies",
+    "Get this task's dependencies and their current status (met = merged to dev)",
+    {},
+    async () => {
+      try {
+        const deps = await connection.getDependencies();
+        return textResult(JSON.stringify(deps, null, 2));
+      } catch (error) {
+        return textResult(
+          `Failed to get dependencies: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    },
+    { annotations: { readOnlyHint: true } }
+  );
+}
+function buildCreateFollowUpTaskTool(connection) {
+  return defineTool(
+    "create_follow_up_task",
+    "Create a follow-up task in this project that depends on the current task. Use for out-of-scope work, v1.1 features, or cleanup that should happen after this task merges.",
+    {
+      title: z.string().describe("Follow-up task title"),
+      description: z.string().optional().describe("Brief description of the follow-up work"),
+      plan: z.string().optional().describe("Implementation plan if known"),
+      story_point_value: z.number().optional().describe("Story point estimate (1=Common, 2=Magic, 3=Rare, 5=Unique)")
+    },
+    async ({ title, description, plan, story_point_value }) => {
+      try {
+        const result = await connection.createFollowUpTask({
+          title,
+          description,
+          plan,
+          storyPointValue: story_point_value
+        });
+        return textResult(
+          `Follow-up task created: "${title}" (slug: ${result.slug}). It depends on the current task and will be unblocked when this task is merged.`
+        );
+      } catch (error) {
+        return textResult(
+          `Failed to create follow-up task: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  );
+}
 function buildCommonTools(connection, config) {
   const tools = [
     buildReadTaskChatTool(connection),
@@ -3020,7 +3308,12 @@ function buildCommonTools(connection, config) {
     buildGetTaskFileTool(connection),
     buildSearchIncidentsTool(connection),
     buildGetTaskIncidentsTool(connection),
-    buildCreatePullRequestTool(connection)
+    buildQueryGcpLogsTool(connection),
+    buildCreatePullRequestTool(connection, config),
+    buildAddDependencyTool(connection),
+    buildRemoveDependencyTool(connection),
+    buildGetDependenciesTool(connection),
+    buildCreateFollowUpTaskTool(connection)
   ];
   if (process.env.CLAUDESPACE_NAME) {
     tools.push(buildScaleUpResourcesTool(connection));
@@ -4652,6 +4945,14 @@ import { randomUUID } from "crypto";
 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 CODE_REVIEW_WRITE_CMD_PATTERN = /git\s+push|git\s+commit|git\s+add|rm\s+|mv\s+|cp\s+|mkdir\s+|touch\s+|chmod\s+|chown\s+/;
+var RESOURCE_HEAVY_PATTERNS = [
+  /\bbun\s+(install|i|add)\b/,
+  /\bnpm\s+(install|ci|i)\b/,
+  /\byarn(\s+install)?\s/,
+  /\bpnpm\s+(install|i|add)\b/,
+  /\bpip\s+install\b/,
+  /\bcargo\s+build\b/
+];
 function isPlanFile(input) {
   const filePath = String(input.file_path ?? input.path ?? "");
   return filePath.includes(".claude/plans/");
@@ -4754,14 +5055,15 @@ async function handleExitPlanMode(host, input) {
         ].join("\n")
       };
     }
-    await host.connection.triggerIdentification();
-    host.hasExitedPlanMode = true;
     if (host.agentMode === "discovery") {
+      host.hasExitedPlanMode = true;
       host.connection.postChatMessage(
-        "Task identified and moved to Open. Switch to Build mode when ready to start implementation."
+        "Plan complete. The task stays in Planning \u2014 identify it or switch to Build mode when ready."
       );
       return { behavior: "allow", updatedInput: input };
     }
+    await host.connection.triggerIdentification();
+    host.hasExitedPlanMode = true;
     const newMode = host.isParentTask ? "review" : "building";
     host.pendingModeRestart = true;
     if (host.onModeTransition) {
@@ -4800,35 +5102,47 @@ async function handleAskUserQuestion(host, input) {
   return { behavior: "allow", updatedInput: { questions: input.questions, answers } };
 }
 var DENIAL_WARNING_THRESHOLD = 3;
+function isResourceHeavyCommand(command) {
+  return RESOURCE_HEAVY_PATTERNS.some((p) => p.test(command));
+}
+var autoScaled = false;
+async function maybeAutoScale(host, toolName, input) {
+  if (autoScaled || !process.env.CLAUDESPACE_NAME || toolName !== "Bash" || typeof input.command !== "string" || !isResourceHeavyCommand(input.command)) {
+    return;
+  }
+  autoScaled = true;
+  try {
+    await host.connection.requestScaleUp("light", `auto-scale: ${input.command.slice(0, 60)}`);
+  } catch {
+  }
+}
+function resolveToolAccess(host, toolName, input) {
+  switch (host.agentMode) {
+    case "discovery":
+      return handleDiscoveryToolAccess(toolName, input);
+    case "building":
+      return handleBuildingToolAccess(toolName, input);
+    case "review":
+      return handleReviewToolAccess(toolName, input, host.isParentTask);
+    case "auto":
+      return handleAutoToolAccess(toolName, input, host.hasExitedPlanMode, host.isParentTask);
+    case "code-review":
+      return handleCodeReviewToolAccess(toolName, input);
+    default:
+      return { behavior: "allow", updatedInput: input };
+  }
+}
 function buildCanUseTool(host) {
   let consecutiveDenials = 0;
   return async (toolName, input) => {
+    await maybeAutoScale(host, toolName, input);
     if (toolName === "ExitPlanMode" && (host.agentMode === "auto" || host.agentMode === "discovery") && !host.hasExitedPlanMode) {
       return await handleExitPlanMode(host, input);
     }
     if (toolName === "AskUserQuestion") {
       return await handleAskUserQuestion(host, input);
     }
-    let result;
-    switch (host.agentMode) {
-      case "discovery":
-        result = handleDiscoveryToolAccess(toolName, input);
-        break;
-      case "building":
-        result = handleBuildingToolAccess(toolName, input);
-        break;
-      case "review":
-        result = handleReviewToolAccess(toolName, input, host.isParentTask);
-        break;
-      case "auto":
-        result = handleAutoToolAccess(toolName, input, host.hasExitedPlanMode, host.isParentTask);
-        break;
-      case "code-review":
-        result = handleCodeReviewToolAccess(toolName, input);
-        break;
-      default:
-        result = { behavior: "allow", updatedInput: input };
-    }
+    const result = resolveToolAccess(host, toolName, input);
     if (result.behavior === "deny") {
       consecutiveDenials++;
       if (consecutiveDenials === DENIAL_WARNING_THRESHOLD) {
@@ -4854,6 +5168,7 @@ function buildHooks(host) {
       {
         hooks: [
           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);
               host.connection.sendEvent({
@@ -5773,6 +6088,9 @@ var AgentRunner = class {
     const pastPlanning = this.taskContext.status !== "Planning" && this.taskContext.status !== "Unidentified";
     if (this.agentMode === "auto" && pastPlanning) {
       this.hasExitedPlanMode = true;
+      this.agentMode = "building";
+      const builderModel = this.taskContext.builderModel ?? this.taskContext.model;
+      if (builderModel) this.taskContext.model = builderModel;
     }
     this.logEffectiveSettings();
     if (process.env.CODESPACES === "true") unshallowRepo(this.config.workspaceDir);
@@ -6077,16 +6395,21 @@ var AgentRunner = class {
     this._queryHost = host;
     return host;
   }
+  lastAnnouncedMode = null;
   handleModeChange(newAgentMode) {
     if (this.config.mode !== "pm") return;
-    if (newAgentMode) this.agentMode = newAgentMode;
+    if (!newAgentMode || newAgentMode === this.agentMode) return;
+    this.agentMode = newAgentMode;
     this.updateExitedPlanModeFlag(newAgentMode);
     const effectiveMode = this.effectiveAgentMode;
     const isBuildCapable = effectiveMode === "building" || effectiveMode === "auto" && this.hasExitedPlanMode;
     this.connection.emitModeChanged(effectiveMode);
-    this.connection.postChatMessage(
-      `Mode switched to **${effectiveMode}**${effectiveMode === "building" ? " \u2014 I now have direct coding access." : ""}`
-    );
+    if (effectiveMode !== this.lastAnnouncedMode) {
+      this.lastAnnouncedMode = effectiveMode;
+      this.connection.postChatMessage(
+        `Mode switched to **${effectiveMode}**${effectiveMode === "building" ? " \u2014 I now have direct coding access." : ""}`
+      );
+    }
     if (isBuildCapable && this.taskContext?.status === "Open") {
       this.connection.updateStatus("InProgress");
       this.taskContext.status = "InProgress";
@@ -6124,8 +6447,19 @@ var AgentRunner = class {
   }
   stop() {
     this.stopped = true;
+    this.stopHeartbeat();
     this.clearIdleTimers();
+    const host = this._queryHost;
+    if (host?.activeQuery) {
+      const q = host.activeQuery;
+      if (typeof q.abort === "function") {
+        q.abort();
+      }
+      void host.activeQuery.return(void 0);
+      host.activeQuery = null;
+    }
     this.tunnelClient?.disconnect();
+    this.connection.disconnect();
     if (this.inputResolver) {
       this.inputResolver(null);
       this.inputResolver = null;
@@ -7468,8 +7802,23 @@ var ProjectRunner = class {
     logger8.info("Connected, waiting for task assignments");
     await new Promise((resolve2) => {
       this.resolveLifecycle = resolve2;
-      process.on("SIGTERM", () => void this.stop());
-      process.on("SIGINT", () => void this.stop());
+      this.setupSignalHandlers();
+    });
+  }
+  setupSignalHandlers() {
+    process.on("SIGTERM", () => {
+      setTimeout(() => {
+        logger8.warn("Forcing exit after SIGTERM timeout");
+        process.exit(1);
+      }, STOP_TIMEOUT_MS + 1e4).unref();
+      void this.stop();
+    });
+    process.on("SIGINT", () => {
+      setTimeout(() => {
+        logger8.warn("Forcing exit after SIGINT timeout");
+        process.exit(1);
+      }, STOP_TIMEOUT_MS + 1e4).unref();
+      void this.stop();
     });
   }
   handleAssignment(assignment) {
@@ -7577,7 +7926,7 @@ var ProjectRunner = class {
     await Promise.race([
       Promise.all(stopPromises),
       new Promise((resolve2) => {
-        setTimeout(resolve2, 6e4);
+        setTimeout(resolve2, STOP_TIMEOUT_MS + 5e3);
       })
     ]);
     this.connection.disconnect();
@@ -7668,4 +8017,4 @@ export {
   ProjectRunner,
   FileCache
 };
-//# sourceMappingURL=chunk-RMNWEID4.js.map
+//# sourceMappingURL=chunk-WBBX5AIX.js.map