@rallycry/conveyor-agent 11.0.22 → 11.0.24

package/dist/{chunk-RW6V7KCE.js → chunk-HW6SHIL7.js}

@@ -29,7 +29,7 @@ import {
   spawnOptionsFingerprint,
   transcriptSize,
   turnOptionsFrom
-} from "./chunk-W5INK3NE.js";
+} from "./chunk-WCJ6HRVU.js";
 import {
   AGENT_STATUS_REASON_USER_QUESTION,
   AgentConnection,
@@ -91,7 +91,7 @@ import {
   statWorkspacePath,
   updateRemoteToken,
   verifyGitCredential
-} from "./chunk-OMD77OIJ.js";
+} from "./chunk-YNI2HFZE.js";
 import {
   registerBootMilestoneSocketFallback,
   reportBootMilestone
@@ -831,9 +831,11 @@ function mapUsage(message) {
   if (!isRecord(usage)) return void 0;
   const result = {};
   const input = numberField(usage, "input_tokens");
+  const output = numberField(usage, "output_tokens");
   const cacheRead = numberField(usage, "cache_read_input_tokens");
   const cacheCreation = numberField(usage, "cache_creation_input_tokens");
   if (input !== void 0) result.input_tokens = input;
+  if (output !== void 0) result.output_tokens = output;
   if (cacheRead !== void 0) result.cache_read_input_tokens = cacheRead;
   if (cacheCreation !== void 0) result.cache_creation_input_tokens = cacheCreation;
   return result;
@@ -1807,8 +1809,13 @@ async function writeHookSettings(dir, opts = {}) {
     // `--dangerously-skip-permissions`.
     // NOTE: a bare "*" rule is INVALID (the CLI rejects it and parks the TUI on
     // a Settings Warning dialog at boot) — hence the explicit ALLOW_RULES list.
+    // `deny` carries the tools no pod agent may use (Artifact publishes to an
+    // off-platform claude.ai URL; deliverables belong on the card). Bare tool
+    // names are the valid rule form. The key is omitted when empty — see
+    // HookSettingsOptions.disallowedTools for why that matters.
     permissions: {
-      allow: ALLOW_RULES
+      allow: ALLOW_RULES,
+      ...opts.disallowedTools && opts.disallowedTools.length > 0 ? { deny: opts.disallowedTools } : {}
     },
     hooks: {
       PreToolUse: buildPreToolUseHooks(helperPath, opts.gateAllTools === true),
@@ -2606,6 +2613,7 @@ var ClaudeTuiAdapter = class {
       permissionMode: options.permissionMode,
       settingsPath: input.settingsPath ?? "",
       ...options.appendSystemPrompt ? { appendSystemPrompt: options.appendSystemPrompt } : {},
+      ...options.disallowedTools?.length ? { disallowedTools: options.disallowedTools } : {},
       ...input.mcpConfigPath ? { mcpConfigPath: input.mcpConfigPath, strictMcpConfig: true } : {}
     });
     return {
@@ -3155,7 +3163,8 @@ var PtySession = class {
     );
     await this.socket.listen();
     const { settingsPath } = await writeHookSettings(this.tempDir, {
-      gateAllTools: this.options.permissionMode === "plan"
+      gateAllTools: this.options.permissionMode === "plan",
+      ...this.options.disallowedTools?.length ? { disallowedTools: this.options.disallowedTools } : {}
     });
     await this.setupToolServers();
     const transcriptPath = sessionTranscriptPath(this.options.cwd, sessionId);
@@ -5641,7 +5650,8 @@ function buildDiscoveryPrompt(context, runnerMode) {
     ] : [],
     ``,
     `### Contracts this environment enforces`,
-    `- You are READ-ONLY. File writes are denied outside \`.claude/plans/\`, and so are the commands that would start the work: git commit/push/merge/rebase/checkout, git apply, gh pr create, package publish. Everything else runs without an approval prompt \u2014 the pod is a sandbox, so investigate freely (build, test, query the dev DB, read logs).`,
+    `- You are READ-ONLY. File writes are denied outside \`.claude/plans/\` and \`/tmp/\`, and so are the commands that would start the work: git commit/push/merge/rebase/checkout, git apply, gh pr create, package publish. Everything else runs without an approval prompt \u2014 the pod is a sandbox, so investigate freely (build, test, query the dev DB, read logs).`,
+    `- Research deliverables the team should keep (a diagram, an HTML report, a screenshot, a data export) go on the card with \`mcp__conveyor__upload_attachment\`: write the file under \`/tmp/\` first, and pass \`title\` as the caption so it shows in the thread. Never publish one as a Claude artifact.`,
     `- A plan file on disk is NOT the plan. Only \`update_task\` saves it to the card.`,
     `- **ExitPlanMode is the LAST step and it validates.** It fails until the card has a plan, story points, risk, and a title \u2014 the plan comes from \`update_task\`, and story points, risk and title from \`update_task_properties\`. Calling it early wastes a turn on a denial.`,
     `- ExitPlanMode does NOT start building. It parks this session for human review; the team decides when to build.`,
@@ -6340,7 +6350,7 @@ Working rules:`,
     `- When a build/lint/test run fails, capture its output to a file once and grep the file \u2014 never re-run the suite just to re-filter the same output.`,
     `- App servers (including development and production servers) keep running after startup. Start them with the harness background/session facility, then run a separate bounded HTTP readiness check and continue verification. Never wait for server exit or a completion notification to mean the app is ready. If readiness times out, inspect build output and process/resource state before restarting.`,
     runtimeTui === "codex" ? `- Waiting on long-running commands: retain and resume the command session until it returns an exit result. Finish each required gate before ending the task. Never pretend a completion notification will resume you, and never start another gate while the current one is running.` : `- Waiting on long-running commands: if a gate finishes in under ~2 minutes, run it in the foreground with a timeout. For a longer one, launch it with run_in_background and STOP; a completion notification arrives when it finishes, and tracked background work holds the workspace awake for up to 45 minutes. Inspect any gate approaching that cap. For the final pre-PR gate a bounded foreground run (\`timeout 590 <gate>\` with Bash \`timeout: 600000\`) is still preferred as defense in depth. A pod restart loses both foreground and background processes. Never busy-wait with sleep/pgrep/tail loops, and never re-run the suite to escape a wait that looks stalled.`,
-    runtimeTui === "codex" ? `- Do not end your turn to wait on a required gate. Resume its command session, inspect its exit result, and then continue the checklist.` : `- For a finite background gate, end your turn and its completion notification re-invokes you within the bounded liveness window. Never emit filler commands (\`echo waiting\`, \`true\`, \`sleep N; echo done\`) to "stay alive" \u2014 they are detected and blocked. The proven long-wait shape: start the job with run_in_background, then end the turn.${agentMode === "review" ? "" : " For CI on a pushed commit the shape is `wait_for_checks`, then end the turn (the pod may sleep; the GitHub result wakes it)."} Arm a ScheduleWakeup (delaySeconds 900-1500, prompt restating your next steps) only when nothing will notify you \u2014 a deploy, a remote queue \u2014 never for CI, and never as insurance against a background job's own notification, which does fire.`,
+    runtimeTui === "codex" ? `- Do not end your turn to wait on a required gate. Resume its command session, inspect its exit result, and then continue the checklist.` : `- For a finite background gate, end your turn and its completion notification re-invokes you within the bounded liveness window. Never emit filler commands (\`echo waiting\`, \`true\`, \`sleep N; echo done\`) to "stay alive" \u2014 they are detected and blocked. The proven long-wait shape: start the job with run_in_background, then end the turn.${agentMode === "review" ? "" : " For CI on a pushed commit the shape is `wait_for_checks`, then end the turn (the pod may sleep; the GitHub result wakes it)."} Arm a ScheduleWakeup (delaySeconds 900-1500, prompt restating your next steps) only when nothing will notify you \u2014 a deploy, a remote queue \u2014 never for CI, and never as insurance against a background job's own notification, which does fire. One armed wakeup keeps this workspace awake until it fires (at most one hour), so arm exactly one and end the turn \u2014 a second one "as insurance" buys nothing.`,
     `
 Git:`,
     `- Stay on \`${context.githubBranch}\` for the whole task: do not check out another branch and do not create one. It was cut from \`${context.baseBranch}\`, and PRs target that automatically.`,
@@ -6860,7 +6870,7 @@ var SEARCH_STATUSES = [
   "Complete",
   "Cancelled"
 ];
-var SEARCH_CARD_TYPES = ["task", "incident", "suggestion"];
+var SEARCH_CARD_TYPES = ["task", "incident", "suggestion", "decision"];
 var searchFilterFields = {
   tagNames: f.optional(
     f.array(f.string(), {
@@ -7502,6 +7512,11 @@ var uploadAttachmentContract = defineToolContract({
       title: f.optional(
         f.string({ desc: "Short caption posted with the file (defaults to the file name)" })
       ),
+      comment: f.optional(
+        f.string({
+          desc: "Alias of `title` (the external conveyor-mcp surface names this field `comment`). Provide at most one of the two."
+        })
+      ),
       tags: attachmentTags
     }
   },
@@ -7514,6 +7529,11 @@ var uploadAttachmentContract = defineToolContract({
       comment: f.optional(
         f.string({ desc: "When set, also posts the attachment to the task chat with this text" })
       ),
+      title: f.optional(
+        f.string({
+          desc: "Alias of `comment` (the in-pod agent surface names this field `title`). Provide at most one of the two."
+        })
+      ),
       tags: attachmentTags,
       mimeType: f.optional(
         f.string({ desc: "Override the mime type inferred from the file extension" })
@@ -7553,6 +7573,293 @@ var createSuggestionContract = defineToolContract({
   }
 });
 var suggestionsContracts = [createSuggestionContract];
+var OPTION_KINDS = ["current", "planned", "proposed"];
+var STATUS_LABELS = ["Open", "Decided", "Cancelled"];
+var optionDescription = "What this option means in the product, written as GIVEN / WHEN / THEN. Concrete enough that a reader six months from now can tell which behaviour was chosen.";
+var optionsDesc = "Two or three options. More than three means the question is not framed yet \u2014 narrow it or split it. Mark the option describing what the code does today as kind: current.";
+var defaultOptionDesc = "1-based position of the option that wins if nobody decides by the deadline. Required: silence has to become a decision, never a stall.";
+var agentOption = f.object(
+  {
+    label: f.string({ min: 1, desc: "Short name for the option, under 80 characters" }),
+    description: f.string({ min: 1, desc: optionDescription }),
+    kind: f.optional(
+      f.enum(OPTION_KINDS, {
+        desc: 'current = what the code does today, planned = already agreed but unbuilt, proposed = new. Defaults to "proposed".'
+      })
+    )
+  },
+  { desc: "One option people can choose" }
+);
+var createDecisionContract = defineToolContract({
+  name: "create_decision",
+  agent: {
+    description: `Raise a product decision: a fork the plan cannot be right without. Two or three options, one default, a deadline. Run list_decisions FIRST \u2014 an answered decision is the answer, and re-asking it wastes everybody's time. Do NOT file a decision for an assumption you can simply state: an assumed behaviour belongs in the plan as a GIVEN / WHEN / THEN line under "Assumed behaviours". Returns the decision in full (the same JSON as get_decision, with option ids and the deadline) plus which cards were linked.`,
+    fields: {
+      question: f.string({
+        min: 1,
+        desc: "The question, as one plain sentence ending in a question mark"
+      }),
+      summary: f.optional(
+        f.string({
+          desc: cardDescriptionDesc("One or two sentences of context for the card face")
+        })
+      ),
+      context: f.string({
+        min: 1,
+        desc: "Markdown background: why this is being asked now, and what breaks if it is answered wrongly"
+      }),
+      options: f.array(agentOption, { min: 2, desc: optionsDesc }),
+      default_option: f.number({ int: true, min: 1, max: 3, desc: defaultOptionDesc }),
+      deadline_hours: f.optional(
+        f.number({ min: 1, max: 720, desc: "Hours until the default applies. Default 72." })
+      ),
+      impacted_cards: f.optional(
+        f.array(f.string(), {
+          desc: "Slugs or ids of cards this decision blocks. They cannot start until it is settled, and they are un-blocked the moment it is. Blocking a card needs Moderate access: without it the decision is still raised and each ref comes back under refused."
+        })
+      ),
+      include_current_card: f.optional(
+        f.boolean({
+          desc: "Also block the card this session is working on. Defaults to true \u2014 you are raising this because your own plan is stuck on it. Pass false to raise the question without stopping your own work."
+        })
+      ),
+      tag_names: f.optional(
+        f.array(f.string(), {
+          desc: "Tag names. The settled decision is written into each tag's overview, which is how the next agent finds it."
+        })
+      ),
+      raised_by_pr: f.optional(
+        f.number({ int: true, min: 1, desc: "PR number that surfaced the question" })
+      ),
+      raised_by_card: f.optional(
+        f.string({
+          desc: "Slug or id of the card that raised the question. A link back, not a block \u2014 use impacted_cards to block a card."
+        })
+      ),
+      deadline_at: f.optional(
+        f.string({
+          desc: "Absolute deadline as an ISO 8601 timestamp, e.g. 2026-09-25T17:00:00Z. Wins over deadline_hours when both are given; must be in the future and within 720 hours."
+        })
+      )
+    }
+  },
+  mcp: {
+    description: "Raise a product decision on a Conveyor project: a fork that has to be settled before the work can be planned correctly. Two or three options, one default that applies if nobody decides, and a deadline. Search list_decisions first \u2014 a Decided decision is the answer. Pass projectId to target a specific project; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId,
+      question: f.string({ desc: "The question, as one plain sentence" }),
+      summary: f.optional(f.string({ desc: cardDescriptionDesc("Context for the card face") })),
+      context: f.string({ desc: "Markdown background: why this is being asked now" }),
+      options: f.array(agentOption, { min: 2, desc: optionsDesc }),
+      defaultOption: f.number({ int: true, min: 1, max: 3, desc: defaultOptionDesc }),
+      deadlineHours: f.optional(
+        f.number({ min: 1, max: 720, desc: "Hours until the default applies. Default 72." })
+      ),
+      impactedCards: f.optional(
+        f.array(f.string(), {
+          desc: "Slugs or ids of cards this decision blocks. Needs Moderate access; without it each ref comes back under refused and the decision is still raised."
+        })
+      ),
+      tagNames: f.optional(f.array(f.string(), { desc: "Tag names to categorize the decision" })),
+      raisedByPr: f.optional(
+        f.number({ int: true, min: 1, desc: "PR number that surfaced the question" })
+      ),
+      raisedByCard: f.optional(
+        f.string({
+          desc: "Slug or id of the card that raised the question. A link back, not a block \u2014 use impactedCards to block a card."
+        })
+      ),
+      deadlineAt: f.optional(
+        f.string({
+          desc: "Absolute deadline (ISO 8601). Wins over deadlineHours when both are given; must be in the future and within 720 hours."
+        })
+      )
+    }
+  }
+});
+var listDecisionsContract = defineToolContract({
+  name: "list_decisions",
+  agent: {
+    description: `Search this project's decisions. Run this BEFORE planning anything in an area: "have we already decided how X behaves?" Each row carries the summary, who raised it (and from which card or PR), when, and \u2014 once settled \u2014 the resolution, so the list doubles as the decision log. Filter by card to see what is blocking a specific card.`,
+    fields: {
+      status: f.optional(
+        f.enum(STATUS_LABELS, {
+          desc: "Open = still being voted on, Decided = settled, Cancelled = dropped"
+        })
+      ),
+      tag: f.optional(f.string({ desc: 'Tag name, e.g. "slack"' })),
+      card: f.optional(
+        f.string({ desc: "Slug or id of a card \u2014 returns the decisions it is blocked by" })
+      ),
+      query: f.optional(f.string({ desc: "Text search on the question" })),
+      limit: f.optional(f.number({ desc: "Max rows to return (default 50, max 200)" }))
+    }
+  },
+  mcp: {
+    description: `List and search a Conveyor project's decisions. Decided rows include their resolution, so this is the fastest way to answer "did we already settle this?". Pass projectId to target a specific project; otherwise the configured default project is used.`,
+    fields: {
+      projectId: mcpProjectId,
+      status: f.optional(f.enum(STATUS_LABELS, { desc: "Filter by state" })),
+      tag: f.optional(f.string({ desc: "Tag name to filter by" })),
+      card: f.optional(f.string({ desc: "Card slug or id \u2014 decisions blocking that card" })),
+      query: f.optional(f.string({ desc: "Text search on the question" })),
+      limit: f.optional(
+        f.number({ int: true, min: 1, max: 200, desc: "Max rows to return (default 50)" })
+      )
+    }
+  }
+});
+var getDecisionContract = defineToolContract({
+  name: "get_decision",
+  agent: {
+    description: "Read one decision in full: its summary and context, who raised it and from where, every option with its GIVEN / WHEN / THEN, every vote with who cast it and why, the running tally, the cards it blocks, and the resolution once there is one. Use read_task_chat with the same id for the discussion thread.",
+    fields: {
+      decision: f.string({ min: 1, desc: "Decision slug or id" })
+    }
+  },
+  mcp: {
+    description: "Read one Conveyor decision in full \u2014 context, options, votes with reasons, tally, impacted cards, and the resolution. Pass projectId to disambiguate a slug; otherwise the configured default project is used.",
+    fields: {
+      projectId: mcpProjectId,
+      decision: f.string({ desc: "Decision slug or id" })
+    }
+  }
+});
+var voteDecisionContract = defineToolContract({
+  name: "vote_decision",
+  agent: {
+    description: "Vote on an open decision. One vote per voter: voting again replaces your previous one. Always give a reason \u2014 the resolution weighs reasons over counts, and a vote with no reason carries almost nothing.",
+    fields: {
+      decision: f.string({ min: 1, desc: "Decision slug or id" }),
+      option: f.string({ min: 1, desc: "Option id, or its 1-based position" }),
+      reason: f.optional(
+        f.string({ desc: "Why this option, in one or two sentences (max 255 characters)" })
+      )
+    }
+  },
+  mcp: {
+    description: "Vote on an open Conveyor decision, with a reason. One vote per voter \u2014 voting again replaces the previous one.",
+    fields: {
+      projectId: mcpProjectId,
+      decision: f.string({ desc: "Decision slug or id" }),
+      option: f.string({ desc: "Option id, or its 1-based position" }),
+      reason: f.optional(f.string({ desc: "Why this option (max 255 characters)" }))
+    }
+  }
+});
+var resolveDecisionContract = defineToolContract({
+  name: "resolve_decision",
+  agent: {
+    description: "Settle a decision. This is not a formality: the resolution is written into the plan of every card the decision blocked, into each of their chats, and into the overview of every tag it carries, and those cards become startable. Say what was decided in one or two sentences \u2014 a reader months later should not need to open the thread.",
+    fields: {
+      decision: f.string({ min: 1, desc: "Decision slug or id" }),
+      option: f.string({ min: 1, desc: "Winning option id, or its 1-based position" }),
+      resolution: f.string({
+        min: 1,
+        desc: "What was decided, in one or two plain sentences (max 255 characters)"
+      }),
+      notes: f.optional(
+        f.string({ desc: "Markdown reasoning. Link any verdict attachment here." })
+      )
+    }
+  },
+  mcp: {
+    description: "Settle a Conveyor decision. The resolution is written into every impacted card's plan and chat and into its tags' overviews, and the impacted cards become startable.",
+    fields: {
+      projectId: mcpProjectId,
+      decision: f.string({ desc: "Decision slug or id" }),
+      option: f.string({ desc: "Winning option id, or its 1-based position" }),
+      resolution: f.string({ desc: "What was decided (max 255 characters)" }),
+      notes: f.optional(f.string({ desc: "Markdown reasoning" }))
+    }
+  }
+});
+var updateDecisionContract = defineToolContract({
+  name: "update_decision",
+  agent: {
+    description: "Change an open decision: fix the question, summary, context or tags, rewrite the options while nobody has voted, move the deadline, link or unlink the cards it blocks, or cancel it. Cancelling un-blocks the impacted cards without answering the question, so only do it when the question stopped mattering.",
+    fields: {
+      decision: f.string({ min: 1, desc: "Decision slug or id" }),
+      question: f.optional(f.string({ min: 1, desc: "New question, one plain sentence" })),
+      summary: f.optional(
+        f.string({ desc: cardDescriptionDesc("New one- or two-sentence summary") })
+      ),
+      context: f.optional(f.string({ min: 1, desc: "New markdown background" })),
+      options: f.optional(
+        f.array(agentOption, {
+          min: 2,
+          desc: "Replacement options. Accepted only while the decision has no votes \u2014 once somebody has voted, cancel it and raise a new one instead. Send default_option with it: the old default no longer exists."
+        })
+      ),
+      default_option: f.optional(
+        f.number({ int: true, min: 1, max: 3, desc: "1-based position of the new default" })
+      ),
+      tag_names: f.optional(
+        f.array(f.string(), { desc: "Replacement tag names (replaces the current set)" })
+      ),
+      deadline_hours: f.optional(f.number({ desc: "New deadline, in hours from now. 1 to 720." })),
+      deadline_at: f.optional(
+        f.string({
+          desc: "New absolute deadline (ISO 8601). Wins over deadline_hours; must be in the future and within 720 hours."
+        })
+      ),
+      add_impacted_cards: f.optional(
+        f.array(f.string(), { desc: "Slugs or ids of cards to block on this decision" })
+      ),
+      remove_impacted_cards: f.optional(
+        f.array(f.string(), { desc: "Ids of cards to stop blocking" })
+      ),
+      status: f.optional(
+        f.enum(["Cancelled", "Open"], {
+          desc: "Cancelled drops the question; Open reopens a settled one and clears its answer"
+        })
+      )
+    }
+  },
+  mcp: {
+    description: "Change an open Conveyor decision: fix the question, summary, context or tags, rewrite the options while nobody has voted, move the deadline, link or unlink impacted cards, cancel it, or reopen a settled one.",
+    fields: {
+      projectId: mcpProjectId,
+      decision: f.string({ desc: "Decision slug or id" }),
+      question: f.optional(f.string({ desc: "New question" })),
+      summary: f.optional(f.string({ desc: cardDescriptionDesc("New summary") })),
+      context: f.optional(f.string({ desc: "New markdown background" })),
+      options: f.optional(
+        f.array(agentOption, {
+          min: 2,
+          desc: "Replacement options. Accepted only while the decision has no votes. Send defaultOption with it: the old default no longer exists."
+        })
+      ),
+      defaultOption: f.optional(
+        f.number({ int: true, min: 1, max: 3, desc: "1-based position of the new default" })
+      ),
+      tagNames: f.optional(f.array(f.string(), { desc: "Replacement tag names" })),
+      deadlineHours: f.optional(
+        f.number({ min: 1, max: 720, desc: "New deadline, in hours from now" })
+      ),
+      deadlineAt: f.optional(
+        f.string({ desc: "New absolute deadline (ISO 8601). Wins over deadlineHours." })
+      ),
+      addImpactedCards: f.optional(
+        f.array(f.string(), { desc: "Slugs or ids of cards to block on this decision" })
+      ),
+      removeImpactedCards: f.optional(
+        f.array(f.string(), { desc: "Ids of cards to stop blocking" })
+      ),
+      status: f.optional(
+        f.enum(["Cancelled", "Open"], { desc: "Cancel it, or reopen a settled one" })
+      )
+    }
+  }
+});
+var decisionsContracts = [
+  createDecisionContract,
+  listDecisionsContract,
+  getDecisionContract,
+  voteDecisionContract,
+  resolveDecisionContract,
+  updateDecisionContract
+];
 var createPullRequestContract = defineToolContract({
   name: "create_pull_request",
   agent: {
@@ -8213,6 +8520,7 @@ var TOOL_CONTRACTS = Object.fromEntries(
     ...subtasksContracts,
     ...attachmentsContracts,
     ...suggestionsContracts,
+    ...decisionsContracts,
     ...pullRequestContracts,
     ...integrationsContracts,
     ...driveContracts,
@@ -8276,10 +8584,11 @@ function buildReadTaskChatTool(connection) {
           taskId: task_id
         });
         return textResult(JSON.stringify(messages, null, 2));
-      } catch {
+      } catch (error) {
         return textResult(
           JSON.stringify({
-            note: "Could not fetch live chat. Chat history was provided in the initial context."
+            error: `Failed to read chat: ${error instanceof Error ? error.message : "Unknown error"}`,
+            note: "Usually transient \u2014 retry. Chat history up to this session's start was provided in the initial context."
           })
         );
       }
@@ -9063,7 +9372,8 @@ Paste this into the PR description to show it inline:
 ${snippet}`;
 }
 function buildUploadAttachmentTool(connection, config) {
-  return defineContractTool(uploadAttachmentContract, async ({ path, title, tags }) => {
+  return defineContractTool(uploadAttachmentContract, async ({ path, title, comment, tags }) => {
+    const caption = title ?? comment;
     try {
       const filePath = isAbsolute(path) ? path : join16(config.workspaceDir, path);
       const mimeType = inferMimeType(filePath);
@@ -9099,11 +9409,11 @@ function buildUploadAttachmentTool(connection, config) {
       const result = await connection.call("confirmFileUpload", {
         sessionId: connection.sessionId,
         fileId,
-        title,
+        title: caption,
         tags
       });
       return textResult(
-        `Uploaded ${fileName} (${info.size} bytes) and posted it to the task chat${title ? ` with caption "${title}"` : ""}. File ID: ${result.fileId}${describeTags(result.appliedTags, result.unknownTags)}${describeEmbed(fileName, result.downloadUrl)}`
+        `Uploaded ${fileName} (${info.size} bytes) and posted it to the task chat${caption ? ` with caption "${caption}"` : ""}. File ID: ${result.fileId}${describeTags(result.appliedTags, result.unknownTags)}${describeEmbed(fileName, result.downloadUrl)}`
       );
     } catch (error) {
       return textResult(
@@ -10465,6 +10775,155 @@ ${res.map(describeItem).join("\n")}`);
   ];
 }
 
+// src/tools/decision-tools.ts
+function errText5(prefix, error) {
+  return textResult(`${prefix}: ${error instanceof Error ? error.message : "Unknown error"}`);
+}
+function buildDecisionTools(connection, projectId) {
+  return [
+    ...readTools2(connection, projectId),
+    ...raiseAndVoteTools(connection, projectId),
+    ...settleTools(connection, projectId)
+  ];
+}
+function readTools2(connection, projectId) {
+  return [
+    defineContractTool(
+      listDecisionsContract,
+      async (input) => {
+        try {
+          const res = await connection.call("listProjectDecisions", {
+            projectId,
+            status: input.status,
+            tag: input.tag,
+            card: input.card,
+            query: input.query,
+            limit: input.limit
+          });
+          if (res.decisions.length === 0) {
+            return textResult(
+              "No decisions match. Nothing has been settled here, so you are free to choose \u2014 state the choice in the plan as a GIVEN / WHEN / THEN assumption, or raise a decision with create_decision if the plan cannot be right without an answer."
+            );
+          }
+          return textResult(JSON.stringify(res.decisions, null, 2));
+        } catch (error) {
+          return errText5("Failed to list decisions", error);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    ),
+    defineContractTool(
+      getDecisionContract,
+      async (input) => {
+        try {
+          const res = await connection.call("getProjectDecision", {
+            projectId,
+            decision: input.decision
+          });
+          return textResult(JSON.stringify(res, null, 2));
+        } catch (error) {
+          return errText5("Failed to read the decision", error);
+        }
+      },
+      { annotations: { readOnlyHint: true } }
+    )
+  ];
+}
+function raiseAndVoteTools(connection, projectId) {
+  return [
+    defineContractTool(createDecisionContract, async (input) => {
+      try {
+        const res = await connection.call("createProjectDecision", {
+          projectId,
+          question: input.question,
+          summary: input.summary,
+          context: input.context,
+          options: input.options,
+          defaultOption: input.default_option,
+          deadlineHours: input.deadline_hours,
+          impactedCards: input.impacted_cards,
+          includeCurrentCard: input.include_current_card,
+          sessionId: connection.sessionId,
+          tagNames: input.tag_names,
+          raisedByPr: input.raised_by_pr,
+          raisedByCard: input.raised_by_card,
+          deadlineAt: input.deadline_at
+        });
+        const { impactedLinked, refused, ...detail } = res;
+        const refusedLine = refused.length > 0 ? `
+
+Not linked: ${refused.map((r) => `${r.ref} (${r.reason})`).join("; ")}` : "";
+        return textResult(
+          `Raised decision ${res.slug} \u2014 ${res.url}
+Blocking ${impactedLinked.length} card(s).${refusedLine}
+
+${JSON.stringify(detail, null, 2)}`
+        );
+      } catch (error) {
+        return errText5("Failed to raise the decision", error);
+      }
+    }),
+    defineContractTool(voteDecisionContract, async (input) => {
+      try {
+        const res = await connection.call("voteProjectDecision", {
+          projectId,
+          decision: input.decision,
+          option: input.option,
+          reason: input.reason
+        });
+        const tally = res.options.map((o) => `${o.label}: ${o.votes}`).join(", ");
+        return textResult(`Voted on ${res.slug}. Tally \u2014 ${tally}.`);
+      } catch (error) {
+        return errText5("Failed to vote", error);
+      }
+    })
+  ];
+}
+function settleTools(connection, projectId) {
+  return [
+    defineContractTool(resolveDecisionContract, async (input) => {
+      try {
+        const res = await connection.call("resolveProjectDecision", {
+          projectId,
+          decision: input.decision,
+          option: input.option,
+          resolution: input.resolution,
+          notes: input.notes
+        });
+        return textResult(
+          `Settled ${res.slug} as "${res.chosenOption}". ${res.impactedCount} card(s) were written back to and are no longer blocked.`
+        );
+      } catch (error) {
+        return errText5("Failed to settle the decision", error);
+      }
+    }),
+    defineContractTool(updateDecisionContract, async (input) => {
+      try {
+        const res = await connection.call("updateProjectDecision", {
+          projectId,
+          decision: input.decision,
+          question: input.question,
+          summary: input.summary,
+          context: input.context,
+          options: input.options,
+          defaultOption: input.default_option,
+          tagNames: input.tag_names,
+          deadlineHours: input.deadline_hours,
+          deadlineAt: input.deadline_at,
+          addImpactedCards: input.add_impacted_cards,
+          removeImpactedCards: input.remove_impacted_cards,
+          status: input.status
+        });
+        return textResult(
+          `Updated ${res.slug} \u2014 ${res.status}, ${res.impactedCount} impacted card(s), deadline ${res.deadlineAt}.`
+        );
+      } catch (error) {
+        return errText5("Failed to update the decision", error);
+      }
+    })
+  ];
+}
+
 // src/tools/connected-tools.ts
 function connectedToolsFor(connection, context) {
   const projectId = context?.projectId;
@@ -10474,6 +10933,9 @@ function connectedToolsFor(connection, context) {
     buildListProjectIntegrationsTool(connection, projectId),
     ...context.chatChannelsConfigured ? buildChannelTools(connection, projectId) : [],
     ...context.meetingsAvailable ? buildMeetingTools(connection, projectId) : [],
+    // Always available: the decision tables exist on every project, and a fork
+    // an agent cannot file is a fork it assumes its way past instead.
+    ...buildDecisionTools(connection, projectId),
     ...context.googleAnalyticsConfigured ? [buildAnalyticsSummaryTool(connection, projectId)] : [],
     ...context.gcpLogsConfigured ? [buildQueryGcpLogsTool(connection, projectId)] : [],
     ...context.grafanaLogsConfigured ? [buildQueryGrafanaLogsTool(connection, projectId)] : []
@@ -10846,6 +11308,26 @@ function safeVoid(promise, context) {
     });
   }
 }
+function addTurnUsage(total, usage) {
+  const next = {
+    inputTokens: total.inputTokens + (usage.input_tokens ?? 0),
+    outputTokens: total.outputTokens + (usage.output_tokens ?? 0),
+    cacheReadInputTokens: total.cacheReadInputTokens + (usage.cache_read_input_tokens ?? 0),
+    cacheCreationInputTokens: total.cacheCreationInputTokens + (usage.cache_creation_input_tokens ?? 0),
+    totalTokens: 0
+  };
+  next.totalTokens = next.inputTokens + next.outputTokens + next.cacheReadInputTokens + next.cacheCreationInputTokens;
+  return next;
+}
+function emptyTurnUsage() {
+  return {
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadInputTokens: 0,
+    cacheCreationInputTokens: 0,
+    totalTokens: 0
+  };
+}
 function epochSecondsToISO(value) {
   if (typeof value === "string") return value;
   if (typeof value !== "number" || value <= 0) return void 0;
@@ -10927,11 +11409,16 @@ function emitContextUpdate(modelUsage, host, context, lastAssistantUsage) {
     });
   }
 }
-function handleSuccessResult(event, host, context, startTime, lastAssistantUsage) {
+function handleSuccessResult(event, host, context, startTime, lastAssistantUsage, turnUsage) {
   const durationMs = Date.now() - startTime;
   const summary = event.result || "Task completed.";
   const retriable = isRetriableMessage(summary);
-  host.connection.sendEvent({ type: "completed", summary, durationMs });
+  host.connection.sendEvent({
+    type: "completed",
+    summary,
+    durationMs,
+    ...turnUsage && turnUsage.totalTokens > 0 ? { usage: turnUsage } : {}
+  });
   const { modelUsage } = event;
   if (modelUsage && typeof modelUsage === "object") {
     emitContextUpdate(modelUsage, host, context, lastAssistantUsage);
@@ -10952,7 +11439,7 @@ function handleErrorResult(event, host) {
   host.connection.sendEvent({ type: "error", message: errorMsg });
   return { retriable };
 }
-function handleResultEvent(event, host, context, startTime, lastAssistantUsage) {
+function handleResultEvent(event, host, context, startTime, lastAssistantUsage, turnUsage) {
   const resultSummary = event.subtype === "success" ? event.result : event.errors.join(", ");
   if (event.subtype === "success") {
     const result2 = handleSuccessResult(
@@ -10960,15 +11447,16 @@ function handleResultEvent(event, host, context, startTime, lastAssistantUsage)
       host,
       context,
       startTime,
-      lastAssistantUsage
+      lastAssistantUsage,
+      turnUsage
     );
     return { ...result2, resultSummary };
   }
   const result = handleErrorResult(event, host);
   return { ...result, resultSummary };
 }
-async function emitResultEvent(event, host, context, startTime, lastAssistantUsage) {
-  const result = handleResultEvent(event, host, context, startTime, lastAssistantUsage);
+async function emitResultEvent(event, host, context, startTime, lastAssistantUsage, turnUsage) {
+  const result = handleResultEvent(event, host, context, startTime, lastAssistantUsage, turnUsage);
   const durationMs = Date.now() - startTime;
   if (event.subtype === "success") {
     const successEvent = event;
@@ -10976,7 +11464,8 @@ async function emitResultEvent(event, host, context, startTime, lastAssistantUsa
     await host.callbacks.onEvent({
       type: "completed",
       summary,
-      durationMs
+      durationMs,
+      ...turnUsage && turnUsage.totalTokens > 0 ? { usage: turnUsage } : {}
     });
   } else if (!result.staleSession) {
     const errorEvent = event;
@@ -11082,13 +11571,20 @@ async function handleAssistantCase(event, host, turnToolCalls) {
   const msgUsage = event.message.usage;
   return msgUsage ?? void 0;
 }
-async function handleResultCase(event, host, context, startTime, isTyping, lastAssistantUsage) {
+async function handleResultCase(event, host, context, startTime, isTyping, lastAssistantUsage, turnUsage) {
   let stoppedTyping = false;
   if (isTyping) {
     host.connection.sendTypingStop();
     stoppedTyping = true;
   }
-  const resultInfo = await emitResultEvent(event, host, context, startTime, lastAssistantUsage);
+  const resultInfo = await emitResultEvent(
+    event,
+    host,
+    context,
+    startTime,
+    lastAssistantUsage,
+    turnUsage
+  );
   return {
     retriable: resultInfo.retriable,
     resultSummary: resultInfo.resultSummary,
@@ -11192,7 +11688,10 @@ async function processAssistantCase(event, host, state) {
     state.isTyping = true;
   }
   const usage = await handleAssistantCase(event, host, state.turnToolCalls);
-  if (usage) state.lastAssistantUsage = usage;
+  if (usage) {
+    state.lastAssistantUsage = usage;
+    state.turnUsage = addTurnUsage(state.turnUsage, usage);
+  }
   if (!state.sawApiError || event.isApiError && !state.terminalApiError) {
     const fullText = event.message.content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
     if (API_ERROR_PATTERN.test(fullText)) {
@@ -11211,7 +11710,8 @@ async function processResultCase(event, host, context, startTime, state) {
     context,
     startTime,
     state.isTyping,
-    state.lastAssistantUsage
+    state.lastAssistantUsage,
+    state.turnUsage
   );
   if (info.stoppedTyping) state.isTyping = false;
   state.retriable = info.retriable;
@@ -11244,6 +11744,7 @@ async function processEvents(events, context, host) {
     staleSession: void 0,
     authError: void 0,
     lastAssistantUsage: void 0,
+    turnUsage: emptyTurnUsage(),
     turnToolCalls: [],
     questionPending: false
   };
@@ -11323,6 +11824,9 @@ function fallbackResetIso(rateLimitType, now = Date.now()) {
   return new Date(now + (weekly ? TWENTY_FOUR_HOURS_MS : FIVE_HOURS_MS)).toISOString();
 }
 
+// src/execution/tool-access.ts
+import { isAbsolute as isAbsolute3, posix } from "path";
+
 // src/execution/task-property-utils.ts
 function collectMissingProps(taskProps) {
   const missing = [];
@@ -11465,6 +11969,12 @@ function isPlanFile(input) {
   const filePath = String(input.file_path ?? input.path ?? "");
   return filePath.includes(".claude/plans/");
 }
+function isScratchPath(input) {
+  const filePath = String(input.file_path ?? input.path ?? "");
+  if (!isAbsolute3(filePath)) return false;
+  return posix.normalize(filePath).startsWith("/tmp/");
+}
+var ARTIFACT_DENIED = "Publish deliverables on the card with upload_attachment; the Artifact tool is not available in Conveyor sessions.";
 var READ_ONLY_BLOCKED_BASH = [
   { name: "git commit", re: /\bgit\s+(?:-\S+\s+)*commit\b/ },
   { name: "git push", re: /\bgit\s+(?:-\S+\s+)*push\b/ },
@@ -11483,17 +11993,19 @@ function matchesReadOnlyBlocked(cmd) {
 }
 var POST_CHANNEL_TOOL = /(^|__)post_channel_message$/;
 var CHANNEL_POST_DENIED = "Posting into a chat channel is not available in this mode. Reading channels still is \u2014 use read_channel_messages if you need the discussion.";
+var DECISION_SETTLE_TOOLS = /(^|__)(resolve_decision|update_decision)$/;
+var DECISION_SETTLE_DENIED = "Settling a decision is not available in review mode. Say on the PR that the change turns on an unsettled decision, and cite it with list_decisions \u2014 a reviewer does not make the product call.";
 function handleReadOnlyToolAccess(toolName, input) {
   if (POST_CHANNEL_TOOL.test(toolName)) {
     return { behavior: "deny", message: CHANNEL_POST_DENIED };
   }
   if (PM_PLAN_FILE_TOOLS.has(toolName)) {
-    if (isPlanFile(input)) {
+    if (isPlanFile(input) || isScratchPath(input)) {
       return { behavior: "allow", updatedInput: input };
     }
     return {
       behavior: "deny",
-      message: "Discovery mode is read-only. File writes are restricted to plan files."
+      message: "Discovery mode is read-only. File writes are restricted to plan files and /tmp/ scratch files \u2014 write a deliverable under /tmp/ and attach it with upload_attachment."
     };
   }
   if (toolName === "Bash") {
@@ -11532,6 +12044,9 @@ function handleReviewToolAccess(toolName, input) {
   if (POST_CHANNEL_TOOL.test(toolName)) {
     return { behavior: "deny", message: CHANNEL_POST_DENIED };
   }
+  if (DECISION_SETTLE_TOOLS.test(toolName)) {
+    return { behavior: "deny", message: DECISION_SETTLE_DENIED };
+  }
   return handleBuildingToolAccess(toolName, input);
 }
 function handleAutoToolAccess(toolName, input, hasExitedPlanMode, isParentTask) {
@@ -11649,7 +12164,7 @@ var DENIAL_FORCE_STOP_THRESHOLD = 8;
 function handleDenialEscalation(host, consecutiveDenials) {
   if (consecutiveDenials === DENIAL_WARNING_THRESHOLD) {
     host.connection.postChatMessage(
-      `\u26A0\uFE0F Multiple tool denials detected. You are in ${host.agentMode} mode \u2014 file writes outside .claude/plans/ are not permitted. Focus on creating a plan instead of implementing code changes.`
+      `\u26A0\uFE0F Multiple tool denials detected. You are in ${host.agentMode} mode \u2014 file writes outside .claude/plans/ and /tmp/ are not permitted. Focus on creating a plan instead of implementing code changes.`
     );
   }
   if (consecutiveDenials >= DENIAL_FORCE_STOP_THRESHOLD) {
@@ -11695,6 +12210,9 @@ function checkToolLoop(host, toolName, input) {
   return { behavior: "deny", message: buildRepeatLoopMessage(repeats, isHeavyGateActive()) };
 }
 function resolveToolAccess(host, toolName, input) {
+  if (toolName === "Artifact") {
+    return { behavior: "deny", message: ARTIFACT_DENIED };
+  }
   switch (host.agentMode) {
     case "discovery":
     case "help":
@@ -13409,6 +13927,100 @@ var BackgroundWorkTracker = class {
   }
 };
 
+// src/runner/scheduled-wakeup.ts
+var SCHEDULE_WAKEUP_TOOL = "schedulewakeup";
+var SCHEDULED_WAKEUP_MIN_DELAY_SECONDS = 60;
+var SCHEDULED_WAKEUP_MAX_DELAY_SECONDS = 3600;
+var SCHEDULED_WAKEUP_GRACE_MS = 2 * 60 * 1e3;
+function asRecord3(input) {
+  if (typeof input === "string") {
+    try {
+      const parsed = JSON.parse(input);
+      return typeof parsed === "object" && parsed !== null ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
+  return typeof input === "object" && input !== null ? input : null;
+}
+function parseScheduledWakeup(tool2, input, now = Date.now()) {
+  if (tool2.toLowerCase() !== SCHEDULE_WAKEUP_TOOL) return null;
+  const record = asRecord3(input);
+  if (!record) return null;
+  if (record.stop === true) return null;
+  const raw = record.delaySeconds;
+  if (typeof raw !== "number" || !Number.isFinite(raw)) return null;
+  const delaySeconds = Math.min(
+    SCHEDULED_WAKEUP_MAX_DELAY_SECONDS,
+    Math.max(SCHEDULED_WAKEUP_MIN_DELAY_SECONDS, raw)
+  );
+  return { delaySeconds, deadline: now + delaySeconds * 1e3 + SCHEDULED_WAKEUP_GRACE_MS };
+}
+function isScheduledWakeupStop(tool2, input) {
+  if (tool2.toLowerCase() !== SCHEDULE_WAKEUP_TOOL) return false;
+  return asRecord3(input)?.stop === true;
+}
+var ScheduledWakeupTracker = class {
+  /** Absolute expiry (epoch ms) of the armed wakeup; null when none. */
+  deadline = null;
+  onChange;
+  log;
+  constructor(options = {}) {
+    this.onChange = options.onChange;
+    this.log = options.log ?? ((message) => process.stderr.write(message));
+  }
+  /**
+   * Feed one `tool_use` from the turn stream. Returns true when it changed the
+   * armed state (test/diagnostic signal; callers can ignore it).
+   */
+  noteToolUse(tool2, input, now = Date.now()) {
+    if (isScheduledWakeupStop(tool2, input)) {
+      if (this.deadline === null) return false;
+      this.deadline = null;
+      this.log("[conveyor-agent] scheduled wakeup stopped \u2014 heartbeats may report idle again\n");
+      this.onChange?.();
+      return true;
+    }
+    const arm = parseScheduledWakeup(tool2, input, now);
+    if (!arm) return false;
+    this.deadline = arm.deadline;
+    this.log(
+      `[conveyor-agent] scheduled wakeup armed (${arm.delaySeconds}s) \u2014 heartbeats stay non-idle until it fires
+`
+    );
+    this.onChange?.();
+    return true;
+  }
+  /** Is a non-expired wakeup armed? */
+  hasPending(now = Date.now()) {
+    this.prune(now);
+    return this.deadline !== null;
+  }
+  /** Absolute expiry of the armed wakeup, or null when none is armed. Callers
+   *  bound their own deferrals by this rather than by a fixed cap — a one-hour
+   *  arm outlives `BACKGROUND_WORK_MAX_MS`. */
+  pendingDeadline(now = Date.now()) {
+    this.prune(now);
+    return this.deadline;
+  }
+  /** Drop the arm (a turn started, or the session is shutting down). */
+  clear() {
+    if (this.deadline === null) return;
+    this.deadline = null;
+    this.onChange?.();
+  }
+  /** Expire a deadline that has passed, loudly — the wakeup should have fired
+   *  a turn by now, so a tripped expiry is worth seeing in the log. */
+  prune(now) {
+    if (this.deadline === null || this.deadline > now) return;
+    this.deadline = null;
+    this.log(
+      "[conveyor-agent] scheduled wakeup deadline passed with no turn \u2014 reporting idle again\n"
+    );
+    this.onChange?.();
+  }
+};
+
 // src/runner/live-children.ts
 function findLiveChild(sources) {
   for (const source of sources) {
@@ -13476,6 +14088,13 @@ var SessionRunner = class _SessionRunner {
   backgroundWork = new BackgroundWorkTracker({
     onChange: () => this.refreshLoopStatus()
   });
+  /** An armed `ScheduleWakeup` (the dynamic `/loop` mode): the turn ended, but
+   *  the agent asked to be re-invoked at a deadline. Same liveness contract as
+   *  `backgroundWork` — while it reports pending, heartbeats go out non-idle so
+   *  the reconciler cannot sleep the pod before the wakeup fires. */
+  scheduledWakeup = new ScheduledWakeupTracker({
+    onChange: () => this.refreshLoopStatus()
+  });
   /** Boot supervisor handle, set post-construction once it's known (it is
    *  started alongside connect(), before the runner itself exists in some
    *  call sites) — notified when the core loop goes live so it can release
@@ -13520,6 +14139,7 @@ var SessionRunner = class _SessionRunner {
       },
       onIdleTimeout: () => {
         if (this.deferShutdownForLiveChild("idle")) return;
+        if (this.deferShutdownForScheduledWakeup("idle")) return;
         if (this.deferShutdownForBackgroundWork()) return;
         process.stderr.write("[conveyor-agent] Idle timeout reached, stopping agent\n");
         this.stopped = true;
@@ -13532,6 +14152,7 @@ var SessionRunner = class _SessionRunner {
       },
       onDormantTimeout: () => {
         if (this.deferShutdownForLiveChild("dormant")) return;
+        if (this.deferShutdownForScheduledWakeup("dormant")) return;
         process.stderr.write("[conveyor-agent] Dormant idle timeout reached, shutting down\n");
         this.stopped = true;
         this.queryBridge?.stop();
@@ -13591,6 +14212,50 @@ var SessionRunner = class _SessionRunner {
     const label = timer === "idle" ? "Idle" : "Dormant idle";
     process.stderr.write(
       `[conveyor-agent] ${label} timeout deferred: ${live.kind} session ${live.sessionId} active
+`
+    );
+    if (timer === "idle") {
+      this.lifecycle.startIdleTimer(recheckMs);
+    } else {
+      this.dormantDeadline = Date.now() + recheckMs;
+      this.lifecycle.startDormantTimer(recheckMs);
+    }
+    return true;
+  }
+  /**
+   * Suppress an idle or dormant shutdown while a `ScheduleWakeup` is armed.
+   *
+   * Both timers matter. The idle timer (30 min) kills a loop that paces itself
+   * slower than that, and the dormant timer (60 min after a `completed` event)
+   * kills a one-hour arm — the agent declares completion at the end of every
+   * tick, so a dynamic loop sits dormant by construction.
+   *
+   * The bound is the WAKEUP'S OWN deadline, not `BACKGROUND_WORK_MAX_MS`: the
+   * tool clamps `delaySeconds` to one hour, which already exceeds that 45-min
+   * cap, so reusing it would shut the pod down before the longest legal arm
+   * fired. Once the deadline passes the tracker expires it and this returns
+   * false, so a lost timer cannot pin a pod.
+   */
+  deferShutdownForScheduledWakeup(timer) {
+    let deadline;
+    try {
+      deadline = this.scheduledWakeup.pendingDeadline();
+    } catch (err) {
+      process.stderr.write(
+        `[conveyor-agent] Scheduled-wakeup probe failed, not deferring: ${err}
+`
+      );
+      return false;
+    }
+    if (deadline === null) return false;
+    const remainingMs = Math.max(0, deadline - Date.now());
+    const recheckMs = Math.min(
+      Math.max(remainingMs, 1),
+      Math.max(this.lifecycle.config.idleTimeoutMs, 1)
+    );
+    const label = timer === "idle" ? "Idle" : "Dormant idle";
+    process.stderr.write(
+      `[conveyor-agent] ${label} timeout deferred: scheduled wakeup armed (${Math.round(remainingMs / 1e3)}s remaining)
 `
     );
     if (timer === "idle") {
@@ -14520,6 +15185,7 @@ var SessionRunner = class _SessionRunner {
     });
     this.portDiscovery.stop();
     this.backgroundWork.clear();
+    this.scheduledWakeup.clear();
     this.loopLag.stop();
     this.lifecycle.destroy();
     this.connection.disconnect();
@@ -14760,6 +15426,7 @@ ${outcome.failures.join("\n")}
     if (this.questionPendingSince !== null && Date.now() - this.questionPendingSince < resolveQuestionGraceMs() + QUESTION_HOLD_SLACK_MS) {
       return "waiting";
     }
+    if (this.scheduledWakeup.hasPending()) return "waiting";
     return this.backgroundWork.hasPending() || isHeavyGateActive() ? "waiting" : "idle";
   }
   // ── Question grace hold ────────────────────────────────────────────
@@ -14830,11 +15497,12 @@ ${outcome.failures.join("\n")}
     this.loopLag.setStatus(loopStatus);
     return loopStatus;
   }
-  /** One `tool_use` from the turn stream — registers a background launch when
-   *  the tool starts work that outlives the turn. */
+  /** One `tool_use` from the turn stream — registers work that outlives the
+   *  turn: a background launch, or an armed `ScheduleWakeup`. */
   noteToolUseForBackgroundWork(event) {
     if (event.type !== "tool_use" || typeof event.tool !== "string") return;
     this.backgroundWork.noteToolUse(event.tool, event.input);
+    this.scheduledWakeup.noteToolUse(event.tool, event.input);
   }
   async setState(status) {
     if (status === "running") {
@@ -14875,6 +15543,7 @@ ${outcome.failures.join("\n")}
   /** Mark a fresh turn without emitting a duplicate status. QueryExecutor's
    * prefilled PTY callback already emitted `running` before it reaches here. */
   beginRunningEpisode() {
+    this.scheduledWakeup.clear();
     this.activeEpisodeStartedAt = Date.now();
     this.backgroundDeferStartedAt = null;
     this.backgroundWakeFiredThisIdle = false;
@@ -14886,6 +15555,7 @@ ${outcome.failures.join("\n")}
     this.clearQuestionHold();
     this.portDiscovery.stop();
     this.backgroundWork.clear();
+    this.scheduledWakeup.clear();
     this.loopLag.stop();
     this.lifecycle.destroy();
     try {