@rallycry/conveyor-agent 11.0.21 → 11.0.23

package/dist/{boot-Z3EBJ7GX.js → boot-S73ZNWBJ.js}

@@ -217,6 +217,30 @@ async function runPipeline(steps, ctx) {
   );
 }
 
+// src/boot/bootstrap-refusal.ts
+var BootstrapRejectedError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "BootstrapRejectedError";
+  }
+  code;
+};
+async function readRefusal(res) {
+  if (res.status < 400 || res.status >= 500) return void 0;
+  let body;
+  try {
+    body = JSON.parse(await res.text());
+  } catch {
+    return void 0;
+  }
+  const payload = body;
+  if (payload?.retryable !== false) return void 0;
+  const message = typeof payload.error === "string" ? payload.error : "bootstrap refused";
+  const code = typeof payload.code === "string" ? payload.code : void 0;
+  return new BootstrapRejectedError(`${message} (HTTP ${res.status})`, code);
+}
+
 // src/boot/poll.ts
 var BootstrapUnauthorizedError = class extends Error {
   constructor(message) {
@@ -261,6 +285,10 @@ async function pollBootstrapBundle(apiUrl, token, deps) {
     if (res?.status === 401) {
       throw new BootstrapUnauthorizedError("bootstrap token rejected (401) \u2014 pod identity invalid");
     }
+    if (res) {
+      const refusal = await readRefusal(res);
+      if (refusal) throw refusal;
+    }
     pollCount++;
     if (pollCount % PROGRESS_LOG_EVERY === 0) {
       deps.log.info(`[boot] Still waiting for bind (poll #${pollCount})...`);

package/dist/{chunk-4ZDIBDQC.js → chunk-I7QYTA2V.js}

@@ -1446,7 +1446,7 @@ ${q.question}${q.options.length ? "\n" + q.options.map((o) => `- ${o.label}: ${o
   }
 };
 
-// ../shared/dist/chunk-42BS7Y35.js
+// ../shared/dist/chunk-6NPOGQPP.js
 import { z } from "zod";
 var DEFAULT_SONNET_MODEL = "claude-sonnet-5";
 var DEFAULT_OPUS_MODEL = "claude-opus-5";
@@ -1709,6 +1709,8 @@ import { z as z7 } from "zod";
 import { z as z8 } from "zod";
 import { z as z9 } from "zod";
 import { z as z10 } from "zod";
+import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var EXTERNAL_AGENT_MESSAGE_SOURCE = "external_agent";
 var TUI_KINDS = ["claude-code", "opencode", "codex"];
 var ACHIEVEMENT_RARITIES = [
@@ -3235,135 +3237,291 @@ var CRITICAL_AUTOMATED_SOURCES = /* @__PURE__ */ new Set([
   // clear the completion guard.
   "ci_result"
 ]);
+var DECISION_STATUS_LABELS = ["Open", "Decided", "Cancelled"];
+var DECISION_OPTION_KINDS = ["current", "planned", "proposed"];
+var DECISION_VOTE_SOURCES = ["web", "slack", "discord", "agent"];
+var DECISION_OPTIONS_MIN = 2;
+var DECISION_OPTIONS_MAX = 3;
+var DECISION_OPTION_LABEL_MAX = 80;
+var DECISION_QUESTION_MAX = 200;
+var DECISION_RESOLUTION_MAX = CARD_DESCRIPTION_MAX;
+var DECISION_VOTE_REASON_MAX = CARD_DESCRIPTION_MAX;
+var DECISION_DEADLINE_MIN_HOURS = 1;
+var DECISION_DEADLINE_MAX_DAYS = 30;
+var DECISION_DEADLINE_MAX_HOURS = DECISION_DEADLINE_MAX_DAYS * 24;
+var DECISION_LIST_MAX_LIMIT = 200;
+var decisionIdSchema = z10.string().cuid("Invalid decision ID");
+var optionInputSchema = z10.object({
+  label: z10.string().min(1, "Option label is required").max(DECISION_OPTION_LABEL_MAX),
+  description: z10.string().min(1, "Describe the option as GIVEN / WHEN / THEN"),
+  kind: z10.enum(DECISION_OPTION_KINDS).optional()
+});
+var optionsArraySchema = z10.array(optionInputSchema).min(DECISION_OPTIONS_MIN, `A decision needs at least ${DECISION_OPTIONS_MIN} options`).max(
+  DECISION_OPTIONS_MAX,
+  `A decision takes at most ${DECISION_OPTIONS_MAX} options \u2014 more than that means the question is not framed yet`
+);
+var CreateDecisionRequestSchema = z10.object({
+  projectId: z10.string().cuid("Invalid project ID"),
+  /** The question, as one plain sentence. */
+  title: z10.string().min(1, "A decision needs a question").max(DECISION_QUESTION_MAX),
+  description: z10.string().max(CARD_DESCRIPTION_MAX).optional(),
+  context: z10.string().min(1, "Context is required \u2014 say why this is being asked now"),
+  options: optionsArraySchema,
+  /** 1-based position of the option that wins on silence. */
+  defaultOptionOrdinal: z10.number().int().min(1).max(DECISION_OPTIONS_MAX),
+  deadlineHours: z10.number().min(DECISION_DEADLINE_MIN_HOURS).max(DECISION_DEADLINE_MAX_HOURS).optional(),
+  /** Cards this decision blocks, by cuid or slug. */
+  impactedCardRefs: z10.array(z10.string().min(1)).max(50).optional(),
+  tagNames: z10.array(z10.string().min(1)).max(10).optional(),
+  raisedByTaskId: z10.string().min(1).optional(),
+  raisedByPrNumber: z10.number().int().positive().optional()
+});
+var VoteDecisionRequestSchema = z10.object({
+  decisionId: decisionIdSchema,
+  optionId: z10.string().cuid("Invalid option ID"),
+  reason: z10.string().max(DECISION_VOTE_REASON_MAX).optional(),
+  source: z10.enum(DECISION_VOTE_SOURCES).optional()
+});
+var RemoveDecisionVoteRequestSchema = z10.object({
+  decisionId: decisionIdSchema
+});
+var ResolveDecisionRequestSchema = z10.object({
+  decisionId: decisionIdSchema,
+  chosenOptionId: z10.string().cuid("Invalid option ID"),
+  resolution: z10.string().min(1, "A resolution is required \u2014 say what was decided").max(DECISION_RESOLUTION_MAX),
+  resolutionNotes: z10.string().optional()
+});
+var CancelDecisionRequestSchema = z10.object({
+  decisionId: decisionIdSchema,
+  /** Why it is being dropped. Posted to the decision thread. */
+  reason: z10.string().max(DECISION_RESOLUTION_MAX).optional()
+});
+var ReopenDecisionRequestSchema = z10.object({
+  decisionId: decisionIdSchema,
+  deadlineHours: z10.number().min(DECISION_DEADLINE_MIN_HOURS).max(DECISION_DEADLINE_MAX_HOURS).optional()
+});
+var UpdateDecisionRequestSchema = z10.object({
+  decisionId: decisionIdSchema,
+  title: z10.string().min(1).max(200).optional(),
+  description: z10.string().max(CARD_DESCRIPTION_MAX).optional(),
+  context: z10.string().min(1).optional(),
+  deadlineAt: z10.string().datetime().optional(),
+  /** Only accepted while the decision has zero votes. */
+  options: optionsArraySchema.optional(),
+  defaultOptionOrdinal: z10.number().int().min(1).max(DECISION_OPTIONS_MAX).optional(),
+  addImpactedCardRefs: z10.array(z10.string().min(1)).max(50).optional(),
+  removeImpactedCardIds: z10.array(z10.string().min(1)).max(50).optional()
+});
+var GetDecisionRequestSchema = z10.object({
+  /** cuid or slug. A slug needs `projectId` to resolve unambiguously. */
+  decisionId: z10.string().min(1),
+  projectId: z10.string().cuid().optional()
+});
+var ListDecisionsRequestSchema = z10.object({
+  projectId: z10.string().cuid("Invalid project ID"),
+  status: z10.enum(DECISION_STATUS_LABELS).optional(),
+  /** Tag name, not id — an agent knows the tag it is working under. */
+  tag: z10.string().min(1).optional(),
+  /** Decisions that this card is blocked by (cuid or slug). */
+  cardId: z10.string().min(1).optional(),
+  query: z10.string().min(1).optional(),
+  limit: z10.number().int().min(1).max(DECISION_LIST_MAX_LIMIT).optional()
+});
+var optionInput = z11.object({
+  label: z11.string().min(1).max(DECISION_OPTION_LABEL_MAX),
+  description: z11.string().min(1),
+  kind: z11.enum(DECISION_OPTION_KINDS).optional()
+});
+var optionsInput = z11.array(optionInput).min(DECISION_OPTIONS_MIN).max(DECISION_OPTIONS_MAX);
+var deadlineHours = z11.number().min(DECISION_DEADLINE_MIN_HOURS).max(DECISION_DEADLINE_MAX_HOURS).optional();
+var CreateProjectDecisionRequestSchema = z11.object({
+  projectId: z11.string(),
+  question: z11.string().min(1).max(200),
+  summary: z11.string().max(CARD_DESCRIPTION_MAX).optional(),
+  context: z11.string().min(1),
+  options: optionsInput,
+  defaultOption: z11.number().int().min(1).max(DECISION_OPTIONS_MAX),
+  deadlineHours,
+  impactedCards: z11.array(z11.string().min(1)).max(50).optional(),
+  /**
+   * Pod surface only: also block the card this session is working on. The
+   * session's task id is resolved SERVER-side from `sessionId` — a
+   * client-supplied card id would let a pod block any card in the project.
+   */
+  includeCurrentCard: z11.boolean().optional(),
+  sessionId: z11.string().optional(),
+  tagNames: z11.array(z11.string().min(1)).max(10).optional(),
+  raisedByPr: z11.number().int().positive().optional(),
+  requestingUserId: z11.string().optional()
+});
+var ListProjectDecisionsRequestSchema = z11.object({
+  projectId: z11.string(),
+  status: z11.enum(DECISION_STATUS_LABELS).optional(),
+  tag: z11.string().min(1).optional(),
+  card: z11.string().min(1).optional(),
+  query: z11.string().min(1).optional(),
+  limit: z11.number().int().min(1).max(DECISION_LIST_MAX_LIMIT).optional(),
+  requestingUserId: z11.string().optional()
+});
+var GetProjectDecisionRequestSchema = z11.object({
+  projectId: z11.string(),
+  decision: z11.string().min(1),
+  requestingUserId: z11.string().optional()
+});
+var VoteProjectDecisionRequestSchema = z11.object({
+  projectId: z11.string(),
+  decision: z11.string().min(1),
+  /** An option id, or its 1-based position. */
+  option: z11.string().min(1),
+  reason: z11.string().max(CARD_DESCRIPTION_MAX).optional(),
+  requestingUserId: z11.string().optional()
+});
+var ResolveProjectDecisionRequestSchema = z11.object({
+  projectId: z11.string(),
+  decision: z11.string().min(1),
+  option: z11.string().min(1),
+  resolution: z11.string().min(1).max(DECISION_RESOLUTION_MAX),
+  notes: z11.string().optional(),
+  requestingUserId: z11.string().optional()
+});
+var UpdateProjectDecisionRequestSchema = z11.object({
+  projectId: z11.string(),
+  decision: z11.string().min(1),
+  deadlineHours,
+  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(),
+  requestingUserId: z11.string().optional()
+});
 var MEETING_CHECKLIST_TITLE_MAX = 300;
 var MEETING_TRANSCRIPT_MAX_CHARS = 2e6;
 var MEETING_TITLE_MAX = 200;
 var MEETING_OCCURRED_AT_MIN_YEAR = 2e3;
 var MEETING_OCCURRED_AT_MAX_FUTURE_MS = 48 * 60 * 60 * 1e3;
 var OCCURRED_AT_RANGE_MESSAGE = `occurredAt must be a real date: no earlier than ${MEETING_OCCURRED_AT_MIN_YEAR}, and no more than 48 hours in the future.`;
-var MeetingOccurredAtSchema = z10.string().datetime().refine((value) => {
+var MeetingOccurredAtSchema = z12.string().datetime().refine((value) => {
   const ms = Date.parse(value);
   if (Number.isNaN(ms)) return false;
   if (ms > Date.now() + MEETING_OCCURRED_AT_MAX_FUTURE_MS) return false;
   return new Date(ms).getUTCFullYear() >= MEETING_OCCURRED_AT_MIN_YEAR;
 }, OCCURRED_AT_RANGE_MESSAGE);
-var CreateMeetingFromTranscriptRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  rawText: z10.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
-  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
+var CreateMeetingFromTranscriptRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  rawText: z12.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
+  title: z12.string().min(1).max(MEETING_TITLE_MAX).optional(),
   /** ISO 8601. Defaults to now when the source carries no date. */
   occurredAt: MeetingOccurredAtSchema.optional(),
   /** Override auto-detection. Rarely needed; detection handles the three formats. */
-  format: z10.enum(["text", "vtt", "srt"]).optional(),
-  source: z10.enum(["manual", "slack"]).optional()
+  format: z12.enum(["text", "vtt", "srt"]).optional(),
+  source: z12.enum(["manual", "slack"]).optional()
 });
-var GetMeetingRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid()
+var GetMeetingRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid()
 });
-var UpdateMeetingRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid(),
-  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
+var UpdateMeetingRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  title: z12.string().min(1).max(MEETING_TITLE_MAX).optional(),
   occurredAt: MeetingOccurredAtSchema.optional()
 });
-var RegenerateMeetingSummaryRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid()
+var RegenerateMeetingSummaryRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid()
 });
-var DeleteMeetingRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid()
+var DeleteMeetingRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid()
 });
-var checklistTitle = z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX);
-var ListMeetingChecklistRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid()
+var checklistTitle = z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX);
+var ListMeetingChecklistRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid()
 });
-var AddMeetingChecklistItemsRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid(),
-  items: z10.array(z10.object({ title: checklistTitle })).min(1).max(50)
+var AddMeetingChecklistItemsRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  items: z12.array(z12.object({ title: checklistTitle })).min(1).max(50)
 });
-var UpdateMeetingChecklistItemRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid(),
-  itemId: z10.string().cuid(),
+var UpdateMeetingChecklistItemRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  itemId: z12.string().cuid(),
   title: checklistTitle.optional(),
-  ordinal: z10.number().int().min(0).optional(),
+  ordinal: z12.number().int().min(0).optional(),
   /** Explicit null clears the link; undefined leaves it alone. */
-  linkedTaskId: z10.string().cuid().nullable().optional()
+  linkedTaskId: z12.string().cuid().nullable().optional()
 }).refine(
   (v) => v.title !== void 0 || v.ordinal !== void 0 || v.linkedTaskId !== void 0,
   "Pass at least one of title, ordinal, or linkedTaskId."
 );
-var DeleteMeetingChecklistItemRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid(),
-  itemId: z10.string().cuid()
-});
-var SetMeetingChecklistItemCheckedRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid(),
-  itemId: z10.string().cuid(),
-  checked: z10.boolean(),
+var DeleteMeetingChecklistItemRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  itemId: z12.string().cuid()
+});
+var SetMeetingChecklistItemCheckedRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  itemId: z12.string().cuid(),
+  checked: z12.boolean(),
   /** Attach the card in the same call that ticks the item. */
-  linkedTaskId: z10.string().cuid().nullable().optional()
+  linkedTaskId: z12.string().cuid().nullable().optional()
 });
-var ListMeetingsRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  limit: z10.number().int().min(1).max(50).optional(),
-  search: z10.string().max(200).optional()
+var ListMeetingsRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  limit: z12.number().int().min(1).max(50).optional(),
+  search: z12.string().max(200).optional()
 });
-var ReadMeetingTranscriptRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid(),
-  offset: z10.number().int().min(0).optional(),
-  limit: z10.number().int().min(1).max(500).optional()
+var ReadMeetingTranscriptRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  offset: z12.number().int().min(0).optional(),
+  limit: z12.number().int().min(1).max(500).optional()
 });
 var MEETING_SUMMARY_MAX_CHARS = 5e4;
-var AddProjectMeetingChecklistItemsRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid(),
-  items: z10.array(z10.object({ title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX) })).min(1).max(50),
-  requestingUserId: z10.string().optional()
-});
-var CheckProjectMeetingChecklistItemRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid(),
-  title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
-  checked: z10.boolean(),
+var AddProjectMeetingChecklistItemsRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  items: z12.array(z12.object({ title: z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX) })).min(1).max(50),
+  requestingUserId: z12.string().optional()
+});
+var CheckProjectMeetingChecklistItemRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  title: z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  checked: z12.boolean(),
   /** Card id or slug. Resolved server-side and required to be in the project. */
-  linkedTask: z10.string().min(1).optional(),
-  requestingUserId: z10.string().optional()
-});
-var EditProjectMeetingChecklistItemRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid(),
-  title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
-  newTitle: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
-  requestingUserId: z10.string().optional()
-});
-var RemoveProjectMeetingChecklistItemRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid(),
-  title: z10.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
-  requestingUserId: z10.string().optional()
-});
-var CreateProjectMeetingRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  rawText: z10.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
-  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
+  linkedTask: z12.string().min(1).optional(),
+  requestingUserId: z12.string().optional()
+});
+var EditProjectMeetingChecklistItemRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  title: z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  newTitle: z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  requestingUserId: z12.string().optional()
+});
+var RemoveProjectMeetingChecklistItemRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  title: z12.string().min(1).max(MEETING_CHECKLIST_TITLE_MAX),
+  requestingUserId: z12.string().optional()
+});
+var CreateProjectMeetingRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  rawText: z12.string().min(1).max(MEETING_TRANSCRIPT_MAX_CHARS),
+  title: z12.string().min(1).max(MEETING_TITLE_MAX).optional(),
   occurredAt: MeetingOccurredAtSchema.optional(),
-  requestingUserId: z10.string().optional()
+  requestingUserId: z12.string().optional()
 });
-var UpdateProjectMeetingRequestSchema = z10.object({
-  projectId: z10.string().cuid(),
-  meetingId: z10.string().cuid(),
-  title: z10.string().min(1).max(MEETING_TITLE_MAX).optional(),
+var UpdateProjectMeetingRequestSchema = z12.object({
+  projectId: z12.string().cuid(),
+  meetingId: z12.string().cuid(),
+  title: z12.string().min(1).max(MEETING_TITLE_MAX).optional(),
   occurredAt: MeetingOccurredAtSchema.optional(),
-  summary: z10.string().min(1).max(MEETING_SUMMARY_MAX_CHARS).optional(),
-  requestingUserId: z10.string().optional()
+  summary: z12.string().min(1).max(MEETING_SUMMARY_MAX_CHARS).optional(),
+  requestingUserId: z12.string().optional()
 }).refine(
   (v) => v.title !== void 0 || v.occurredAt !== void 0 || v.summary !== void 0,
   "Pass at least one of title, occurredAt, or summary."
@@ -3738,13 +3896,17 @@ var CARD_TYPE_SURFACE = {
   task: "board",
   chat: "board",
   incident: "report",
-  suggestion: "report"
+  suggestion: "report",
+  // Decisions get their own surface: they are neither built on the board nor
+  // triaged in the report feeds. Cards → Decisions is their only feed.
+  decision: "decision"
 };
 var surfaceTypes = (surface) => Object.keys(CARD_TYPE_SURFACE).filter(
   (type) => CARD_TYPE_SURFACE[type] === surface
 );
 var BOARD_CARD_TYPES = surfaceTypes("board");
 var REPORT_CARD_TYPES = surfaceTypes("report");
+var DECISION_CARD_TYPES = surfaceTypes("decision");
 
 // src/runner/git-run.ts
 import { execFile } from "child_process";

package/dist/{chunk-5WQHDGIW.js → chunk-LBB7DXOC.js}

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

package/dist/{chunk-WPXSZKMS.js → chunk-XJSW42TM.js}

@@ -91,7 +91,7 @@ import {
   statWorkspacePath,
   updateRemoteToken,
   verifyGitCredential
-} from "./chunk-4ZDIBDQC.js";
+} from "./chunk-I7QYTA2V.js";
 import {
   registerBootMilestoneSocketFallback,
   reportBootMilestone
@@ -6338,8 +6338,9 @@ Working rules:`,
     `- Read a file before your first Write/Edit to it, and batch multiple changes to the same file into a single call instead of many sequential edits.`,
     `- To learn what calls a symbol or where it lives, query the prebuilt code graph before grepping: \`graphify query "<SymbolName>"\` from the repo root. Query a SYMBOL, never a sentence \u2014 \`graphify query "resolveTaskBaseBranch"\` returns the definition plus every call site, while "how does a task get its base branch" seeds unrelated start nodes and returns test files and loggers. Don't know the symbol yet? Grep for the name first, then query it: grep finds names, the graph finds relationships. \`No matching nodes found\` means "not in this graph" (it is prebuilt, so very recent code is absent), NOT "not in the codebase" \u2014 fall back to \`git grep\`. Skip all of this if \`graphify-out/graph.json\` is not present.`,
     `- 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.`,
-    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 the workspace stays awake for as long as background work is outstanding, so a backgrounded gate will not be killed by an idle sleep. For the final pre-PR gate a bounded foreground run (\`timeout 590 <gate>\` with Bash \`timeout: 600000\`) is still preferred as defense in depth \u2014 it survives a pod resume, which a background job does not. 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.` : `- Ending your turn with NO tool call is the correct way to wait, and it is safe: the pod stays alive and the next notification re-invokes you. 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.`,
+    `- 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.`,
     `
 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.`,
@@ -6859,7 +6860,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(), {
@@ -7552,6 +7553,235 @@ 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's id, slug, and url.`,
+    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" })
+      )
+    }
+  },
+  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" })
+      )
+    }
+  }
+});
+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.`,
+    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 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.",
+    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: 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.",
+    fields: {
+      decision: f.string({ min: 1, desc: "Decision slug or id" }),
+      deadline_hours: f.optional(f.number({ desc: "New deadline, in hours from now. 1 to 720." })),
+      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: extend 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" }),
+      deadlineHours: f.optional(
+        f.number({ min: 1, max: 720, desc: "New deadline, in hours from now" })
+      ),
+      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: {
@@ -8212,6 +8442,7 @@ var TOOL_CONTRACTS = Object.fromEntries(
     ...subtasksContracts,
     ...attachmentsContracts,
     ...suggestionsContracts,
+    ...decisionsContracts,
     ...pullRequestContracts,
     ...integrationsContracts,
     ...driveContracts,
@@ -10464,6 +10695,143 @@ ${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
+        });
+        const refused = res.refused.length > 0 ? `
+
+Not linked: ${res.refused.map((r) => `${r.ref} (${r.reason})`).join("; ")}` : "";
+        return textResult(
+          `Raised decision ${res.slug} \u2014 ${res.url}
+Blocking ${res.impactedLinked.length} card(s).${refused}`
+        );
+      } 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,
+          deadlineHours: input.deadline_hours,
+          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;
@@ -10473,6 +10841,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)] : []
@@ -11482,6 +11853,8 @@ 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 };
@@ -11531,6 +11904,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) {
@@ -14075,8 +14451,8 @@ var SessionRunner = class _SessionRunner {
         "[conveyor-agent] Completed \u2014 entering dormant idle (staying connected)\n"
       );
     }
+    this.pendingMessages = this.pendingMessages.filter((msg) => msg.source === "pty_passive");
     await this.flushWipNow("WIP: turn complete");
-    this.pendingMessages.length = 0;
     if (this._state !== "idle") await this.setState("idle");
     const remainingMs = Math.max(0, this.dormantDeadline - Date.now());
     this.lifecycle.startDormantTimer(remainingMs);

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   WorkspaceCommandSupervisor,
   startWorkspaceCommandsAfterConnect,
   stopWorkspaceCommands
-} from "./chunk-5WQHDGIW.js";
+} from "./chunk-LBB7DXOC.js";
 import {
   PtyHarness,
   SessionRunner,
@@ -25,7 +25,7 @@ import {
   runUsageProbe,
   sampleKeyUsage,
   usesNativeUsageReporting
-} from "./chunk-WPXSZKMS.js";
+} from "./chunk-XJSW42TM.js";
 import "./chunk-37J5MMQT.js";
 import {
   inheritedEnv,
@@ -44,7 +44,7 @@ import {
   createServiceLogger,
   fetchBootstrap,
   loadConveyorConfig
-} from "./chunk-4ZDIBDQC.js";
+} from "./chunk-I7QYTA2V.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-Z3EBJ7GX.js");
+  const { runBoot } = await import("./boot-S73ZNWBJ.js");
   process.exit(await runBoot(process.argv.slice(3)));
 }
 if (isLegacyEntrypointLaunch(process.env)) {
@@ -1458,7 +1458,7 @@ if (!RUNNER_MODES.includes(CONVEYOR_MODE)) {
   process.exit(1);
 }
 if (CONVEYOR_MODE === "serving") {
-  const { runServingSession } = await import("./serve-boot-IRRHYA7W.js");
+  const { runServingSession } = await import("./serve-boot-ODH57W6I.js");
   exitContext.runnerMode = "serving";
   exitContext.sessionId = process.env.CONVEYOR_SESSION_ID ?? exitContext.sessionId;
   const outcome = await runServingSession({

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   SessionRunner,
   unshallowRepo
-} from "./chunk-WPXSZKMS.js";
+} from "./chunk-XJSW42TM.js";
 import "./chunk-37J5MMQT.js";
 import "./chunk-W5INK3NE.js";
 import {
@@ -17,7 +17,7 @@ import {
   stageAndCommit,
   updateRemoteToken,
   workspacePathExists
-} from "./chunk-4ZDIBDQC.js";
+} from "./chunk-I7QYTA2V.js";
 import "./chunk-Q4FQOJ7D.js";
 import {
   runAuthTokenCommand,

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-agent",
-  "version": "11.0.21",
+  "version": "11.0.23",
   "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-build/SKILL.md

@@ -215,6 +215,27 @@ behavior — do not go looking for why "unrelated" tests are running.
 > more broadly; if it does, let CI finish before merging. Confirm which case
 > you are in rather than assuming, since the two lead to opposite behavior.
 
+## A plan that turns on an unsettled question
+
+A plan you cannot execute correctly because a product choice was never made is
+not a blocker by itself. Check `list_decisions(card: "<slug>")` and the owning
+tag's overview first — the answer is often already there, and citing it is the
+whole point of the type. When it genuinely is not:
+
+- **Most of the time, decide and say so.** Write the choice into the plan as a
+  GIVEN / WHEN / THEN line under "Assumed behaviours" and keep building. A
+  reviewer who disagrees says so, and it costs one comment.
+- **Raise a decision when the answer changes what you build** and getting it
+  wrong means rework rather than a follow-up commit. `create_decision` blocks
+  this card by default, so proceed on the decision's default option and mark
+  the plan `Planned: <default> pending <decision url>` — the answer is written
+  back onto this card's plan when it settles.
+- **Park only when building on the default would be thrown away.** That is the
+  Blocked path below.
+
+The bar, and how to write options somebody can actually choose between, is in
+[../conveyor-plan/references/product-decisions.md](../conveyor-plan/references/product-decisions.md).
+
 ## Not every task ends in a PR
 
 `create_pull_request` is for work that changes code. Plenty of cards don't:

package/skills/conveyor-consensus/SKILL.md

@@ -30,7 +30,8 @@ Announce a one-line plan naming the sources you found, then sweep. **Say what yo
 | Source | How |
 | ------ | --- |
 | Work channels | `read_channel_messages` per registered readable channel, paging back with `olderCursor` until the window covers the question. `authorIsBot` separates the team's discussion from Conveyor's own card feed — check it before treating a message as a teammate's. Read thread replies (`threadTs`) where a thread carries the argument. |
-| Conveyor cards | `search_tasks` with ALL `typeFilters` (task, incident, suggestion) and several keyword variants — the term, the term plus symptom words, the adjacent nouns people actually use. Incidents carry fingerprint dedup, so an incident's upvote count is itself a frequency signal. Check whether a decision card already exists; the doc is usually its input. |
+| Conveyor cards | `search_tasks` with ALL `typeFilters` (task, incident, suggestion) and several keyword variants — the term, the term plus symptom words, the adjacent nouns people actually use. Incidents carry fingerprint dedup, so an incident's upvote count is itself a frequency signal. |
+| Decisions | `list_decisions` — open ones are the questions on the table, Decided ones carry their resolution and are the project's own record of what it already settled. A verdict that contradicts a Decided decision has to say so and say why. `list_project_integrations` reports `decisions.openCount` / `decidedCount`, so you know whether there is a log here before you search it. |
 | Tags | `list_tags` then `get_tag` on the relevant ones — the overview is the project's own domain vocabulary, and it names the subsystems your categories should line up with. |
 | Card chat | `read_task_chat` on the cards the search surfaced. The argument usually lives in the chat, not the description. |
 | Meetings | If the meeting tools exist, list and read the ones in the window. A transcript is the densest source of "what people actually said" you will find. |
@@ -83,6 +84,48 @@ Chart rules that repeatedly matter: plain div/CSS charts over JS; one strong cha
 4. **Local sessions may also publish an Artifact** for a shareable URL, and `SendUserFile` the HTML — both are additive. In a pod neither exists; the attachment is the deliverable.
 5. **Revisions re-upload to the SAME card.** The doc is living; never fork it into `report-v2.html`.
 
+## Decision mode
+
+When the argument IS a decision card — the user named one, or the sweep found
+an open decision that this question is about — the shape changes. The doc is
+not a survey of opinion; it is the input to settling a specific question that
+has options, a deadline, and a default that wins if nobody acts.
+
+**Sources, in place of the Phase 1 table:**
+
+| Source | How |
+| ------ | --- |
+| The decision | `get_decision` — the context, every option's GIVEN / WHEN / THEN, every vote with who cast it and why, the running tally, and the cards it blocks. |
+| The thread | `read_task_chat` on the decision. The Slack and Discord replies already mirror here, so this is the whole discussion in one read. |
+| The impacted cards | Their plans say what each option would cost to build. A clean option that nobody can implement is not the cheap one. |
+| Everything else | The ordinary sweep above, scoped to the question. |
+
+**Weigh reasons, not counts.** Two people giving the same reason are one
+argument. A single vote with a concrete failure case outranks three with none.
+Say so explicitly in the verdict — a decision settled on a head count that
+contradicted the reasoning is the thing this mode exists to prevent.
+
+**Then settle it, in this order:**
+
+1. Attach the verdict HTML. **Where it lands depends on the surface**, and the
+   difference matters: a local MCP session's `upload_attachment` takes a
+   `taskId`, so send it to the DECISION card, titled with the question. The
+   in-pod tool takes no card argument and always posts to the session's own
+   card — so in a pod, attach it there and put the link in the resolution
+   notes rather than pretending it reached the decision.
+2. `resolve_decision` with the winning option, a resolution of one or two
+   plain sentences (255 characters), and `notes` linking wherever the
+   attachment actually landed.
+
+Step 2 is what makes it real: the resolution is written into the plan and the
+chat of every card the decision blocked and into the owning tags' overviews,
+and those cards become startable. Do not stop at the doc.
+
+**If the evidence does not settle it**, say that and do not resolve. Extend the
+deadline with `update_decision` and post what would settle it. A verdict of
+"this needs one more data point, and here is which" is a real answer; picking
+an option to look decisive is not.
+
 ## Phase 5: the consensus loop
 
 The doc is the midpoint, not the end. Expect and serve:

package/skills/conveyor-plan/SKILL.md

@@ -121,6 +121,17 @@ Ask the user only decisions that change the plan's shape — scope cuts, UX
 choices, irreversible tradeoffs. Batch them in one round; never drip. Facts
 the repo can answer are yours to find, not theirs.
 
+**Search the decision log first, and raise one when the user is not there.**
+`list_decisions(status: "Decided", tag: "<tag>")` often answers the question
+outright — an answered decision is the answer, and re-asking it is the waste
+this exists to stop. When it does not, and you are running headless, prefer
+`create_decision` over blocking on `AskUserQuestion`: a decision has a
+deadline, so it settles on its default rather than stalling, and it links the
+cards it blocks. Most forks are not decisions at all — see
+[references/product-decisions.md](references/product-decisions.md) for the bar,
+how to write options a person can actually choose between, and how to keep
+building while one is open.
+
 ## Phase 3 — Draft the plan
 
 Use the plan format in [references/plan-format.md](references/plan-format.md):

package/skills/conveyor-plan/references/product-decisions.md

@@ -0,0 +1,103 @@
+# Product decisions
+
+A product decision is a fork the plan cannot be right without — where two
+answers lead to two different, both-defensible builds, and picking one silently
+means somebody finds out at review. Conveyor has a card type for it:
+`create_decision` raises one with two or three options, a default, and a
+deadline; `list_decisions` finds the answer next time.
+
+Shared by the plan, triage, build, and review skills. The rules are the same
+wherever you are.
+
+## 1. Search before you ask
+
+A decision that was settled once must never be re-litigated. Before planning
+anything in an area:
+
+1. Read the owning tag's overview (`get_tag`) — a settled decision is written
+   into a `## Decisions` section there.
+2. `list_decisions(status: "Decided", tag: "<tag>")` — every row carries its
+   resolution, so the list IS the decision log.
+3. `list_decisions(card: "<slug>")` — what is blocking this card right now.
+
+Cite what you find. "We decided this on 2026-09-19: <resolution>" ends the
+question; re-opening it without new information wastes everybody's time.
+
+## 2. Most forks are not decisions
+
+The common case is an assumption you can simply state. Write it in the plan
+under **Assumed behaviours**, one GIVEN / WHEN / THEN line each:
+
+```
+## Assumed behaviours
+- GIVEN a decision with no votes, WHEN its deadline passes, THEN the default option wins.
+```
+
+A reviewer who disagrees says so, and it costs one comment. That is cheaper
+than a card, a deadline, and three people's attention.
+
+Raise a decision only when **all** of these hold:
+
+- Two or three options are genuinely defensible — you cannot pick on merit.
+- Getting it wrong means rework, not a follow-up commit.
+- Somebody other than you has to live with the answer.
+
+## 3. Writing one that is answerable
+
+- **The question is one plain sentence**, ending in a question mark. If it
+  needs two, it is two decisions.
+- **Two or three options.** More than three means the question is not framed
+  yet: narrow it, or split it.
+- **Each option is GIVEN / WHEN / THEN** — what the product does, concretely,
+  if this option wins. "Option B: use a queue" is not an option; "GIVEN a
+  second build request, WHEN one is already running, THEN it queues rather
+  than being refused" is.
+- **Mark the status quo.** The option describing what the code does today gets
+  `kind: "current"`; an already-agreed-but-unbuilt one gets `kind: "planned"`.
+  A reader six months later needs to know whether the winner was a change.
+- **Name the default and what it costs if wrong.** The default wins on
+  silence. If silence would be dangerous, say so in the context — and set a
+  shorter deadline.
+- **Link the cards it blocks.** They cannot start until it settles, and they
+  un-block the moment it does. In a pod this includes your own card by
+  default.
+- **Tag it.** The settled answer is written into each tag's overview, which is
+  how the next agent finds it without knowing the decision exists.
+
+## 4. Keep moving
+
+Raising a decision is not a reason to stop. Either:
+
+- **Proceed on the default.** Mark the plan: `Planned: <default option>
+  pending <decision url>`. If the decision settles differently, the write-back
+  lands on this card's plan and the card is un-blocked with the correct answer.
+- **Park**, per the parked protocol in
+  `conveyor-build/references/pack-path.md`, when building on the default would
+  be actively unsafe or would be thrown away.
+
+Never sit idle waiting for a vote.
+
+## 5. Settling one
+
+`resolve_decision` is not a formality. The resolution is written into the plan
+and the chat of every card the decision blocked, and into the overview of every
+tag it carries — and those cards become startable. So:
+
+- Write the resolution as one or two plain sentences a non-engineer can read.
+  A reader months later should not have to open the thread.
+- Weigh the reasons, not the count. Two people with the same reason are one
+  argument.
+- Put the reasoning in `notes`, and link any verdict attachment there.
+
+**A reviewer does not settle decisions.** A review runs against a diff that
+already exists. If the diff turns on an unsettled decision, say so on the PR
+and cite it — `resolve_decision` is refused in review mode for that reason.
+
+## 6. When nobody answers
+
+At the deadline, the sweeper settles it: the plurality winner, or the default
+on a tie or an empty ballot, stamped `resolvedHow: "deadline"`. Silence becomes
+a decision rather than a stall. A reminder lands in the thread a day before.
+
+That is why the default is required, and why it has to be the answer you can
+live with.

