@rallycry/conveyor-agent 11.0.23 → 11.0.24

package/dist/{boot-S73ZNWBJ.js → boot-65PTSADA.js}

@@ -1,6 +1,6 @@
 import {
   startWorkbenchServer
-} from "./chunk-EIHZRSYI.js";
+} from "./chunk-EITUTXXJ.js";
 import {
   TOMBSTONE_MESSAGE,
   isLegacyEntrypointLaunch
@@ -12,7 +12,7 @@ import {
   refreshSkillsAfterCheckout,
   runPreReadyBinds
 } from "./chunk-37J5MMQT.js";
-import "./chunk-W5INK3NE.js";
+import "./chunk-WCJ6HRVU.js";
 import {
   GitPrepJob,
   defaultGit,

package/dist/{chunk-EIHZRSYI.js → chunk-EITUTXXJ.js}

@@ -1,6 +1,6 @@
 import {
   loadPtySpawn
-} from "./chunk-W5INK3NE.js";
+} from "./chunk-WCJ6HRVU.js";
 import {
   terminateProcessGroup
 } from "./chunk-W4LZ7R6Z.js";

package/dist/{chunk-XJSW42TM.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-I7QYTA2V.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.`,
@@ -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" })
@@ -7573,7 +7593,7 @@ var agentOption = f.object(
 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's id, slug, and url.`,
+    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,
@@ -7610,6 +7630,16 @@ var createDecisionContract = defineToolContract({
       ),
       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."
+        })
       )
     }
   },
@@ -7633,6 +7663,16 @@ var createDecisionContract = defineToolContract({
       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."
+        })
       )
     }
   }
