@ai-dossier/sched 0.17.0 → 0.18.0

package/README.md

@@ -34,14 +34,18 @@ ai-dossier sched resume
 ai-dossier sched abandon --issue 42 --reason "operator abort"
 ai-dossier sched abandon --batch b1   # dissolve; members requeue as full-cycle
 ai-dossier sched stats --issues 4..9  # per-issue tokens/cost from ~/.dossier/runs.jsonl (#524)
+ai-dossier sched stats --batch b1 --project owner-repo  # batch member/tail/report/fix costs from raw dispatch logs (#564)
 ```
 
-Every subcommand except `stats` takes `--project <slug>` (default: `owner-repo` of the
-current directory, falling back to the repo basename — fleet-cycle's convention) and
-`--json`. `stats` reads `~/.dossier/runs.jsonl`, a single global file, not the
-per-project state — it takes `--json` and `--issues` only; see "runs.jsonl telemetry"
-below for the resulting cross-repo caveat (the same issue number in two repos sums
-together).
+Every subcommand except `stats` (without `--batch`) takes `--project <slug>` (default:
+`owner-repo` of the current directory, falling back to the repo basename — fleet-cycle's
+convention) and `--json`. `stats` without `--batch` reads `~/.dossier/runs.jsonl`, a
+single global file, not the per-project state — it takes `--json` and `--issues` only;
+see "runs.jsonl telemetry" below for the resulting cross-repo caveat (the same issue
+number in two repos sums together). `stats --batch <id>` instead takes `--project` like
+every other subcommand and reads that project's `~/.dossier/sched/<project>/runs/`
+directory directly, reconstructing costs from the raw dispatch logs rather than
+`runs.jsonl` (#564) — see "Batch members (#564)" below.
 
 Since #507, `enqueue` additionally reads each candidate issue's live GitHub labels (one
 `gh issue view --json labels` call per issue, resolved against the current directory's repo
@@ -183,6 +187,12 @@ strategy and the `batch-preserved` journal event (see Batch failure recovery abo
 are behavioral, not persisted-shape changes, so they carry no schema-version bump of their
 own.
 
+Config schema moves to 1.8.0 (#565): a new top-level `default_batch_priority` key
+(integer) — the `BatchEntry.priority` a batch gets when created with no explicit
+`batch_priority` (see Unit priority below). Absent → `DEFAULT_BATCH_PRIORITY` (10); an
+invalid value degrades the whole config file to built-in defaults, same contract as every
+other field.
+
 Two engine-safety policies were explicit product decisions on #464:
 
 - **Pid identity is hybrid-verified (decision 1, option C).** Every spawn records the
@@ -377,6 +387,49 @@ load, backfilling `null`: no label re-check ever ran under them, so the first ti
 the upgrade polls immediately rather than waiting out a throttle window it has no
 evidence for — the exact backfill, not a guess.
 
+Schema 1.10.0 (#565): `QueueEntry` gains `priority` (integer, default 0) and `BatchEntry`
+gains `priority` (integer, default `DEFAULT_BATCH_PRIORITY` = 10) — see Unit priority
+below. 1.9.0 and earlier states migrate on load, backfilling absent OR explicit `null` to
+those same defaults: nothing before this field existed was ever weighted differently, so
+the backfill is exact, not a guess.
+
+## Unit priority (#565)
+
+`readiness.ts`'s `runnableUnits` ranks EVERY candidate — issues and batches together — by
+`priority` desc, then readiness age (`updated_at`) asc, then a numeric tiebreak (an
+issue's own number, or a batch's anchor issue) asc, via the exported `compareByPriority`
+comparator and its `entryRank`/`batchRank` helpers. A batch's default priority
+(`DEFAULT_BATCH_PRIORITY`, 10, or the configured `default_batch_priority`) outranks a
+full-cycle entry's default (0) so a ready batch is offered a free slot before a
+same-readiness issue competing for it — closing the gap
+`docs/reports/batch-pilot-2-execution.md` §13.4 found (an operator manually deferring
+full-cycle entries by hand so a batch could claim its slot).
+
+Applying that ordering to who actually DISPATCHES took more than sorting: `engine.ts`'s
+`dispatchAssignments` (the issue-only dispatch pass) now runs `computeAssignments` as a
+READ-ONLY dry run over both kinds each tick, discards the returned state, and applies
+only the issue winners — reserving a free slot for a higher-priority ready batch instead
+of handing it to a same-tick issue. `batch-dispatch.ts`'s own ready-batch claim loop
+(which never goes through `computeAssignments`/`runnableUnits` itself) later that same
+tick claims the capacity the reservation left free, sorted by the same comparator when
+more than one batch is ready. The reservation is gated on the batch pass actually being
+configured (`batchExec`/`runBatchSuite`) — without that gate, a `ready` batch with
+nothing able to claim it would withdraw capacity from issues forever instead of one tick.
+
+`sched enqueue --priority <n>` sets a full-cycle entry's own priority; with `--mode slot`
+it instead sets the BATCH's priority — a batch-level fact like `anchor`/`run_id`,
+agreement-checked on a later join (an incremental `--more-members-expected` call, or a
+manifest split across `--from-manifest` calls, must never silently re-point it). `sched
+reprioritize --issue <n>|--batch <id> --priority <n>` adjusts a queued unit's weight in
+place — no abandon/re-enqueue round trip, which would also reset every other field
+`enqueueEntries` does not accept as a re-supply — and deliberately does not bump
+`updated_at` (the readiness-age tiebreak), journaling a `reprioritized` event with the
+previous value instead. `sched status`'s Queue and Batches tables both show a `priority`
+column; a slot-mode member's own priority is never read by the scheduler (only the BATCH
+row governs assignment), so the Queue table renders `-` for it rather than a number that
+looks load-bearing but is not. A batch dissolve (`recovery.ts`'s `dissolveBatch`) carries
+the parent batch's priority forward onto both split halves.
+
 ## Batch dispatch (#523)
 
 `batch-dispatch.ts`'s `runBatchTick` — called from `tick()` after the issue-level pass,
@@ -453,7 +506,13 @@ import {
   enqueueEntries,        // validated queue appends (cycles, dupes, mode/batch rules)
   parseManifest,         // batch-prep JSON → EnqueueInput[]
   computeAssignments,    // pure: fill idle slots with runnable units, bounded by max_slots
-  runnableUnits,         // pure: which units may run right now (dep-gated)
+  runnableUnits,         // pure: which units may run right now (dep-gated), in assignment
+                         //   order — priority desc → readiness age → issue/anchor (#565)
+  compareByPriority,     // the priority/age/tiebreak comparator runnableUnits sorts with —
+                         //   also used directly by batch-dispatch.ts's ready-batch claim loop
+  entryRank, batchRank,  // PriorityRank of a QueueEntry / BatchEntry (#565)
+  reprioritizeIssue,     // sched reprioritize --issue: adjust priority in place, no
+  reprioritizeBatch,     //   abandon/re-enqueue round trip; refuses a terminal unit
   tick,                  // one engine cycle: reconcile + verify + refill + spawn,
                          //   and since #468: park-watch, teardown, report dispatch
   runLoop,               // the sched start loop (tick, sleep, repeat)
@@ -528,7 +587,8 @@ import {
   transitionIssue, transitionBatch, transitionSlot,  // typed §D transitions
   TRANSITIONS,           // the transition tables themselves (for previews)
   buildStatusReport,     // machine-readable status incl. blocked/failed sets
-  validateState,         // strict persisted-state validation (1.0.0-1.8.0 files migrate)
+  validateState,         // strict persisted-state validation (1.0.0-1.9.0 files migrate)
+  DEFAULT_ISSUE_PRIORITY, DEFAULT_BATCH_PRIORITY, // priority defaults (0 / 10, #565)
   IllegalTransitionError, EnqueueError, CorruptStateError, LockTimeoutError,
   SchedNotFoundError,
   EngineTooOldError,     // state schema newer than installed engine — not corruption (#537)
@@ -542,6 +602,11 @@ import {
   type SchedRunLogInput, // buildSchedRunLogEntry's input shape
   dispatchLogPath,       // <runsDir>/<unit>.log — shared by spawn (offset) and record (read)
   fileSizeOrZero,        // byte size of the dispatch log at spawn time, or 0
+  // #564: reconstruct a batch's dispatch costs from raw per-unit logs on
+  // disk, for batches with no runs.jsonl coverage (pre-#564, or torn down)
+  listBatchDispatchLogs,   // every raw dispatch log found for a batch id, parsed from its filename
+  buildBatchRunLogEntries, // ...to RunLogEntry rows, same shape a live dispatch produces
+  type BatchLogEntry,      // one parsed log entry (member/tail/report/fix)
   runBatchTick,          // #523: one batch reconcile+refill pass; called by tick() after
                          //   the issue pass — loads/saves state itself, holds no lock
                          //   across the call
@@ -635,7 +700,25 @@ journaled `run-log-no-usage` with a `reason` — `log-unreadable`, `log-empty`,
 `no-usage-events` — so a row of dashes in `sched stats` can be explained without
 re-deriving it. A successful append is journaled `run-log-recorded`; a failed one,
 `run-log-failed` with the target file. Dispatches ended by `sched abandon` release the
-slot without recording, so they are not costed.
+slot without recording, so they are not costed. (`finalizeRunLogEntry` in `run-log.ts`
+is the single implementation of this journal-then-append tail, shared by
+`recordDispatchRunLog` here and batch dispatch's `recordMemberRunLog` below — #564.)
+
+**Batch members (#564).** `batch-dispatch.ts` spawns members/tail/report/fix agents
+directly (`deps.spawnDeps.spawn()`), bypassing `recordDispatchRunLog` above entirely —
+`runs.jsonl` had zero coverage for batches even after #524/#531 shipped the per-issue
+capture. `recordMemberRunLog` (`batch-dispatch.ts`) closes that gap for MEMBER
+dispatches, attributed to the same `issue:<n>` unit scheme ordinary dispatches use, so a
+member's cost shows up in the default `sched stats` view with no new read-side logic.
+Tail/report/fix agents still never write to `runs.jsonl` (wiring that in needs each of
+their spawn functions to stamp `SlotEntry.spawned_at` first, same as the original
+member bug); `sched stats --batch <id>` (`packages/sched/src/batch-stats.ts`) instead
+recovers their cost — and any historical batch's, predating #564 or already torn down —
+by reading the raw dispatch logs on disk directly, the same recovery a human previously
+did by hand (`docs/reports/batch-pilot-2-execution.md` §13). Tokens/cost/model reproduce
+exactly; `Duration`/`Tier` are always `-` for a `--batch`-reconstructed row (a raw log
+carries neither the dispatch's spawn time nor its tier) — a structural limit of
+after-the-fact recovery, not a missing-data bug.
 
 - **Crash safety**: a process killed between writes leaves the previous complete state,
   never a partial file; restart resumes identically (proved by `restart.test.ts`) —

package/dist/batch-dispatch.d.ts

@@ -114,6 +114,11 @@ export interface BatchDispatchDeps {
      */
     runCapability?: (worktree: string, capabilityId: string) => CapOutcome;
     fsExists?: FsExists;
+    /**
+     * Home directory for `~/.dossier/runs.jsonl` (#564) — mirrors `EngineDeps.homeDir`.
+     * Undefined defers to `appendSchedRunLog`'s own `os.homedir()` default.
+     */
+    homeDir?: string;
 }
 /** What one `runBatchTick` call did, merged into `engine.ts`'s `TickResult` by the caller. */
 export interface BatchTickResult {
@@ -127,14 +132,17 @@ export interface BatchTickResult {
 }
 /**
  * One batch reconcile+refill pass. Called from `engine.ts`'s `tick()` after
- * the issue-level pass — batches never compete with issues for a slot within
- * the same tick because this pass runs strictly after `dispatchAssignments`
- * already filled every slot it could (see the module doc: batch claims never
- * go through `computeAssignments`/`runnableUnits` at all). Loads and saves
- * state itself via `deps.store.withLock` — the caller holds no lock across
- * this call. `deps.exec` and `deps.runSuite` are mandatory; `deps.
- * runCapability` is independently optional (AC2's incremental gate is itself
- * a "when available" fast path).
+ * the issue-level pass — this pass never claims a slot the issue pass already
+ * gave to an issue (see the module doc: a batch's OWN claim never goes
+ * through `computeAssignments`/`runnableUnits`). It is not, however, run on
+ * leftovers: `dispatchAssignments` (#565) reserves capacity ahead of time for
+ * any ready batch that outranks a competing issue in `runnableUnits`'
+ * priority order, so a higher-priority batch is not starved by same-tick
+ * issue dispatch — see that function's doc for the reservation mechanics.
+ * Loads and saves state itself via `deps.store.withLock` — the caller holds
+ * no lock across this call. `deps.exec` and `deps.runSuite` are mandatory;
+ * `deps.runCapability` is independently optional (AC2's incremental gate is
+ * itself a "when available" fast path).
  */
 export declare function runBatchTick(deps: BatchDispatchDeps, config: SchedConfig, dispatch: ResolvedDispatch): BatchTickResult;
 //# sourceMappingURL=batch-dispatch.d.ts.map

package/dist/batch-dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch-dispatch.d.ts","sourceRoot":"","sources":["../src/batch-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAiBH,OAAO,EAKL,KAAK,gBAAgB,EAErB,KAAK,SAAS,EAEf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,KAAK,WAAW,EAOjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,OAAO,EAAa,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,EAUL,KAAK,WAAW,EACjB,MAAM,YAAY,CAAC;AAWpB,OAAO,EAAE,KAAK,QAAQ,EAA2D,MAAM,YAAY,CAAC;AACpG,OAAO,KAAK,EAKV,WAAW,EAIZ,MAAM,SAAS,CAAC;AAGjB;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,IAAI,GAAG,aAAa,GAAG,mBAAmB,GAAG,wBAAwB,CAAC;AAE/F,8DAA8D;AAC9D,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,SAAS,CAAC;IACrB,GAAG,EAAE,MAAM,IAAI,CAAC;IAChB,uFAAuF;IACvF,OAAO,EAAE,MAAM,CAAC;IAChB,0FAA0F;IAC1F,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sGAAsG;IACtG,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,WAAW,CAAC;IAC5C;;;;;;;;;;;;;;OAcG;IACH,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,UAAU,CAAC;IACvE,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACrB;AAED,8FAA8F;AAC9F,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,8FAA8F;IAC9F,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAw8CD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,iBAAiB,EACvB,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,gBAAgB,GACzB,eAAe,CAsEjB"}
+{"version":3,"file":"batch-dispatch.d.ts","sourceRoot":"","sources":["../src/batch-dispatch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAiBH,OAAO,EASL,KAAK,gBAAgB,EAErB,KAAK,SAAS,EACf,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,KAAK,WAAW,EAOjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,KAAK,OAAO,EAAa,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAExC,OAAO,EAUL,KAAK,WAAW,EACjB,MAAM,YAAY,CAAC;AAYpB,OAAO,EAAE,KAAK,QAAQ,EAA2D,MAAM,YAAY,CAAC;AACpG,OAAO,KAAK,EAKV,WAAW,EAIZ,MAAM,SAAS,CAAC;AAGjB;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,IAAI,GAAG,aAAa,GAAG,mBAAmB,GAAG,wBAAwB,CAAC;AAE/F,8DAA8D;AAC9D,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,SAAS,CAAC;IACrB,GAAG,EAAE,MAAM,IAAI,CAAC;IAChB,uFAAuF;IACvF,OAAO,EAAE,MAAM,CAAC;IAChB,0FAA0F;IAC1F,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sGAAsG;IACtG,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,WAAW,CAAC;IAC5C;;;;;;;;;;;;;;OAcG;IACH,aAAa,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,UAAU,CAAC;IACvE,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,8FAA8F;AAC9F,MAAM,WAAW,eAAe;IAC9B,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,8FAA8F;IAC9F,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAsiDD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,iBAAiB,EACvB,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,gBAAgB,GACzB,eAAe,CAsFjB"}

package/dist/batch-dispatch.js

@@ -103,7 +103,9 @@ const attribution_1 = require("./attribution");
 const dispatch_1 = require("./dispatch");
 const groundtruth_1 = require("./groundtruth");
 const journal_1 = require("./journal");
+const readiness_1 = require("./readiness");
 const recovery_1 = require("./recovery");
+const run_log_1 = require("./run-log");
 const scheduler_1 = require("./scheduler");
 const state_1 = require("./state");
 const teardown_1 = require("./teardown");
@@ -469,7 +471,7 @@ function spawnMember(deps, dispatch, state, slot, batchId, now, result) {
     const spawnSpec = (0, dispatch_1.resolveTierSpawn)(dispatch, tier, memberIssue);
     const cmd = spawnSpec.cmd;
     const prompt = (0, dispatch_1.buildMemberPrompt)(dispatch.memberPrompt, memberIssue, batchId, batch.worktree);
-    const logFile = path.join(deps.store.runsDir, `${(0, dispatch_1.unitLogName)(unit(batchId))}-m${batch.executing_member}-${memberIssue}.log`);
+    const logFile = (0, dispatch_1.batchMemberLogPath)(deps.store.runsDir, batchId, batch.executing_member, memberIssue);
     let pid;
     try {
         pid = deps.spawnDeps.spawn(cmd, prompt, logFile);
@@ -488,6 +490,10 @@ function spawnMember(deps, dispatch, state, slot, batchId, now, result) {
         pid_start: deps.spawnDeps.processStart(pid),
         phase: 'member',
         last_progress_at: now.toISOString(),
+        // #564: `engine.ts`'s own `spawnUnit` stamps this at spawn time
+        // (line ~745) — `spawnMember` never did, so `recordMemberRunLog`'s
+        // `slot.spawned_at === null` guard silently skipped every member.
+        spawned_at: now.toISOString(),
     };
     const next = slot.status === 'assigned' || slot.status === 'recovering'
         ? (0, state_1.transitionSlot)(withStatus, slot.id, 'running', patch, now)
@@ -529,6 +535,11 @@ function claimAndSetup(deps, config, dispatch, batchId, now, result) {
     const batch = (0, state_1.findBatch)(state, batchId);
     if (!batch)
         return;
+    // #565 AC2: "journaled on each assignment" — the issue-dispatch path
+    // (`engine.ts`'s `dispatchAssignments`) already does this on its own
+    // 'assigned' event; mirrored here so a batch's claim carries the same
+    // audit trail.
+    journalEvent(deps, 'assigned', unit(batchId), { slot: claimedSlot, priority: batch.priority });
     const setup = runBatchSetup(deps, batch, now);
     const poster = (0, recovery_1.createExecMilestonePoster)(deps.exec, { repoDir: deps.repoDir });
     if (!setup.ok) {
@@ -617,6 +628,18 @@ function claimAndSpawn(deps, config, batchId, phase, now, spawn) {
 function spawnMemberContinuation(deps, config, dispatch, batchId, now, result) {
     claimAndSpawn(deps, config, batchId, 'member', now, (state, slot) => spawnMember(deps, dispatch, state, slot, batchId, now, result));
 }
+/**
+ * Tail/report/fix dispatches (this function, `spawnReportAgent`,
+ * `reconcileFixSlot`) are NOT recorded live to `runs.jsonl` — only member
+ * dispatches got that treatment in #564 (`spawnMember`'s call into
+ * `recordMemberRunLog`). `sched stats --batch <id>` (`batch-stats.ts`) is
+ * the only way to see their cost today, reconstructed from the raw log
+ * after the fact. Wiring in live recording for these later means repeating
+ * `spawnMember`'s own #564 fix first: none of these three spawn functions'
+ * patches stamp `SlotEntry.spawned_at` either, so a `recordXRunLog` guarded
+ * on `spawned_at !== null` (mirroring `recordMemberRunLog`) would silently
+ * no-op forever, exactly like the original bug.
+ */
 function spawnTailAgent(deps, config, dispatch, batchId, now, result) {
     claimAndSpawn(deps, config, batchId, 'reviewing', now, (state, slot) => {
         const batch = (0, state_1.findBatch)(state, batchId);
@@ -630,7 +653,7 @@ function spawnTailAgent(deps, config, dispatch, batchId, now, result) {
         const spawnSpec = (0, dispatch_1.resolveTierSpawn)(dispatch, 'strong', batch.anchor);
         const cmd = spawnSpec.cmd;
         const prompt = (0, dispatch_1.buildBatchTailPrompt)(dispatch.batchTailPrompt, batchId, batch.anchor, batch.members, batch.worktree);
-        const logFile = path.join(deps.store.runsDir, `${(0, dispatch_1.unitLogName)(unit(batchId))}-tail.log`);
+        const logFile = (0, dispatch_1.batchTailLogPath)(deps.store.runsDir, batchId);
         let pid;
         try {
             pid = deps.spawnDeps.spawn(cmd, prompt, logFile);
@@ -680,7 +703,7 @@ function spawnReportAgent(deps, config, dispatch, batchId, now, result) {
         const spawnSpec = (0, dispatch_1.resolveTierSpawn)(dispatch, 'mechanical', batch.anchor);
         const cmd = spawnSpec.cmd;
         const prompt = (0, dispatch_1.buildBatchReportPrompt)(dispatch.batchReportPrompt, batchId, batch.anchor, prNumber);
-        const logFile = path.join(deps.store.runsDir, `${(0, dispatch_1.unitLogName)(unit(batchId))}-report.log`);
+        const logFile = (0, dispatch_1.batchReportLogPath)(deps.store.runsDir, batchId);
         let pid;
         try {
             pid = deps.spawnDeps.spawn(cmd, prompt, logFile);
@@ -812,7 +835,7 @@ function runValidate(deps, config, dispatch, batchId, now, result) {
         return;
     }
     claimAndSpawn(deps, config, batchId, 'fixing', now, (s, slot) => {
-        const logFile = path.join(deps.store.runsDir, `${(0, dispatch_1.unitLogName)(unit(batchId))}-fix-${offender}.log`);
+        const logFile = (0, dispatch_1.batchFixLogPath)(deps.store.runsDir, batchId, offender);
         let pid;
         try {
             pid = deps.spawnDeps.spawn(fixDispatch.command, fixDispatch.prompt, logFile);
@@ -909,6 +932,51 @@ function evictMemberAndContinue(deps, config, dispatch, batchId, batch, memberIs
     }
     advanceMemberOrValidate(deps, config, dispatch, batchId, batch.members.length, batch.executing_member, memberIssue, now, result);
 }
+/**
+ * Record one member dispatch's tokens/cost to `runs.jsonl` (#564) — the
+ * `batch-dispatch.ts` analogue of `engine.ts`'s `recordDispatchRunLog`.
+ * Batch members never go through `engine.ts`'s per-unit spawn/record path
+ * (`spawnMember` calls `deps.spawnDeps.spawn()` directly), so #524's capture
+ * never covered them; this closes that gap using the exact same
+ * `buildSchedRunLogEntry`/`appendSchedRunLog` machinery, attributed to
+ * `issue:<memberIssue>` — the SAME unit scheme ordinary issue dispatches use,
+ * so a member's cost shows up in the default `sched stats` view with no new
+ * unit format for the read side to special-case.
+ *
+ * Exactly-once per dispatch, mirroring `recordDispatchRunLog`'s own
+ * invariant: called from both of `reconcileMemberSlot`'s exit branches
+ * (member complete, member blocked/dead) — a batch never redispatches the
+ * same member slot (eviction requeues it as an independent full-cycle run
+ * instead), so unlike `engine.ts`'s per-unit log, a member's log file is
+ * always one-shot and reading from offset 0 is always correct.
+ */
+function recordMemberRunLog(deps, dispatch, state, batchId, batch, memberIssue, slot, now) {
+    if (slot.status !== 'running' || slot.spawned_at === null) {
+        journalEvent(deps, 'run-log-skipped', unit(batchId), {
+            issue: memberIssue,
+            reason: slot.spawned_at === null ? 'never-spawned' : `already-recorded-${slot.status}`,
+            slot: slot.id,
+        });
+        return;
+    }
+    const tier = (0, state_1.findEntry)(state, memberIssue)?.tier ?? 'mid';
+    const { cmd, model } = (0, dispatch_1.resolveTierSpawn)(dispatch, tier, memberIssue);
+    const logFile = (0, dispatch_1.batchMemberLogPath)(deps.store.runsDir, batchId, batch.executing_member, memberIssue);
+    const logContent = (0, run_log_1.readDispatchLog)(logFile, 0);
+    const runEntry = (0, run_log_1.buildSchedRunLogEntry)({
+        unit: `issue:${memberIssue}`,
+        role: 'batch-member',
+        cmd0: cmd[0],
+        cmd,
+        logContent,
+        spawnedAt: slot.spawned_at,
+        completedAt: now,
+        configuredModel: model,
+        cwd: deps.repoDir,
+        tier,
+    });
+    (0, run_log_1.finalizeRunLogEntry)(runEntry, logContent, deps.homeDir, (event, extra) => journalEvent(deps, event, unit(batchId), extra), { issue: memberIssue, log: logFile });
+}
 function reconcileMemberSlot(deps, config, dispatch, batchId, slot, now, result) {
     const state0 = deps.store.load();
     const batch = (0, state_1.findBatch)(state0, batchId);
@@ -926,6 +994,10 @@ function reconcileMemberSlot(deps, config, dispatch, batchId, slot, now, result)
             issue: memberIssue,
             detail: 'member review done',
         }), now);
+        // The member's own agent process is done regardless of what the
+        // incremental gate below decides — record its telemetry once here (#564)
+        // rather than at each of this branch's two later exit points.
+        recordMemberRunLog(deps, dispatch, state0, batchId, batch, memberIssue, slot, now);
         // Incremental gate (#523 AC2): typecheck + focused tests via `cap run`,
         // when the repo has a manifest for them — a second, independent check
         // that the member's own self-reported "done" is real, matching this
@@ -975,6 +1047,7 @@ function reconcileMemberSlot(deps, config, dispatch, batchId, slot, now, result)
             : dead
                 ? 'agent-exited-unverified'
                 : 'member-blocked';
+        recordMemberRunLog(deps, dispatch, state0, batchId, batch, memberIssue, slot, now);
         journalEvent(deps, 'unit-failed', unit(batchId), {
             issue: memberIssue,
             reason,
@@ -1234,21 +1307,40 @@ function teardownBatch(deps, batchId) {
 // --- Entry point ---
 /**
  * One batch reconcile+refill pass. Called from `engine.ts`'s `tick()` after
- * the issue-level pass — batches never compete with issues for a slot within
- * the same tick because this pass runs strictly after `dispatchAssignments`
- * already filled every slot it could (see the module doc: batch claims never
- * go through `computeAssignments`/`runnableUnits` at all). Loads and saves
- * state itself via `deps.store.withLock` — the caller holds no lock across
- * this call. `deps.exec` and `deps.runSuite` are mandatory; `deps.
- * runCapability` is independently optional (AC2's incremental gate is itself
- * a "when available" fast path).
+ * the issue-level pass — this pass never claims a slot the issue pass already
+ * gave to an issue (see the module doc: a batch's OWN claim never goes
+ * through `computeAssignments`/`runnableUnits`). It is not, however, run on
+ * leftovers: `dispatchAssignments` (#565) reserves capacity ahead of time for
+ * any ready batch that outranks a competing issue in `runnableUnits`'
+ * priority order, so a higher-priority batch is not starved by same-tick
+ * issue dispatch — see that function's doc for the reservation mechanics.
+ * Loads and saves state itself via `deps.store.withLock` — the caller holds
+ * no lock across this call. `deps.exec` and `deps.runSuite` are mandatory;
+ * `deps.runCapability` is independently optional (AC2's incremental gate is
+ * itself a "when available" fast path).
  */
 function runBatchTick(deps, config, dispatch) {
     const result = emptyResult();
     const now = deps.now();
-    for (const batch of deps.store.load().batches) {
-        if (batch.status === 'ready' && slotFor(deps.store.load(), batch.id) === undefined) {
-            claimAndSetup(deps, config, dispatch, batch.id, now, result);
+    // #565: when more ready batches exist than free capacity, claim them in
+    // the same priority order `runnableUnits` would (desc priority → asc
+    // readiness age → anchor) — this loop never goes through
+    // `computeAssignments`/`runnableUnits` itself (see the module doc), so it
+    // applies the shared comparator/rank helpers directly. The ORDER and
+    // MEMBERSHIP of `readyOrder` are frozen from a snapshot taken once up
+    // front — a batch that becomes `ready` mid-pass waits for the next tick;
+    // only the per-batch `slotFor`/`status` re-check inside the loop reads
+    // fresh state (one `store.load()` per iteration, in case an earlier claim
+    // in this same pass changed things).
+    const readyOrder = [...deps.store.load().batches]
+        .filter((b) => b.status === 'ready')
+        .sort((a, b) => (0, readiness_1.compareByPriority)((0, readiness_1.batchRank)(a), (0, readiness_1.batchRank)(b)))
+        .map((b) => b.id);
+    for (const batchId of readyOrder) {
+        const state = deps.store.load();
+        const batch = (0, state_1.findBatch)(state, batchId);
+        if (batch && batch.status === 'ready' && slotFor(state, batchId) === undefined) {
+            claimAndSetup(deps, config, dispatch, batchId, now, result);
         }
     }
     for (const batch of deps.store.load().batches) {