package/skills/conveyor-review/SKILL.md

@@ -115,6 +115,17 @@ You have write access. Use it in proportion:
 
 Fixing something you do not fully understand is worse than flagging it.
 
+**A finding that turns on a product choice is neither.** When the diff is
+defensible and the disagreement is really "should the product do X or Y", check
+`list_decisions` first: if it was settled, cite the resolution and the diff is
+either right or wrong on the record. If it was never settled, say so in the
+verdict and name the fork — do NOT settle it yourself. `resolve_decision` is
+refused in review mode for that reason: a review runs on a fixed budget against
+a diff that already exists, and settling a decision writes that answer into
+every card it was blocking. Raising one is fine if the fork is real; the author
+or a moderator settles it. See
+[../conveyor-plan/references/product-decisions.md](../conveyor-plan/references/product-decisions.md).
+
 ## The verdict
 
 > **Environment — the tools differ, and only one pair exists per surface.**

package/skills/conveyor-triage/SKILL.md

@@ -144,6 +144,14 @@ is still unknown — including what evidence would resolve it. Then move it to
 `Open`. "Needs a repro with the console open" is an actionable handoff;
 "couldn't reproduce" is not.
 
+**When the unknown is a product choice, not missing evidence**, the handoff is
+a decision rather than a triage note. "The code does X, the reporter expected
+Y, and both are defensible" is not something more logs will settle — raise it
+with `create_decision`, two or three options written GIVEN / WHEN / THEN, and
+link this card as impacted so it un-blocks the moment the question is answered.
+See
+[../conveyor-plan/references/product-decisions.md](../conveyor-plan/references/product-decisions.md).
+
 **Cancelling:** explain the actual behavior, then cancel.
 
 ## 7. File at least one suggestion — always

