@rallycry/conveyor-agent 11.0.0 → 11.0.2

package/dist/{chunk-PEEGCZAR.js → chunk-QETNCXIR.js}

@@ -7091,8 +7091,11 @@ function formatTaskFile(file) {
 }
 function formatChatHistory(chatHistory, limit) {
   const relevant = chatHistory.slice(-(limit ?? PM_CHAT_HISTORY_LIMIT));
-  const parts = [`
-## Recent Chat Context`];
+  const parts = [
+    `
+## New Messages`,
+    `Posted since this card's last agent turn. For the rest of the conversation call \`mcp__conveyor__read_task_chat\`.`
+  ];
   for (const msg of relevant) {
     const sender = msg.userName ?? msg.role;
     parts.push(`[${sender}]: ${msg.content}`);
@@ -7703,6 +7706,9 @@ function truncatePlanForPrompt(plan) {
 }
 
 // src/execution/pm-relaunch-instructions.ts
+function branchLine(context) {
+  return `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`;
+}
 function resolvePmRelaunchIntent(context, isAuto, agentMode) {
   switch (agentMode) {
     case "building":
@@ -7725,24 +7731,14 @@ function buildRelaunchMessageSummary(context, lastAgentIdx) {
     ...newMessages.map((m) => `[${m.userName ?? "user"}]: ${m.content}`)
   ];
 }
-function buildPmBuildRelaunchParts(context, isAuto) {
-  const parts = [
+function buildPmBuildRelaunchParts(context) {
+  return [
     `
-Your plan has been approved. Begin implementing it now.`,
-    `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`,
-    `Start by reading the relevant source files mentioned in the plan, then write code.`,
+Your plan has been approved \u2014 you are the Builder on this card now.`,
+    ...buildSkillInvocation("/conveyor-build"),
+    branchLine(context),
     `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI.`
   ];
-  if (isAuto) {
-    parts.push(
-      `
-CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or go idle without making code changes.`,
-      `Your FIRST action must be reading source files from the plan, then immediately writing code.`,
-      `Do NOT summarize the plan or say "ready to implement" \u2014 start implementing.`,
-      `If you are genuinely blocked, explain the specific blocker \u2014 do not go idle silently.`
-    );
-  }
-  return parts;
 }
 function buildPmReviewRelaunchParts() {
   return [
@@ -7754,20 +7750,21 @@ Resume reviewing and coordinating this task.`,
     `Do not implement code directly or create a new PR from the PM review session.`
   ];
 }
-function buildPmAutoWithPlanRelaunchParts() {
+function buildPmAutoWithPlanRelaunchParts(context) {
   return [
     `
-You are in auto mode. A plan already exists for this task.`,
-    `Begin implementing it now \u2014 refine story points, title, and tags via update_task_properties if they look like placeholders.`,
-    `Do NOT wait for team input \u2014 proceed autonomously.`
+A plan already exists for this card \u2014 you are the Builder on it.`,
+    ...buildSkillInvocation("/conveyor-build"),
+    branchLine(context)
   ];
 }
-function buildPmAutoPlanningRelaunchParts() {
+function buildPmAutoPlanningRelaunchParts(context) {
   return [
     `
-You are in auto mode. Continue building autonomously.`,
-    `No plan is saved on this card yet \u2014 save a concise plan with update_task before writing further code; never pause or wait for approval.`,
-    `Do NOT wait for team input \u2014 proceed autonomously.`
+No plan is saved on this card yet.`,
+    ...buildSkillInvocation("/conveyor-plan"),
+    `Save it with update_task, then continue with \`/conveyor-build\`.`,
+    branchLine(context)
   ];
 }
 function buildPmWaitForTeamRelaunchParts() {
@@ -7781,10 +7778,10 @@ function buildPmRelaunchParts(context, lastAgentIdx, isAuto, agentMode) {
   const parts = buildRelaunchMessageSummary(context, lastAgentIdx);
   const intent = resolvePmRelaunchIntent(context, isAuto, agentMode);
   const intentPartsByIntent = {
-    ["build" /* Build */]: () => buildPmBuildRelaunchParts(context, isAuto),
+    ["build" /* Build */]: () => buildPmBuildRelaunchParts(context),
     ["review" /* Review */]: buildPmReviewRelaunchParts,
-    ["auto_with_plan" /* AutoWithPlan */]: buildPmAutoWithPlanRelaunchParts,
-    ["auto_planning" /* AutoPlanning */]: buildPmAutoPlanningRelaunchParts,
+    ["auto_with_plan" /* AutoWithPlan */]: () => buildPmAutoWithPlanRelaunchParts(context),
+    ["auto_planning" /* AutoPlanning */]: () => buildPmAutoPlanningRelaunchParts(context),
     ["wait_for_team" /* WaitForTeam */]: buildPmWaitForTeamRelaunchParts
   };
   parts.push(...intentPartsByIntent[intent]());
@@ -7975,6 +7972,7 @@ function branchRule(context, forReview = false) {
   return forReview ? `Work on the git branch "${context.githubBranch}". Stay on this branch for the entire review. Do not checkout or create other branches.` : `Work on the git branch "${context.githubBranch}". Stay on this branch \u2014 do not checkout or create other branches.`;
 }
 function newMessagesBlock(messages) {
+  if (messages.length === 0) return [];
   return [
     `
 New messages since your last run:`,
@@ -7984,6 +7982,25 @@ New messages since your last run:`,
 function pullRequestLine(context) {
   return context.githubPRUrl ? `An existing PR is open at ${context.githubPRUrl} \u2014 push to the same branch to update it. Do NOT create a new PR.` : `When finished, use the mcp__conveyor__create_pull_request tool to open a PR. Do NOT use gh CLI or any other method to create PRs.`;
 }
+function isPlanningSession(mode, agentMode, isAuto) {
+  if (mode === "plan") return true;
+  if (agentMode === "discovery" || agentMode === "help") return true;
+  if (mode !== "pm") return false;
+  return !(agentMode === "building" || agentMode === "auto" || !!isAuto);
+}
+function builderKickoff(context, role) {
+  const parts = [role, ...buildSkillInvocation("/conveyor-build"), branchRule(context)];
+  if (!context.plan?.trim()) {
+    parts.push(
+      `No plan is saved on this card yet \u2014 run \`/conveyor-plan\` first and save it with update_task, then continue with \`/conveyor-build\`.`
+    );
+  }
+  parts.push(pullRequestLine(context));
+  return parts;
+}
+function plannerKickoff(role) {
+  return [role, ...buildSkillInvocation("/conveyor-plan")];
+}
 function buildRelaunchWithSession(mode, context, agentMode, isAuto) {
   const scenario = detectRelaunchScenario(context);
   const hasPriorTurn = !!context.lastSeenMessageId || !!context.claudeSessionId;
@@ -8002,36 +8019,32 @@ function buildRelaunchWithSession(mode, context, agentMode, isAuto) {
   }
   if (mode === "pm") {
     parts.push(...buildPmRelaunchParts(context, lastAgentIdx, isAuto, agentMode));
+  } else if (isPlanningSession(mode, agentMode, isAuto)) {
+    parts.push(
+      scenario === "feedback_relaunch" ? `You have been relaunched with new feedback.` : `You were relaunched but no new instructions have been given since your last run.`,
+      ...newMessagesBlock(allNew.filter((m) => m.role === "user")),
+      ...plannerKickoff(`You are the Planner on this card.`)
+    );
   } else if (scenario === "feedback_relaunch") {
-    const newMessages = allNew.filter((m) => m.role === "user");
     parts.push(
       `You have been relaunched with new feedback.`,
-      branchRule(context),
-      ...newMessagesBlock(newMessages),
-      `
-Address the requested changes. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 review the feedback and implement the changes directly.`,
-      `Commit and push your updates.`,
-      pullRequestLine(context)
+      ...newMessagesBlock(allNew.filter((m) => m.role === "user")),
+      ...builderKickoff(context, `You are the Builder on this card \u2014 address the feedback above.`)
     );
   } else {
-    parts.push(
-      `You were relaunched but no new instructions have been given since your last run.`,
-      branchRule(context),
-      `Run \`git log --oneline -10\` to review what you already committed.`,
-      `Review the current state of the codebase and verify everything is working correctly.`
-    );
+    parts.push(`You were relaunched but no new instructions have been given since your last run.`);
     if (agentMode === "auto" || agentMode === "building" || isAuto) {
       parts.push(
-        `If work is incomplete, continue implementing the plan. When finished, commit, push, and use mcp__conveyor__create_pull_request to open a PR.`,
-        `Do NOT go idle or wait for instructions \u2014 you are in auto mode.`
+        ...builderKickoff(context, `You are the Builder on this card \u2014 pick up where you left off.`)
       );
     } else {
       parts.push(
+        branchRule(context),
         `Post a brief status update with post_to_chat (your turn output is NOT shown in chat \u2014 post_to_chat is how the team sees it), then wait for further instructions.`
       );
-    }
-    if (context.githubPRUrl) {
-      parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
+      if (context.githubPRUrl) {
+        parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
+      }
     }
   }
   return parts.join("\n");
@@ -8117,87 +8130,17 @@ ${truncatePlanForPrompt(context.plan)}`);
   if (context.incidents && context.incidents.length > 0) {
     parts.push(...formatIncidents(context.incidents));
   }
-  if (context.chatHistory.length > 0) {
+  const undelivered = relaunchMessageBatch(context);
+  if (undelivered.length > 0) {
     const chatLimit = runnerMode === "task" ? TASK_CHAT_HISTORY_LIMIT : PM_CHAT_HISTORY_LIMIT;
-    parts.push(...formatChatHistory(context.chatHistory, chatLimit));
+    parts.push(...formatChatHistory(undelivered, chatLimit));
   }
   return parts;
 }
-function buildFreshInstructions(isPm, isAutoMode, context, agentMode) {
-  if (isPm && agentMode === "building") {
-    return [
-      `Your plan has been approved. Begin implementing it now.`,
-      branchRule(context),
-      `Start by reading the relevant source files mentioned in the plan, then write code.`,
-      pullRequestLine(context),
-      `
-CRITICAL: You are in Auto mode. Do NOT report status, ask for confirmation, or go idle without making code changes.`,
-      `Your FIRST action must be reading source files from the plan, then immediately writing code.`,
-      `Do NOT summarize the plan or say "ready to implement" \u2014 start implementing.`,
-      `When all changes are ready, use mcp__conveyor__create_pull_request to open a PR.`,
-      `If you are genuinely blocked, explain the specific blocker \u2014 do not go idle silently.`
-    ];
-  }
-  if (isAutoMode && isPm) {
-    if (context.plan?.trim()) {
-      return [
-        `You are operating autonomously. A plan already exists for this task.`,
-        `Begin implementing it now \u2014 do NOT re-plan or wait for team input.`,
-        `Refine story points, title, and tags via update_task_properties if they look like placeholders.`
-      ];
-    }
-    return [
-      `You are operating autonomously. No plan is saved on this card yet.`,
-      `1. Search the codebase (grep/glob) to locate relevant files, then read the critical ones`,
-      `2. Save a concise plan with update_task BEFORE writing any code \u2014 the plan is a record for the team, not a gate; never pause or wait for approval`,
-      `3. Implement the work, keeping the plan current if your approach changes materially`,
-      `4. Refine story points, tags, and title (update_task_properties) if they look like placeholders`,
-      `Do NOT wait for team input \u2014 proceed autonomously.`
-    ];
-  }
-  if (isPm && context.isParentTask) {
-    return [
-      `You are the project manager for this task and its subtasks.`,
-      `Review existing subtasks via \`list_subtasks\` and the chat history before taking action.`,
-      `Read the task description and chat history carefully \u2014 the team has provided the initial context below. Acknowledge what they've asked for and respond in chat before taking silent tool actions.`,
-      `Start planning now \u2014 explore the codebase, ask clarifying questions if needed, and propose a subtask breakdown. Do not wait for additional team input before engaging.`,
-      `When you finish planning, save the plan with update_task, post a short summary for the team with post_to_chat (your turn output is NOT shown in chat), then end your turn.`
-    ];
-  }
-  if (isPm) {
-    return [
-      `You are the project manager for this task \u2014 a thoughtful, collaborative planner, not the implementer.`,
-      `Your job right now is to help the team turn this request into a clear, well-scoped plan. Be a helpful planning partner: think out loud, surface trade-offs, and keep the human in the loop.`,
-      `Read the task description and chat history carefully \u2014 the team has provided the initial context below. Acknowledge what they've asked for and respond in chat before taking silent tool actions.`,
-      `Start planning now \u2014 explore the codebase, ask clarifying questions if anything is ambiguous, and draft a plan. Do not wait for additional team input before engaging; the initial message IS the team engaging.`,
-      `When you finish planning, save the plan with update_task, post a summary of the plan for the team with post_to_chat (your turn output is NOT shown in chat), then end your turn. A separate task agent will execute the plan after review.`
-    ];
-  }
-  return buildFreshLeafInstructions(context, isAutoMode);
-}
-function buildFreshLeafInstructions(context, isAutoMode) {
-  const parts = context.plan?.trim() ? [`Start now by reading the source files the plan names, then writing code.`] : [
-    `No plan is saved on this card yet. Investigate the task briefly (search first, read only critical files), then save a concise implementation plan with update_task (file:line citations) BEFORE you start writing code.`,
-    `The plan is a step, not the goal: the moment it's posted, IMPLEMENT it in code \u2014 do NOT pause, wait for approval, or treat the posted plan as the deliverable. The card is already In Progress and advances automatically.`
-  ];
-  const base = context.baseBranch?.trim() || "dev";
-  parts.push(
-    `Post to chat when you begin implementing and again when the PR is ready.`,
-    `Pre-PR order (\`/conveyor-build\` has the detail): commit, then sync the base (\`git fetch origin ${base} && git merge origin/${base} --no-edit\`), then ONE verification pass \u2014 \`bun run check\` (lint + typecheck) plus \`bun run test:affected\` (tests scoped to your diff; docs-only changes need no local gates) \u2014 then open the PR. Do NOT re-merge the base or re-run a gate that already passed.`,
-    `If a gate fails, iterate on just the failing test files (\`bun run --cwd <pkg> test:unit <files>\`) and confirm with a single final scoped-gate run. Do NOT open a PR with known failing gates.`,
-    `Open the PR with mcp__conveyor__create_pull_request when the work is done and the gates are green.`
-  );
-  if (isAutoMode) {
-    parts.push(
-      `
-CRITICAL: You are in Auto mode. Your job is to BUILD the change, not to produce a plan \u2014 making a plan and opening a PR of the plan is NOT the goal. The plan is only an intermediate step; you must then write the code that implements it.`,
-      `Do NOT report status, ask for confirmation, or go idle without making code changes. Do NOT summarize the plan or say "ready to implement" \u2014 start implementing immediately.`,
-      `Your pull request MUST contain the actual code implementation. Never open a plan-only or empty-diff PR. (If the task genuinely needs no code changes, do not open a PR \u2014 deliver the result in chat and mark the card Complete.)`,
-      `When the implementation is complete and verified, you MUST use mcp__conveyor__create_pull_request to open a PR before finishing.`,
-      `If you are genuinely blocked, explain the specific blocker \u2014 do not go idle silently.`
-    );
-  }
-  return parts;
+function buildFreshInstructions(isPlanning, context) {
+  return isPlanning ? plannerKickoff(
+    `You are the Planner on this card \u2014 scope and plan it with the team. A separate Builder session implements it.`
+  ) : builderKickoff(context, `You are the Builder on this card \u2014 implement its plan.`);
 }
 function buildFreshCodeReviewInstructions(context) {
   const parts = [...buildSkillInvocation("/conveyor-review"), branchRule(context, true)];
@@ -8206,92 +8149,34 @@ function buildFreshCodeReviewInstructions(context) {
   }
   return parts;
 }
-function buildFeedbackInstructions(context, isPm, agentMode, isAuto) {
-  const lastAgentIdx = findLastAgentMessageIndex(context.chatHistory);
-  const newMessages = context.chatHistory.slice(lastAgentIdx + 1).filter((m) => m.role === "user");
-  if (isPm) {
-    const parts2 = [
-      `You were relaunched with new feedback since your last run.`,
-      `You are the project manager for this task.`,
-      ...newMessagesBlock(newMessages)
-    ];
-    if (isAuto && (agentMode === "building" || agentMode === "review")) {
-      parts2.push(
-        `
-Your plan has been approved. Address the feedback above, then begin implementing.`,
-        branchRule(context),
-        `Start by reading the relevant source files mentioned in the plan, then write code.`,
-        pullRequestLine(context)
-      );
-    } else if (isAuto) {
-      parts2.push(
-        `
-You are in auto mode. Address the feedback above and continue building \u2014 update the saved plan with update_task if the feedback changes your approach.`,
-        `Do NOT wait for additional team input \u2014 the messages above ARE the team's input. Proceed autonomously.`
-      );
-    } else {
-      parts2.push(
-        `
-Review these messages and wait for the team to provide instructions before taking action.`
-      );
-    }
-    return parts2;
-  }
-  const parts = [
-    `You have been relaunched to address feedback on your previous work.`,
-    branchRule(context),
-    `Start by running \`${baseDiffCommand(context.baseBranch, "--stat")}\` to review what you already committed on this branch.`,
-    ...newMessagesBlock(newMessages),
-    `
-Address the requested changes directly. Do NOT re-investigate the codebase from scratch or write a new plan \u2014 go straight to implementing the feedback.`,
-    // Scoped to what the follow-up actually changed. An unconditional full
-    // re-verify on every relaunch made a one-line or docs-only follow-up cost
-    // the same gate time as the original build.
-    `Re-verify in proportion to what THIS follow-up changed, not the whole branch: a docs/\`.claude\`-only change needs no local gates; a code change runs \`bun run check\` plus the directly-affected test files (\`bun run --cwd <pkg> test:unit <files>\`); escalate to a full \`bun run test:affected\` only when the follow-up touched \`packages/shared\`, \`packages/db\`, or root config, or when no gate has ever run on this branch. Fix any failures before pushing \u2014 relaunches are the most common place verification gets skipped.`,
-    `Implement your updates and open a PR when finished.`,
-    pullRequestLine(context)
-  ];
-  return parts;
+function buildFeedbackInstructions(context, isPlanning) {
+  return isPlanning ? plannerKickoff(
+    `You have been relaunched with the feedback in New Messages above. You are the Planner on this card \u2014 fold it into the plan.`
+  ) : builderKickoff(
+    context,
+    `You have been relaunched to address the feedback in New Messages above.`
+  );
 }
-function buildIdleRelaunchInstructions(context, isPm, agentMode, isAuto) {
-  if (isPm && agentMode === "auto" && PRE_BUILD_TASK_STATUSES.has(context.status ?? "")) {
-    if (context.plan?.trim()) {
-      return [
-        `You were relaunched in auto mode. A plan already exists for this task.`,
-        `Begin implementing it now \u2014 refine story points, title, and tags via update_task_properties if they look like placeholders.`,
-        `Do NOT wait for instructions or go idle \u2014 you are in auto mode.`
-      ];
-    }
+function buildIdleRelaunchInstructions(context, isPlanning, agentMode, isAuto) {
+  const opener = `You were relaunched but no new instructions have been given since your last run.`;
+  if (isPlanning) {
     return [
-      `You were relaunched in auto mode. Continue building autonomously.`,
-      `No plan is saved on this card yet \u2014 save a concise plan with update_task before writing further code; never pause or wait for approval.`,
-      `Do NOT wait for instructions or go idle \u2014 you are in auto mode.`
+      opener,
+      `You are the Planner on this card. Post a brief status update with post_to_chat (your turn output is NOT shown in chat \u2014 post_to_chat is how the team sees it), then wait for the team.`
     ];
   }
-  if (isPm && !(agentMode === "building" || agentMode === "review" || agentMode === "auto")) {
+  if (agentMode === "auto" || agentMode === "building" || isAuto) {
     return [
-      `You were relaunched but no new instructions have been given since your last run.`,
-      `You are the project manager for this task.`,
-      `Wait for the team to provide instructions before taking action.`
+      opener,
+      ...builderKickoff(context, `You are the Builder on this card \u2014 pick up where you left off.`)
     ];
   }
-  const isAutoMode = agentMode === "auto" || agentMode === "building" || isAuto;
   const parts = [
-    `You were relaunched but no new instructions have been given since your last run.`,
+    opener,
     branchRule(context),
-    `Run \`git log --oneline -10\` to review what you already committed, then verify the current state is correct.`
+    `Post a brief status update summarizing where things stand with post_to_chat (your turn output is NOT shown in chat \u2014 post_to_chat is how the team sees it).`,
+    `Then wait for further instructions \u2014 do NOT redo work that was already completed.`
   ];
-  if (isAutoMode) {
-    parts.push(
-      `If work is incomplete, continue implementing the plan. When finished, use mcp__conveyor__create_pull_request to open a PR.`,
-      `Do NOT go idle or wait for instructions \u2014 you are in auto mode.`
-    );
-  } else {
-    parts.push(
-      `Post a brief status update summarizing where things stand with post_to_chat (your turn output is NOT shown in chat \u2014 post_to_chat is how the team sees it).`,
-      `Then wait for further instructions \u2014 do NOT redo work that was already completed.`
-    );
-  }
   if (context.githubPRUrl) {
     parts.push(`An existing PR is open at ${context.githubPRUrl}. Do not create a new PR.`);
   }
@@ -8302,6 +8187,7 @@ function buildInstructions(mode, context, scenario, agentMode, isAuto) {
 ## Instructions`];
   const isPm = mode === "pm";
   const isCodeReview = mode === "code-review" || !isPm && agentMode === "review";
+  const isPlanning = isPlanningSession(mode, agentMode, isAuto);
   if (agentMode === "chat") {
     parts.push(...buildChatInstructions(context, scenario, relaunchMessageBatch(context)));
     return parts;
@@ -8311,9 +8197,7 @@ function buildInstructions(mode, context, scenario, agentMode, isAuto) {
     return parts;
   }
   if (scenario === "fresh") {
-    parts.push(
-      ...buildFreshInstructions(isPm, agentMode === "auto" || !!isAuto, context, agentMode)
-    );
+    parts.push(...buildFreshInstructions(isPlanning, context));
     return parts;
   }
   const newBatch = relaunchMessageBatch(context);
@@ -8327,10 +8211,10 @@ function buildInstructions(mode, context, scenario, agentMode, isAuto) {
     return parts;
   }
   if (scenario === "idle_relaunch") {
-    parts.push(...buildIdleRelaunchInstructions(context, isPm, agentMode, isAuto));
+    parts.push(...buildIdleRelaunchInstructions(context, isPlanning, agentMode, isAuto));
     return parts;
   }
-  parts.push(...buildFeedbackInstructions(context, isPm, agentMode, isAuto));
+  parts.push(...buildFeedbackInstructions(context, isPlanning));
   return parts;
 }
 async function buildInitialPrompt(mode, context, isAuto, agentMode, packExecution) {
@@ -13580,6 +13464,9 @@ async function* watchForParkedTui(inner, host, opts) {
     clearTimeout(timer);
   }
 }
+function takesPlannerOpeningTurn(host, mode) {
+  return host.config.mode === "plan" && mode === "discovery";
+}
 async function runSdkQuery(host, context, followUpContent, promptDeliveryOverride) {
   if (host.isStopped()) return;
   const mode = host.agentMode;
@@ -13607,7 +13494,10 @@ async function runSdkQuery(host, context, followUpContent, promptDeliveryOverrid
     await runFollowUpQuery(host, context, options, resume, followUpContent);
     return;
   }
-  if (isDiscoveryLike && (resume || host.harnessKind === "sdk")) {
+  if (isDiscoveryLike && host.harnessKind === "sdk") {
+    return;
+  }
+  if (isDiscoveryLike && resume && !takesPlannerOpeningTurn(host, mode)) {
     return;
   }
   await runInitialQuery(host, context, options, resume, promptDelivery);

package/dist/cli.js

@@ -27,7 +27,7 @@ import {
   resolveTuiKindFromEnv,
   runUsageProbe,
   sampleKeyUsage
-} from "./chunk-PEEGCZAR.js";
+} from "./chunk-QETNCXIR.js";
 import "./chunk-XORJ6SII.js";
 import {
   AgentConnection,

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   SessionRunner,
   unshallowRepo
-} from "./chunk-PEEGCZAR.js";
+} from "./chunk-QETNCXIR.js";
 import "./chunk-XORJ6SII.js";
 import {
   AgentConnection,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-agent",
-  "version": "11.0.0",
+  "version": "11.0.2",
   "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-local-loop/SKILL.md

@@ -173,7 +173,10 @@ notification is the wake. The `ScheduleWakeup` you still arm is the fallback for
 the case where the wait dies silently — use the pacing table's background-gate
 row (1200–1800s), not a second, shorter timer.
 
-- Prefer `node_modules/.bin/conveyor-wait`. If it is absent, use
+- Prefer `node_modules/.bin/conveyor-wait`. Gate on
+  `[ -x node_modules/.bin/conveyor-wait ]`, not on the path existing: in a
+  checkout that has not been built the bin is a symlink into an unbuilt
+  `dist/`, so it looks present and fails to run. When that test is false, use
   `npx -y -p @rallycry/conveyor-mcp@latest conveyor-wait`. The `-p` form
   matters: inside the conveyor monorepo a bare
   `npx @rallycry/conveyor-mcp` misresolves.