@@ -7640,7 +7680,7 @@ var createDecisionContract = defineToolContract({
 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?" Decided rows carry their resolution, so the list doubles as the decision log. Filter by card to see what is blocking a specific card.`,
+    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, {
@@ -7672,7 +7712,7 @@ var listDecisionsContract = defineToolContract({
 var getDecisionContract = defineToolContract({
   name: "get_decision",
   agent: {
-    description: "Read one decision in full: its context, 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.",
+    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" })
     }
@@ -7737,10 +7777,32 @@ var resolveDecisionContract = defineToolContract({
 var updateDecisionContract = defineToolContract({
   name: "update_decision",
   agent: {
-    description: "Change an open decision: extend its 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.",
+    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" })
       ),
@@ -7755,13 +7817,29 @@ var updateDecisionContract = defineToolContract({
     }
   },
   mcp: {
-    description: "Change an open Conveyor decision: extend the deadline, link or unlink impacted cards, cancel it, or reopen a settled one.",
+    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" })
       ),
@@ -8506,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."
           })
         );
       }
@@ -9293,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);
@@ -9329,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(
@@ -10765,14 +10845,19 @@ function raiseAndVoteTools(connection, projectId) {
           includeCurrentCard: input.include_current_card,
           sessionId: connection.sessionId,
           tagNames: input.tag_names,
-          raisedByPr: input.raised_by_pr
+          raisedByPr: input.raised_by_pr,
+          raisedByCard: input.raised_by_card,
+          deadlineAt: input.deadline_at
         });
-        const refused = res.refused.length > 0 ? `
+        const { impactedLinked, refused, ...detail } = res;
+        const refusedLine = refused.length > 0 ? `
 
-Not linked: ${res.refused.map((r) => `${r.ref} (${r.reason})`).join("; ")}` : "";
+Not linked: ${refused.map((r) => `${r.ref} (${r.reason})`).join("; ")}` : "";
         return textResult(
           `Raised decision ${res.slug} \u2014 ${res.url}
-Blocking ${res.impactedLinked.length} card(s).${refused}`
+Blocking ${impactedLinked.length} card(s).${refusedLine}
+
+${JSON.stringify(detail, null, 2)}`
         );
       } catch (error) {
         return errText5("Failed to raise the decision", error);
@@ -10817,7 +10902,14 @@ function settleTools(connection, projectId) {
         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
@@ -11216,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;
@@ -11297,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);
@@ -11322,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(
@@ -11330,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;
@@ -11346,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;
@@ -11452,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,
@@ -11562,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)) {
@@ -11581,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;
@@ -11614,6 +11744,7 @@ async function processEvents(events, context, host) {
     staleSession: void 0,
     authError: void 0,
     lastAssistantUsage: void 0,
+    turnUsage: emptyTurnUsage(),
     turnToolCalls: [],
     questionPending: false
   };
@@ -11693,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 = [];
@@ -11835,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/ },
@@ -11860,12 +12000,12 @@ function handleReadOnlyToolAccess(toolName, input) {
     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") {
@@ -12024,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) {
@@ -12070,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":
@@ -13784,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) {
@@ -13851,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
@@ -13895,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;
@@ -13907,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();
@@ -13966,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") {
@@ -14895,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();
@@ -15135,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 ────────────────────────────────────────────
@@ -15205,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") {
@@ -15250,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;
@@ -15261,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 {

package/dist/{chunk-LBB7DXOC.js → chunk-IWWBG5FI.js}

@@ -8,7 +8,7 @@ import {
   readWorkspaceBytes,
   statWorkspacePath,
   workspacePathExists
-} from "./chunk-I7QYTA2V.js";
+} from "./chunk-YNI2HFZE.js";
 import {
   reportBootMilestone
 } from "./chunk-Q4FQOJ7D.js";

package/dist/{chunk-W5INK3NE.js → chunk-WCJ6HRVU.js}

@@ -26,6 +26,9 @@ function buildSpawnArgs(input) {
     args.push("--permission-mode", "plan");
   }
   args.push("--settings", input.settingsPath);
+  if (input.disallowedTools && input.disallowedTools.length > 0) {
+    args.push("--disallowed-tools", input.disallowedTools.join(","));
+  }
   if (input.appendSystemPrompt) {
     args.push("--append-system-prompt", input.appendSystemPrompt);
   }

package/dist/{chunk-I7QYTA2V.js → chunk-YNI2HFZE.js}

@@ -1806,6 +1806,13 @@ var TurnEndToolCallSchema = z22.object({
   output: z22.string().optional(),
   timestamp: z22.string().optional()
 }).passthrough();
+var AgentTurnUsageSchema = z22.object({
+  inputTokens: z22.number(),
+  outputTokens: z22.number(),
+  cacheReadInputTokens: z22.number(),
+  cacheCreationInputTokens: z22.number(),
+  totalTokens: z22.number()
+});
 var KnownAgentEventSchema = z22.discriminatedUnion("type", [
   // ── Lifecycle / connection ────────────────────────────────────────────
   z22.object({
@@ -1845,7 +1852,11 @@ var KnownAgentEventSchema = z22.discriminatedUnion("type", [
   z22.object({
     type: z22.literal("completed"),
     summary: z22.string().optional(),
-    durationMs: z22.number().optional()
+    durationMs: z22.number().optional(),
+    /** Tokens this turn consumed, summed from the transcript's assistant
+     *  records. Optional: an older agent build sends none, and the server
+     *  then records nothing rather than zeroing the session's totals. */
+    usage: AgentTurnUsageSchema.optional()
   }).passthrough(),
   z22.object({ type: z22.literal("error"), message: z22.string() }).passthrough(),
   z22.object({ type: z22.literal("agent_typing_start") }).passthrough(),
@@ -3352,6 +3363,10 @@ var CreateProjectDecisionRequestSchema = z11.object({
   sessionId: z11.string().optional(),
   tagNames: z11.array(z11.string().min(1)).max(10).optional(),
   raisedByPr: z11.number().int().positive().optional(),
+  /** Slug or id of the card that raised the question. A link back, not a block. */
+  raisedByCard: z11.string().min(1).optional(),
+  /** Absolute deadline (ISO 8601). Wins over `deadlineHours` when both are sent. */
+  deadlineAt: z11.string().datetime({ offset: true }).optional(),
   requestingUserId: z11.string().optional()
 });
 var ListProjectDecisionsRequestSchema = z11.object({
@@ -3387,7 +3402,16 @@ var ResolveProjectDecisionRequestSchema = z11.object({
 var UpdateProjectDecisionRequestSchema = z11.object({
   projectId: z11.string(),
   decision: z11.string().min(1),
+  question: z11.string().min(1).max(200).optional(),
+  summary: z11.string().max(CARD_DESCRIPTION_MAX).optional(),
+  context: z11.string().min(1).optional(),
+  /** Accepted only while nobody has voted. */
+  options: optionsInput.optional(),
+  defaultOption: z11.number().int().min(1).max(DECISION_OPTIONS_MAX).optional(),
+  tagNames: z11.array(z11.string().min(1)).max(10).optional(),
   deadlineHours,
+  /** Absolute deadline (ISO 8601). Wins over `deadlineHours` when both are sent. */
+  deadlineAt: z11.string().datetime({ offset: true }).optional(),
   addImpactedCards: z11.array(z11.string().min(1)).max(50).optional(),
   removeImpactedCards: z11.array(z11.string().min(1)).max(50).optional(),
   status: z11.enum(["Cancelled", "Open"]).optional(),

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   WorkspaceCommandSupervisor,
   startWorkspaceCommandsAfterConnect,
   stopWorkspaceCommands
-} from "./chunk-LBB7DXOC.js";
+} from "./chunk-IWWBG5FI.js";
 import {
   PtyHarness,
   SessionRunner,
@@ -25,13 +25,13 @@ import {
   runUsageProbe,
   sampleKeyUsage,
   usesNativeUsageReporting
-} from "./chunk-XJSW42TM.js";
+} from "./chunk-HW6SHIL7.js";
 import "./chunk-37J5MMQT.js";
 import {
   inheritedEnv,
   resolvePtySpawn,
   sessionTempBase
-} from "./chunk-W5INK3NE.js";
+} from "./chunk-WCJ6HRVU.js";
 import {
   AgentConnection,
   CodespacePortVisibility,
@@ -44,7 +44,7 @@ import {
   createServiceLogger,
   fetchBootstrap,
   loadConveyorConfig
-} from "./chunk-I7QYTA2V.js";
+} from "./chunk-YNI2HFZE.js";
 import "./chunk-Q4FQOJ7D.js";
 import "./chunk-W4LZ7R6Z.js";
 import "./chunk-372R6E4C.js";
@@ -1205,7 +1205,7 @@ function wireSpawnChildren(mode, connection, supervisors, logger7) {
 
 // src/cli.ts
 if (process.argv[2] === "boot") {
-  const { runBoot } = await import("./boot-S73ZNWBJ.js");
+  const { runBoot } = await import("./boot-65PTSADA.js");
   process.exit(await runBoot(process.argv.slice(3)));
 }
 if (isLegacyEntrypointLaunch(process.env)) {
@@ -1307,7 +1307,7 @@ process.on("unhandledRejection", (reason) => {
   process.exit(1);
 });
 if (process.env.CONVEYOR_MODE === "workbench") {
-  const { startWorkbenchServer } = await import("./server-L5CQ5EJB.js");
+  const { startWorkbenchServer } = await import("./server-E6IYHSMN.js");
   const { oomWatchdogOptionsFromEnv } = await import("./oom-watchdog-PAC5OJJG.js");
   const { DEFAULT_WORKBENCH_PORT } = await import("./protocol-QBCYO4GI.js");
   const port = Number(process.env.CONVEYOR_WORKBENCH_PORT) || DEFAULT_WORKBENCH_PORT;
@@ -1458,7 +1458,7 @@ if (!RUNNER_MODES.includes(CONVEYOR_MODE)) {
   process.exit(1);
 }
 if (CONVEYOR_MODE === "serving") {
-  const { runServingSession } = await import("./serve-boot-ODH57W6I.js");
+  const { runServingSession } = await import("./serve-boot-THPACDVI.js");
   exitContext.runnerMode = "serving";
   exitContext.sessionId = process.env.CONVEYOR_SESSION_ID ?? exitContext.sessionId;
   const outcome = await runServingSession({

package/dist/index.d.ts

@@ -732,6 +732,11 @@ declare class SessionRunner {
      *  it reports pending, heartbeats go out non-idle so the workspace activity
      *  clock keeps being bumped and the reconciler can't sleep the pod mid-gate. */
     private readonly backgroundWork;
+    /** 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. */
+    private readonly scheduledWakeup;
     /** 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
@@ -782,6 +787,21 @@ declare class SessionRunner {
      * live build costs work.
      */
     private deferShutdownForLiveChild;
+    /**
+     * 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.
+     */
+    private deferShutdownForScheduledWakeup;
     /** Epoch ms of the first idle-shutdown deferral for background work in the
      *  current idle episode; null when nothing has deferred. Reset when a turn
      *  runs, so each idle episode gets its own bounded hold. */
@@ -1101,8 +1121,8 @@ declare class SessionRunner {
     /** Mirror the resolved status into the loop-lag buffer so the starvation-proof
      *  heartbeat worker reports it too. Returns what it wrote. */
     private refreshLoopStatus;
-    /** 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`. */
     private noteToolUseForBackgroundWork;
     private setState;
     /**

package/dist/index.js

@@ -1,9 +1,9 @@
 import {
   SessionRunner,
   unshallowRepo
-} from "./chunk-XJSW42TM.js";
+} from "./chunk-HW6SHIL7.js";
 import "./chunk-37J5MMQT.js";
-import "./chunk-W5INK3NE.js";
+import "./chunk-WCJ6HRVU.js";
 import {
   AgentConnection,
   GIT_TIMEOUT_MS,
@@ -17,7 +17,7 @@ import {
   stageAndCommit,
   updateRemoteToken,
   workspacePathExists
-} from "./chunk-I7QYTA2V.js";
+} from "./chunk-YNI2HFZE.js";
 import "./chunk-Q4FQOJ7D.js";
 import {
   runAuthTokenCommand,

package/dist/{serve-boot-ODH57W6I.js → serve-boot-THPACDVI.js}

@@ -1,6 +1,6 @@
 import {
   WorkspaceCommandSupervisor
-} from "./chunk-LBB7DXOC.js";
+} from "./chunk-IWWBG5FI.js";
 import {
   AgentConnection,
   CodespacePortVisibility,
@@ -11,7 +11,7 @@ import {
   createServiceLogger,
   ensureOnTaskBranch,
   loadConveyorConfig
-} from "./chunk-I7QYTA2V.js";
+} from "./chunk-YNI2HFZE.js";
 import "./chunk-Q4FQOJ7D.js";
 import "./chunk-W4LZ7R6Z.js";
 import "./chunk-IA45XHOA.js";

package/dist/{server-L5CQ5EJB.js → server-E6IYHSMN.js}

@@ -1,7 +1,7 @@
 import {
   startWorkbenchServer
-} from "./chunk-EIHZRSYI.js";
-import "./chunk-W5INK3NE.js";
+} from "./chunk-EITUTXXJ.js";
+import "./chunk-WCJ6HRVU.js";
 import "./chunk-W4LZ7R6Z.js";
 import "./chunk-372R6E4C.js";
 import "./chunk-SQM2BQ7H.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-agent",
-  "version": "11.0.23",
+  "version": "11.0.24",
   "description": "Conveyor Agent Runner v10 - PTY harness for the task chat (SDK harness for audit/project-chat). Agent-as-User architecture with BaseService patterns. Works locally too.",
   "keywords": [
     "agent",

package/skills/conveyor-plan/SKILL.md

@@ -157,6 +157,18 @@ and the order to verify in. Write it last, when you know which parts were hard.
 It is not optional and it is not a summary. It is the only channel your context
 has across the handoff, because handoffs carry the card and never the session.
 
+**Deliverables beyond the plan go on the card.** A diagram, an HTML report, a
+screenshot, or a data export the team should keep is attached with
+`mcp__conveyor__upload_attachment` — never published as a Claude artifact, which
+is an off-platform link the card cannot render. Write the file under `/tmp/`
+first (a Planner session may write there; the repo checkout stays read-only) and
+pass the caption so the file shows in the card thread rather than only in the
+Files grid. The caption field is spelled differently per surface, and both
+surfaces accept either name: in a pod pass `path` + `title`; on the local MCP
+pass `taskId` + `path` + `comment` (or `title`). An HTML deliverable must be
+self-contained — inline CSS, no `<script>`, no external assets — because the
+card serves it under `sandbox; default-src 'none'`.
+
 Size it: 1 SP default, 2 multi-file, 3 complex patterns/design, 5 hard. Larger
 → propose a pack (parent + `mcp__conveyor__create_subtask` children) instead of
 one mega-card. **Child→child ordering rides `create_subtask`/`update_subtask`'s