package/skills/conveyor-workflows/SKILL.md

@@ -38,9 +38,22 @@ and let Conveyor's own automation do the linking.
   it (post your context to its chat) rather than forking a duplicate.
 - **Classify**: buildable work → `mcp__conveyor__create_task`; an
   idea/improvement you are NOT committing to build →
-  `mcp__conveyor__create_suggestion`; incidents (production breakage) are
-  filed by monitoring and users through Conveyor's incident tooling — you
-  will usually *work* incident cards, not create them.
+  `mcp__conveyor__create_suggestion`; a product fork that has to be settled
+  before the work can be planned correctly → `mcp__conveyor__create_decision`;
+  incidents
+  (production breakage) are filed by monitoring and users through Conveyor's
+  incident tooling — you will usually *work* incident cards, not create them.
+- **Decisions**: a decision card holds one question, two or three options
+  written GIVEN / WHEN / THEN, a default that wins on silence, and a deadline.
+  It BLOCKS the cards it names until it settles, and un-blocks them the moment
+  it does — the answer is written into each of their plans and into the owning
+  tags' overviews, so the next agent finds it without knowing the decision
+  existed. Search with `mcp__conveyor__list_decisions` BEFORE planning in an
+  area: a settled
+  decision is the answer, and re-asking it is the waste the type exists to
+  stop. Most forks are not decisions — an assumption you can simply state
+  belongs in the plan as a GIVEN / WHEN / THEN line. The full bar is in
+  [../conveyor-plan/references/product-decisions.md](../conveyor-plan/references/product-decisions.md).
 - **Mechanics**: `create_task` takes the title, description, `plan`
   (markdown), and optional status/tags; cards start in `Planning`. Every
   status change you make goes through `mcp__conveyor__update_task`