@ai-dossier/sched 0.16.0 → 0.17.1

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
@@ -172,6 +176,17 @@ containing a `blocked` batch with "unknown batch status", bricking that project'
 `SchedStore.load()`. Resume or abandon any blocked batch before downgrading past this
 version.
 
+Config schema moves to 1.7.0 (#563): a new top-level `dissolve_policy` key —
+`{ fraction, min_evictions_before_dissolve }`, both required when the key is present —
+overrides the batch dissolve threshold (default `{ fraction: 1/3,
+min_evictions_before_dissolve: 1 }`, RFC-0001 §F.8's ⅓ with no additional floor). An
+absent key falls back wholesale to the default; an invalid one degrades the WHOLE config
+file to built-in defaults, same as every other config field (`loadConfig`'s
+degrade-to-defaults contract). This release also adds the `partial` `dissolveBatch`
+strategy and the `batch-preserved` journal event (see Batch failure recovery above) — both
+are behavioral, not persisted-shape changes, so they carry no schema-version bump of their
+own.
+
 Two engine-safety policies were explicit product decisions on #464:
 
 - **Pid identity is hybrid-verified (decision 1, option C).** Every spawn records the
@@ -248,7 +263,11 @@ against real scratch repos.
 ```
 validating → attributing → fixing (ONE bounded attempt) → validating
                          → evicting (revert the member's commits) → validating
-  > ⅓ of members evicted, or a revert conflict → dissolving → members requeued
+  evictions > max(ceil(N × fraction), min_evictions_before_dissolve), or a
+  revert conflict → dissolving → members requeued (`dissolve_policy`, #563)
+  same threshold crossed, but the survivors' re-run suite came back green
+                         → reviewing (batch preserved; only the evicted
+                           members requeue — strategy=partial, #563)
   suite report unreadable, after the fallback retry when one applied
                          → blocked → validating (nothing requeued/reverted; #562)
 awaiting-merge (CONFLICTING | auto-merge-blocked)
@@ -280,13 +299,24 @@ awaiting-merge (CONFLICTING | auto-merge-blocked)
    aborted so the worktree is clean and the batch dissolves — the reverts that already
    landed ride along on the abandoned branch, which is why it is abandoned rather than
    reused. An eviction group that reaches an already-shipped member dissolves instead of
-   reverting merged work.
+   reverting merged work. Crossing the dissolve trigger no longer always dissolves (#563):
+   if the re-run suite came back green for the survivors — and every evicted member's
+   commits were actually found and reverted — the batch is PRESERVED instead: trimmed to
+   its survivors and carried straight to `reviewing`, only the evicted members requeue. A
+   red or unreadable re-run, or an evicted member whose commits were never found on the
+   branch, still dissolves in full.
 4. **Dissolve (AC3)** — `dissolveBatch` marks the batch `dissolved` and requeues every
-   UNSHIPPED member: `full` (each as its own full-cycle run) or `halved` (one or two fresh
+   UNSHIPPED member: `full` (each as its own full-cycle run), `halved` (one or two fresh
    `forming` half-batches — a single remaining member yields one — entries retagged,
-   eviction groups inherited where they survive the split). Shipped and terminal members
-   keep their outcome; nothing green is discarded, and no git runs — the batch branch is
-   simply left behind unmerged, since sched deletes nothing.
+   eviction groups inherited where they survive the split), or `partial` (#563 — never
+   marks the batch `dissolved` at all: drops the evicted members from `batch.members` and
+   its `eviction_groups`/`ranges`, transitions `validating → reviewing`, and requeues
+   nothing itself, since the caller's eviction loop already did; falls through to `full`
+   if that would leave zero survivors, so an empty batch never ships). Shipped and
+   terminal members keep their outcome; nothing green is discarded, and no git runs — the
+   batch branch is simply left behind unmerged, since sched deletes nothing. Every dissolve
+   decision — all three strategies — journals its policy inputs (`N=`, `evictions=`,
+   `threshold=`), so it is explainable without re-deriving the formula.
 5. **PR conflict (AC4)** — `handlePrConflict` rebases the batch branch, re-runs the suite
    and re-ships ONCE. A second occurrence, a conflicting rebase, a failed fetch, an
    unusable `base_branch`, a checkout that is not on the batch branch, or a red suite
@@ -299,12 +329,13 @@ awaiting-merge (CONFLICTING | auto-merge-blocked)
    with no `anchor` or no `run_id` cannot post — the CLI requires both — so the milestone
    it could not post is journaled in full instead of vanishing.
 
-Eleven journal events carry the detail: `suite-failed`, `attributed`, `fix-dispatched`,
+Twelve journal events carry the detail: `suite-failed`, `attributed`, `fix-dispatched`,
 `fix-resolved`, `member-evicted`, `revert-conflict`, `batch-rebased`, `batch-dissolved`,
-`batch-blocked` (#562 — the suite report was unreadable), `batch-split` and
-`milestone-post-failed`, plus `git-failed` for any git command that returned non-zero (the
-injected `ExecFn` collapses every git failure into `null`, so the command that produced one
-is always recorded).
+`batch-preserved` (#563 — the dissolve threshold was crossed but the survivors' re-run
+suite came back green, so the batch ships them instead of dissolving), `batch-blocked`
+(#562 — the suite report was unreadable), `batch-split` and `milestone-post-failed`, plus
+`git-failed` for any git command that returned non-zero (the injected `ExecFn` collapses
+every git failure into `null`, so the command that produced one is always recorded).
 
 Schema 1.3.0 carries the new state: `BatchEntry` gains `anchor`, `branch`, `run_id`,
 `eviction_groups`, `evictions`, `fix_attempts` and `rebase_attempts`; `QueueEntry` gains
@@ -483,8 +514,8 @@ import {
   beginFixAttempt,       // the ONE bounded mid-tier fix dispatch instruction
   resolveFixAttempt,     // record its outcome, back to validating
   evictMembers,          // revert + requeue with evidence + suite re-run + dissolve check
-  checkDissolveTrigger,  // pure: > ⅓ of members evicted
-  dissolveBatch,         // full or halved dissolve; preserves everything green
+  checkDissolveTrigger,  // pure: evicted > max(ceil(N × fraction), min floor) — dissolve_policy, #563
+  dissolveBatch,         // full | halved | partial (#563); preserves everything green
   blockBatch,            // #562: unreadable suite report → blocked; no requeue, no revert
   type BlockOptions,     // { reason, milestonePhase? } for blockBatch
   handlePrConflict,      // rebase + re-ship once, then dissolve into halves
@@ -515,6 +546,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
@@ -551,7 +587,8 @@ telemetry" below.
 ├── config.json    # durable intent: max_slots, stall_timeout_ms, reconcile_interval_ms,
 │                  # pr_poll_interval_ms, dispatch (incl. report_prompt,
 │                  # phase_stall_timeout_ms, fence_takeover_timeout_ms, tiers — #527,
-│                  # suite_command — #562), auto_upgrade — #537
+│                  # suite_command — #562), auto_upgrade — #537,
+│                  # dissolve_policy — #563
 ├── events.jsonl   # append-only event journal (the operator's flight recorder)
 ├── runs/          # per-unit agent output logs (issue-<n>.log)
 └── .sched-lock/   # cross-process directory mutex (pid; stolen from dead holders)
@@ -607,7 +644,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 {

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;AAEjB;;;;;;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;AA67CD;;;;;;;;;;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;AACxC,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;AAiiDD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,iBAAiB,EACvB,MAAM,EAAE,WAAW,EACnB,QAAQ,EAAE,gBAAgB,GACzB,eAAe,CAsEjB"}

package/dist/batch-dispatch.js

@@ -104,9 +104,11 @@ const dispatch_1 = require("./dispatch");
 const groundtruth_1 = require("./groundtruth");
 const journal_1 = require("./journal");
 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");
+const types_1 = require("./types");
 function emptyResult() {
     return { spawned: [], completed: [], parked: [], mergeAccepted: [], failed: [], blocked: [] };
 }
@@ -190,13 +192,14 @@ function safeSuite(deps, batchId, worktree) {
         return { ok: false, failing: [], readable: false, detail };
     }
 }
-function recoveryDeps(deps, batch, now) {
+function recoveryDeps(deps, config, batch, now) {
     return {
         exec: deps.exec,
         repoDir: batch.worktree ?? deps.repoDir,
         journal: deps.journal,
         postMilestone: (0, recovery_1.createExecMilestonePoster)(deps.exec, { repoDir: deps.repoDir }),
         runSuite: batch.worktree !== null ? () => deps.runSuite(batch.worktree) : undefined,
+        dissolvePolicy: (0, types_1.resolveDissolvePolicy)(config.dissolve_policy),
         now: () => now,
     };
 }
@@ -467,7 +470,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);
@@ -486,6 +489,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)
@@ -615,6 +622,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);
@@ -628,7 +647,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);
@@ -678,7 +697,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);
@@ -747,7 +766,7 @@ function runValidate(deps, config, dispatch, batchId, now, result) {
     if (!batch || batch.worktree === null)
         return;
     const suite = safeSuite(deps, batchId, batch.worktree);
-    const rDeps = recoveryDeps(deps, batch, now);
+    const rDeps = recoveryDeps(deps, config, batch, now);
     const poster = (0, recovery_1.createExecMilestonePoster)(deps.exec, { repoDir: deps.repoDir });
     if (suite.ok) {
         if (batch.anchor !== null && batch.run_id !== null) {
@@ -810,7 +829,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);
@@ -839,12 +858,12 @@ function runValidate(deps, config, dispatch, batchId, now, result) {
         return next;
     });
 }
-function evictOffender(deps, _config, batchId, offender, attribution, now, result) {
+function evictOffender(deps, config, batchId, offender, attribution, now, result) {
     const state = deps.store.load();
     const batch = (0, state_1.findBatch)(state, batchId);
     if (!batch)
         return;
-    const rDeps = recoveryDeps(deps, batch, now);
+    const rDeps = recoveryDeps(deps, config, batch, now);
     const outcome = (0, recovery_1.evictMembers)(state, batchId, { issues: [offender], reason: 'suite-red-after-fix', attribution, ranges: batch.ranges }, rDeps);
     deps.store.withLock((s) => ({
         state: applyBatchAndIssues(s, outcome.state, batchId, outcome.requeued),
@@ -900,13 +919,58 @@ function advanceMemberOrValidate(deps, config, dispatch, batchId, memberCount, c
  * (self-reported blocked, and the incremental gate below).
  */
 function evictMemberAndContinue(deps, config, dispatch, batchId, batch, memberIssue, reason, now, result) {
-    const dissolved = evictMemberDirectly(deps, batchId, memberIssue, reason, now);
+    const dissolved = evictMemberDirectly(deps, config, batchId, memberIssue, reason, now);
     if (dissolved) {
         result.failed.push(unit(batchId));
         return;
     }
     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);
@@ -924,6 +988,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
@@ -973,6 +1041,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,
@@ -997,7 +1066,8 @@ function reconcileMemberSlot(deps, config, dispatch, batchId, slot, now, result)
  * and a commit range to revert; a member evicted here has neither). Returns
  * whether the batch dissolved.
  */
-function evictMemberDirectly(deps, batchId, memberIssue, reason, now) {
+function evictMemberDirectly(deps, config, batchId, memberIssue, reason, now) {
+    const dissolvePolicy = (0, types_1.resolveDissolvePolicy)(config.dissolve_policy);
     // Pass 1 (pure — requeue + record the eviction): safe to run entirely
     // inside the lock, unlike `dissolveBatch` below, which shells out
     // (`deps.exec`/`postMilestone`) and so must NOT hold the lock while it runs.
@@ -1029,7 +1099,10 @@ function evictMemberDirectly(deps, batchId, memberIssue, reason, now) {
             ],
         }, now);
         const updated = (0, state_1.findBatch)(next, batchId);
-        return { state: next, result: updated !== undefined && (0, recovery_1.checkDissolveTrigger)(updated) };
+        return {
+            state: next,
+            result: updated !== undefined && (0, recovery_1.checkDissolveTrigger)(updated, dissolvePolicy),
+        };
     });
     if (!triggered)
         return false;
@@ -1040,7 +1113,7 @@ function evictMemberDirectly(deps, batchId, memberIssue, reason, now) {
     const batch = (0, state_1.findBatch)(state, batchId);
     if (!batch)
         return false;
-    const rDeps = recoveryDeps(deps, batch, now);
+    const rDeps = recoveryDeps(deps, config, batch, now);
     const outcome = (0, recovery_1.dissolveBatch)(state, batchId, { strategy: 'full', reason: 'eviction-threshold' }, rDeps);
     deps.store.withLock((s) => ({
         state: applyBatchAndIssues(s, outcome.state, batchId, outcome.requeued),
@@ -1061,7 +1134,7 @@ function reconcileFixSlot(deps, config, batchId, slot, now, result) {
         return;
     deps.store.withLock((s) => ({ state: releaseSlot(s, batchId, now), result: undefined }));
     const suite = safeSuite(deps, batchId, batch.worktree);
-    const rDeps = recoveryDeps(deps, batch, now);
+    const rDeps = recoveryDeps(deps, config, batch, now);
     const { state: resolved } = (0, recovery_1.resolveFixAttempt)(deps.store.load(), batchId, offenderRecord.issue, suite.ok ? 'green' : 'red', rDeps);
     deps.store.withLock((s) => ({
         state: applyBatchAndIssues(s, resolved, batchId, []),
@@ -1295,7 +1368,7 @@ function runBatchTick(deps, config, dispatch) {
                 ? [...b.fix_attempts].reverse().find((a) => a.outcome === 'dispatched')
                 : undefined;
             if (b && offenderRecord) {
-                const rDeps = recoveryDeps(deps, b, now);
+                const rDeps = recoveryDeps(deps, config, b, now);
                 const { state: resolved } = (0, recovery_1.resolveFixAttempt)(state, batch.id, offenderRecord.issue, 'red', rDeps);
                 deps.store.withLock((s) => ({
                     state: applyBatchAndIssues(s, resolved, batch.id, []),