@rallycry/conveyor-agent 11.0.18 → 11.0.20

package/dist/{chunk-GL2DIQEQ.js → chunk-Q4FQOJ7D.js}

@@ -128,7 +128,7 @@ function errText(err) {
 }
 async function syncTaskBranchToRepo(deps, paths) {
   const { git, log } = deps;
-  const { branch, baseBranch } = deps.bundle.gitPlan;
+  const { branch } = deps.bundle.gitPlan;
   try {
     await git(["remote", "set-url", "origin", paths.remoteUrl], {
       cwd: paths.repoDir,
@@ -140,6 +140,18 @@ async function syncTaskBranchToRepo(deps, paths) {
   }
   const credentialFailure = await persistCredentialHelper(deps, paths);
   if (credentialFailure) return credentialFailure;
+  const [, resetSucceeded] = await Promise.all([
+    warmBaseBranch(deps, paths),
+    resetTrackedChanges(deps, paths)
+  ]);
+  if (!resetSucceeded) return { state: "failed", reason: "pre-checkout reset failed" };
+  log.info(`[boot] Repo remote ready; agent will checkout ${branch}`);
+  return { state: "ready" };
+}
+async function warmBaseBranch(deps, paths) {
+  const { git, log } = deps;
+  const { baseBranch } = deps.bundle.gitPlan;
+  const started = performance.now();
   try {
     await git(["fetch", "origin", `+refs/heads/${baseBranch}:refs/remotes/origin/${baseBranch}`], {
       cwd: paths.repoDir,
@@ -147,17 +159,24 @@ async function syncTaskBranchToRepo(deps, paths) {
     });
   } catch (err) {
     log.warn(`[boot] WARN: fetch origin/${baseBranch} failed: ${errText(err)}`);
+  } finally {
+    log.info(`[boot] step=gitFetchBase ms=${Math.round(performance.now() - started)}`);
   }
+}
+async function resetTrackedChanges(deps, paths) {
+  const { git, log } = deps;
+  const started = performance.now();
   try {
     await git(["reset", "--hard", "HEAD"], { cwd: paths.repoDir, timeoutMs: QUICK_GIT_TIMEOUT_MS });
+    return true;
   } catch (err) {
     log.error(
       `[boot] ERROR: failed to clean tracked repo changes before checkout: ${errText(err)}`
     );
-    return { state: "failed", reason: "pre-checkout reset failed" };
+    return false;
+  } finally {
+    log.info(`[boot] step=gitResetTracked ms=${Math.round(performance.now() - started)}`);
   }
-  log.info(`[boot] Repo remote ready; agent will checkout ${branch}`);
-  return { state: "ready" };
 }
 async function persistCredentialHelper(deps, paths) {
   try {

package/dist/{chunk-GZRZGBIK.js → chunk-SKTNJNXQ.js}

@@ -5,10 +5,10 @@ import {
   readWorkspaceBytes,
   statWorkspacePath,
   workspacePathExists
-} from "./chunk-WS7QRB37.js";
+} from "./chunk-JBGPARLG.js";
 import {
   reportBootMilestone
-} from "./chunk-GL2DIQEQ.js";
+} from "./chunk-Q4FQOJ7D.js";
 import {
   runSetupCommand,
   runStartCommand,

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   WorkspaceCommandSupervisor,
   startWorkspaceCommandsAfterConnect,
   stopWorkspaceCommands
-} from "./chunk-GZRZGBIK.js";
+} from "./chunk-SKTNJNXQ.js";
 import {
   DEFAULT_SONNET_MODEL,
   PtyHarness,
@@ -26,9 +26,10 @@ import {
   resolveTuiAdapter,
   resolveTuiKindFromEnv,
   runUsageProbe,
-  sampleKeyUsage
-} from "./chunk-ZFHN7GO7.js";
-import "./chunk-SR66HQKB.js";
+  sampleKeyUsage,
+  usesNativeUsageReporting
+} from "./chunk-POK3QCGN.js";
+import "./chunk-37J5MMQT.js";
 import {
   inheritedEnv,
   resolvePtySpawn,
@@ -44,8 +45,8 @@ import {
   createServiceLogger,
   fetchBootstrap,
   loadConveyorConfig
-} from "./chunk-WS7QRB37.js";
-import "./chunk-GL2DIQEQ.js";
+} from "./chunk-JBGPARLG.js";
+import "./chunk-Q4FQOJ7D.js";
 import "./chunk-W4LZ7R6Z.js";
 import "./chunk-372R6E4C.js";
 import "./chunk-IA45XHOA.js";
@@ -236,7 +237,7 @@ var ProjectSessionRunner = class {
   /** Report the running subscription key's rate-limit utilization (same path as
    *  the task runner). Best-effort — never throws, no-op without an OAuth token. */
   async sampleAndReportKeyUsage() {
-    if (this.stopped) return;
+    if (this.stopped || usesNativeUsageReporting()) return;
     const codingAgentKeyId = process.env.CONVEYOR_CODING_AGENT_KEY_ID;
     const { samples, unmeasurable } = await sampleKeyUsage(
       process.env.CLAUDE_CODE_OAUTH_TOKEN,
@@ -575,7 +576,7 @@ var AdhocSessionRunner = class {
   }
   /** Single-key fallback: sample only the key this pod booted under. */
   async sampleAndReportOwnKey() {
-    if (this.stopped) return;
+    if (this.stopped || usesNativeUsageReporting()) return;
     const codingAgentKeyId = process.env.CONVEYOR_CODING_AGENT_KEY_ID;
     const { samples, unmeasurable } = await sampleKeyUsage(
       process.env.CLAUDE_CODE_OAUTH_TOKEN,
@@ -1205,7 +1206,7 @@ function wireSpawnChildren(mode, connection, supervisors, logger7) {
 
 // src/cli.ts
 if (process.argv[2] === "boot") {
-  const { runBoot } = await import("./boot-4ZNOCKFZ.js");
+  const { runBoot } = await import("./boot-Z3EBJ7GX.js");
   process.exit(await runBoot(process.argv.slice(3)));
 }
 if (isLegacyEntrypointLaunch(process.env)) {
@@ -1458,7 +1459,7 @@ if (!RUNNER_MODES.includes(CONVEYOR_MODE)) {
   process.exit(1);
 }
 if (CONVEYOR_MODE === "serving") {
-  const { runServingSession } = await import("./serve-boot-RU5BYIK4.js");
+  const { runServingSession } = await import("./serve-boot-4BUN4U44.js");
   exitContext.runnerMode = "serving";
   exitContext.sessionId = process.env.CONVEYOR_SESSION_ID ?? exitContext.sessionId;
   const outcome = await runServingSession({

package/dist/index.d.ts

@@ -1107,6 +1107,20 @@ declare class SessionRunner {
      *  the tool starts work that outlives the turn. */
     private noteToolUseForBackgroundWork;
     private setState;
+    /**
+     * A submitted PTY query can park on an unexpected terminal dialog without
+     * returning its turn. Keep the runner's local state (which drives heartbeat
+     * liveness) in sync with that specific watchdog signal, but do not emit it
+     * again: QueryBridge already sent it.
+     *
+     * Retry delays and pending questionnaires also report `waiting_for_input`,
+     * but they retain their existing bounded liveness holds and must not change
+     * `_state` here.
+     */
+    private applySubmittedPtyParkedStatus;
+    /** Forward an ordinary query status without changing liveness for transient
+     * waiting states. The submitted-PTY watchdog calls its dedicated handler. */
+    private handleQueryStatus;
     /** Mark a fresh turn without emitting a duplicate status. QueryExecutor's
      * prefilled PTY callback already emitted `running` before it reaches here. */
     private beginRunningEpisode;
@@ -1165,6 +1179,10 @@ type UserQuestionSignal = {
 interface AgentRunnerCallbacks {
     onEvent: (event: Record<string, unknown>) => void | Promise<void>;
     onStatusChange: (status: string) => void | Promise<void>;
+    /** Fired only when a submitted PTY query stays silent past the parked-TUI
+     * grace window. This differs from ordinary `waiting_for_input` reports:
+     * retry delays and questionnaires keep the runner locally live. */
+    onSubmittedPtyParked?: () => void;
     /** Optional — fired on question-pending transitions (see UserQuestionSignal). */
     onUserQuestion?: (signal: UserQuestionSignal) => void;
 }

package/dist/index.js

@@ -1,8 +1,8 @@
 import {
   SessionRunner,
   unshallowRepo
-} from "./chunk-ZFHN7GO7.js";
-import "./chunk-SR66HQKB.js";
+} from "./chunk-POK3QCGN.js";
+import "./chunk-37J5MMQT.js";
 import "./chunk-W5INK3NE.js";
 import {
   AgentConnection,
@@ -17,8 +17,8 @@ import {
   stageAndCommit,
   updateRemoteToken,
   workspacePathExists
-} from "./chunk-WS7QRB37.js";
-import "./chunk-GL2DIQEQ.js";
+} from "./chunk-JBGPARLG.js";
+import "./chunk-Q4FQOJ7D.js";
 import {
   runAuthTokenCommand,
   runSetupCommand,

package/dist/{serve-boot-RU5BYIK4.js → serve-boot-4BUN4U44.js}

@@ -1,6 +1,6 @@
 import {
   WorkspaceCommandSupervisor
-} from "./chunk-GZRZGBIK.js";
+} from "./chunk-SKTNJNXQ.js";
 import {
   AgentConnection,
   CodespacePortVisibility,
@@ -11,8 +11,8 @@ import {
   createServiceLogger,
   ensureOnTaskBranch,
   loadConveyorConfig
-} from "./chunk-WS7QRB37.js";
-import "./chunk-GL2DIQEQ.js";
+} from "./chunk-JBGPARLG.js";
+import "./chunk-Q4FQOJ7D.js";
 import "./chunk-W4LZ7R6Z.js";
 import "./chunk-IA45XHOA.js";
 import "./chunk-SQM2BQ7H.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rallycry/conveyor-agent",
-  "version": "11.0.18",
+  "version": "11.0.20",
   "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

@@ -38,6 +38,42 @@ out in an **Environment** note — never assume; check which one you are in.
   serially. Parallel fan-out is a deliberate choice the user makes by pressing
   Build on the parent, not something a build session opts into.
 
+## Goal and finish line
+
+Which goal applies depends on the route below. State it once, then hold it: a
+run ends when its finish line is true, not earlier.
+
+**Task path goal:** a pull request for this card.
+**Finish line:** the card in ReviewPR, the PR open, CI started. Then aftercare
+per `## Aftercare` — in a pod you stay wake-able; standalone locally you stop.
+**A task turn may end only when:** a harness-tracked background gate is in
+flight (Claude Code only); you are blocked on a human with the question posted;
+or the finish line is true.
+
+**Pack path goal:** the WHOLE pack, not one child. Per child the goal covers
+the full cycle: plan reviewed and promoted → implemented on the pack branch →
+gated → reviewer-of-record pass → merged (locally) or
+`mcp__conveyor__update_task` → ReviewDev (pod) → base synced. Then
+cross-reference, then the finale.
+**Finish line:** every child is ReviewDev, Complete, or Cancelled AND the
+parent's finale PR into the base branch is open with CI started. One child done
+is not the finish line. A turn that ends with a ready child and no wake armed
+is the failure this section exists to prevent.
+**A pack turn may end only when:** a harness-tracked background gate is in
+flight (Claude Code only — Codex holds the gate's command session open
+instead); you are blocked on a human with the parked protocol posted; or the
+finale PR is open and green-and-quiet. Nothing else. Anything else is a stalled
+run, not a paused one.
+
+**Runtime:** *Codex CLI* — before the first step (Setup step 1 on the pack
+path), create a thread goal with your goal tool whose objective is the finish
+line sentence for this route, naming the card slug. Call `update_goal` with
+`complete` only when that finish line is true (for a pack: the finale PR is
+open); `blocked` only per the parked protocol; never because the budget is
+low. *Claude Code* — there is no goal tool; the pacing rule in
+[references/pack-path.md](references/pack-path.md) is the loop, and its pack
+heartbeat is the fallback.
+
 ## Environment
 
 Resolve which one you are in before touching git or the filesystem.

package/skills/conveyor-build/references/pack-path.md

@@ -96,18 +96,39 @@ End a turn with children remaining ONLY when a wake is guaranteed:
 
 - **A background gate is in flight.** Its completion notification re-invokes
   you. (Launch it with the harness's `run_in_background`; hand-rolled
-  backgrounding wakes nothing.)
+  backgrounding wakes nothing.) *Codex CLI substitution:* Codex has no
+  background gate. Hold the gate's command session open until it returns an
+  exit result, then continue in the same turn — ending the turn is not how a
+  Codex runner waits.
 - **You are blocked on a human** — the parked protocol below. The user's chat
   reply is the wake.
 - **The finale PR is open and quiet** — the Babysit tier. Green and quiet is
   the end.
 
-Any other end-of-turn must arm `ScheduleWakeup` first: 60–90s, prompt
-restating which child comes next. That is the pod-sanctioned mechanism (the
-pod prompt allows `ScheduleWakeup` exactly when nothing else will notify you),
-and it is a rare exception, not the cadence. Never end a turn "to report
-progress" — chat is where progress goes, and posting there does not end the
-pack.
+Any other end-of-turn is runtime-specific:
+
+**Claude Code.** Arm `ScheduleWakeup` first: 60–90s, prompt restating which
+child comes next. That is the pod-sanctioned mechanism (the pod prompt allows
+`ScheduleWakeup` exactly when nothing else will notify you), and it is a rare
+exception, not the cadence. On top of it, run a **pack heartbeat**: at Setup,
+before the first child, arm ONE long fallback wake (`ScheduleWakeup`,
+1200–1500s) whose prompt is the pack continuation — "re-derive with
+`mcp__conveyor__list_subtasks` and take the next ready child; if nothing is
+ready and no gate is in flight, stop" — and re-arm it at every child boundary
+so exactly one is outstanding. A heartbeat that fires mid-work re-derives
+state and is a no-op. This is NOT the "insurance wakeup" the pod prompt
+forbids: that rule is about a background job's own completion notification,
+which does fire. Nothing at all notifies a pack between children, so the
+heartbeat is the only guaranteed wake a Claude pack has. Do not delete it.
+
+**Codex CLI.** There is no `ScheduleWakeup` and no `/loop`. The thread goal
+created per the SKILL.md *Goal and finish line* section is the continuation:
+an idle thread is re-prompted to keep working toward it. The only way to leave
+a child ready is therefore to keep working in the same turn — merge, next
+child, merge. Mark the goal complete only when the finale PR is open.
+
+Never end a turn "to report progress" — in either runtime, chat is where
+progress goes, and posting there does not end the pack.
 
 **Pre-exit invariant.** Before ending ANY turn, re-run
 `mcp__conveyor__list_subtasks`. A child that is `Open` with its dependencies

package/skills/conveyor-plan/SKILL.md

@@ -19,6 +19,34 @@ identification decides.** Moving the card to Open fires identification
 automatically (story points, icon, agent, and tags if you set none). Never set
 icon or story points yourself, and never `start_task` unless the user asks.
 
+## Goal and finish line
+
+**Goal:** a plan on this card that a context-free executor can build, or one
+batched round of questions for a human when scope is genuinely ambiguous.
+**Finish line:** the plan is saved with `mcp__conveyor__update_task` AND the
+recommendation is posted with `mcp__conveyor__post_to_chat` and
+`milestone: "plan_ready"`. In a pod, story points and risk are also set
+(`mcp__conveyor__update_task_properties`) and plan mode is exited.
+**A turn may end only when:** (a) the finish line above is true, or (b) an
+`AskUserQuestion` is pending. Nothing else. Anything else is a stalled run, not
+a paused one.
+
+**Never ask whether to start building, and never offer to.** Once the plan is
+saved, the handoff is not yours: in the cloud the system spawns a separate
+Builder session for the card, and locally a human runs `/conveyor-build` when
+they are ready. Until one of those happens, every further turn on this card is
+a plan iteration — read the feedback, revise, re-save, re-post `plan_ready`.
+Do not claim the card, do not touch the tree, and do not invoke
+`/conveyor-build` unprompted. (Locally the user may ask for it in the same
+session; that request is the only trigger.)
+
+**Runtime:** *Codex CLI* — before Phase 0, create a thread goal with your goal
+tool whose objective is: "Save a plan on card <slug> that a context-free
+builder can execute, or ask the blocking questions; do not start
+implementation." Mark it complete only when the finish line is true, never
+because the budget is low. *Claude Code* — there is no goal tool; the finish
+line and the two turn endings above are the loop.
+
 ## Phase 0 — Resolve context
 
 1. `mcp__conveyor__get_connection_context` (all Conveyor tools fully-qualified;
@@ -135,7 +163,10 @@ touching Conveyor, unless they asked you to just ship it.
 > does not exist in a pod. In a pod, the card exists and you are on it: save
 > the plan with `mcp__conveyor__update_task` (`plan`, and `description` if it
 > needs sharpening), post the same recommendation message to chat with
-> `milestone: "plan_ready"`, and stop — a pod does not promote its own card to
+> `milestone: "plan_ready"`, and stop. "Stop" means end the turn with no
+> question about starting work — per *Goal and finish line*, the Builder is a
+> separate session the system spawns, and every later turn here is a plan
+> iteration. A pod does not promote its own card to
 > Open. A parked plan is never `blocked`: that milestone means you cannot
 > continue until a human acts, and it pages nobody. To page a person, ask them
 > with AskUserQuestion. If the pod also has to leave

package/skills/conveyor-review/SKILL.md

@@ -26,6 +26,30 @@ process, this skill loses: a project's own rules outrank a general one.
   PR touches are not this PR's job — note them in chat if they matter, or file
   a suggestion, but do not block on them.
 
+## Goal and finish line
+
+**Goal:** one verdict on this PR.
+**Finish line:** the environment's verdict tool returned success —
+`mcp__conveyor__approve_code_review` / `mcp__conveyor__request_code_changes`
+in a pod, `mcp__conveyor__approve_task` / `mcp__conveyor__request_changes`
+locally — OR a blocked note is posted with the specific blocker and no verdict
+(the `## Blocked` case).
+**A turn may end only when:** (a) the verdict call succeeded — read the
+response; a "superseded by a newer review cycle" error is not success; (b) the
+blocked note is posted; or (c) you pushed your own fix and are waiting for CI
+before approving. Nothing else. Findings posted with no verdict called is a
+stalled review, not a paused one.
+
+**Reviewer of record for a pack child** has no verdict tool: its finish line is
+the merge (locally) or the `mcp__conveyor__update_task` → ReviewDev write
+(pod), and the pack path's goal wording in conveyor-build governs instead.
+
+**Runtime:** *Codex CLI* — before reading the change, create a thread goal with
+your goal tool: "Render exactly one review verdict on PR <n> for card <slug>."
+Mark it complete only after the verdict call succeeded, never because the
+budget is low. *Claude Code* — there is no goal tool; the finish line above is
+the loop.
+
 ## Read the change
 
 1. `mcp__conveyor__get_task` for the plan — you cannot judge "does this do what
@@ -142,8 +166,10 @@ is the reviewer, and the independent review happens later on the pack's PR into
 
 - Apply the same criteria above. The absence of an automated pass makes this
   review more load-bearing, not less.
-- There is **no verdict tool** — merging the child PR is the approval. Say what
-  you checked in chat so the record exists.
+- There is **no verdict tool** — merging the child PR (locally) or the
+  `mcp__conveyor__update_task` → ReviewDev write (pod) is the approval, and
+  that write or merge is this review's finish line; the pack path's goal
+  wording applies. Say what you checked in chat so the record exists.
 - You wrote this code, which makes self-review the weak point. An independent
   reviewer with the diff and no memory of writing it catches what you cannot.