@ai-dossier/sched 0.33.0 → 0.35.0

package/README.md

@@ -89,8 +89,8 @@ where every mechanical supervision decision is code, not remembered prose:
 
    (`strong` sets only `model`, so its command falls back to the default claude template.)
    What an engine is ACTUALLY running is always visible in two places, added in #680: the
-   `Dispatch: …` line in `sched status` (and its `--json` `dispatch` field), and the
-   `▶ sched dispatch: …` banner `sched start` prints once at startup — both show
+    `Dispatch (default): …` line in `sched status` (and its `--json` `dispatch` field), and the
+    `▶ sched dispatch (default): …` banner `sched start` prints once at startup — both show
    `tier=agent/model` resolved exactly as spawns resolve. Note the inverse trap: running
    the batch FROM opencode/GLM does not make it run ON opencode/GLM — without a
    `dispatch.tiers` override every tier dispatches the default claude template regardless
@@ -283,6 +283,30 @@ Config schema moves to 1.8.0 (#565): a new top-level `default_batch_priority` ke
 invalid value degrades the whole config file to built-in defaults, same contract as every
 other field.
 
+Config schema moves to 1.9.0 (#707): `dispatch.dispatch_profiles` names complete
+dispatch configurations for batch runs. A profile has the same `command`, `tier_models`,
+`prompt`, and optional per-tier `tiers` overrides as `dispatch`; the batch records the
+profile name at enqueue time, and every member, tail, report, and recovery agent resolves
+through that profile. For example:
+
+```json
+{
+  "dispatch": {
+    "dispatch_profiles": {
+      "claude": { "command": ["claude", "-p", "--model", "{model}"], "tier_models": { "mechanical": "haiku", "mid": "sonnet", "strong": "opus" } },
+      "glm": { "command": ["opencode", "run", "-m", "{model}", "--"], "tier_models": { "mechanical": "glm-flash", "mid": "glm", "strong": "glm-strong" } }
+    }
+  }
+}
+```
+
+Use `sched enqueue --mode slot --batch <id> --dispatch glm` to select a profile
+explicitly. Without `--dispatch`, a new batch detects Claude Code from `CLAUDECODE` or a
+configured agent binary in its parent process chain. Detection is convenience only: if
+profiles exist and detection is inconclusive, enqueue fails and names the available
+profiles rather than silently choosing the default. `--dispatch` is intentionally rejected
+for full-cycle entries; no profiles means legacy dispatch behavior remains unchanged.
+
 Two engine-safety policies were explicit product decisions on #464:
 
 - **Pid identity is hybrid-verified (decision 1, option C).** Every spawn records the

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

@@ -1 +1 @@
-{"version":3,"file":"batch-dispatch.d.ts","sourceRoot":"","sources":["../src/batch-dispatch.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"batch-dispatch.d.ts","sourceRoot":"","sources":["../src/batch-dispatch.ts"],"names":[],"mappings":"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"}

package/dist/batch-dispatch.js

@@ -1374,7 +1374,10 @@ function runValidate(deps, config, dispatch, batchId, now, result) {
         return;
     }
     const offender = outcome.offenders[0];
-    const { state: fixing, dispatch: fixDispatch } = (0, recovery_1.beginFixAttempt)(attributed, batchId, offender, rDeps, { config, tests: outcome.attributed.get(offender) ?? [] });
+    const { state: fixing, dispatch: fixDispatch } = (0, recovery_1.beginFixAttempt)(attributed, batchId, offender, rDeps, 
+    // #707: `dispatch` is the batch's own (profile-resolved) dispatch — the
+    // fix agent rides the same family the members ran on.
+    { config, tests: outcome.attributed.get(offender) ?? [], dispatch });
     deps.store.withLock((s) => ({
         state: applyBatchAndIssues(s, fixing, batchId, []),
         result: undefined,
@@ -1804,6 +1807,11 @@ function resumeBlockedGate(deps, config, dispatch, batchId, now) {
     const batch = (0, state_1.findBatch)(state, batchId);
     if (!batch)
         throw new types_1.SchedNotFoundError(`Batch not found: ${batchId}`);
+    // A gate recheck can immediately advance to the next provider dispatch, so
+    // it must use the batch's recorded profile rather than the engine default.
+    const batchDispatch = batch.dispatch_profile === null
+        ? dispatch
+        : (0, dispatch_1.resolveProfiledDispatch)(config, batch.dispatch_profile);
     if (batch.status !== 'blocked' || !batch.blocked_reason?.startsWith('gate-inconclusive:')) {
         // #677 review: the landing-failure blocks have no resume verb (same as
         // `suite-unreadable`) — name the actual reason and the operator path
@@ -1852,7 +1860,7 @@ function resumeBlockedGate(deps, config, dispatch, batchId, now) {
             outputTail: recheck.outputTail,
             durationMs: recheck.durationMs,
         }, now);
-        completeMemberGate(deps, config, dispatch, batchId, batch, memberIssue, now, result);
+        completeMemberGate(deps, config, batchDispatch, batchId, batch, memberIssue, now, result);
         return { outcome: 'skipped', capability: capabilityId, detail: excerpt };
     }
     recordMemberGate(deps, batchId, memberIssue, { id: capabilityId, ...recheck }, now);
@@ -1900,7 +1908,7 @@ function resumeBlockedGate(deps, config, dispatch, batchId, now) {
     if (recheck.outcome === 'task-failed') {
         const reason = `incremental-gate-failed:${capabilityId}`;
         writeGateLog(deps, batchId, capabilityId, memberIssue, recheck.outputTail);
-        evictMemberAndContinue(deps, config, dispatch, batchId, batch, memberIssue, {
+        evictMemberAndContinue(deps, config, batchDispatch, batchId, batch, memberIssue, {
             reason,
             detail: withExcerpt(`sched resume --batch: cap run ${capabilityId} reported task-failed on recheck`, excerpt),
         }, now, result);
@@ -1910,7 +1918,7 @@ function resumeBlockedGate(deps, config, dispatch, batchId, now) {
         issue: memberIssue,
         detail: `sched resume --batch: cap run ${capabilityId} reported ok on recheck`,
     });
-    completeMemberGate(deps, config, dispatch, batchId, batch, memberIssue, now, result);
+    completeMemberGate(deps, config, batchDispatch, batchId, batch, memberIssue, now, result);
     return { outcome: 'completed', capability: capabilityId };
 }
 /**
@@ -2791,6 +2799,81 @@ function teardownBatch(deps, batchId) {
 function runBatchTick(deps, config, dispatch) {
     const result = emptyResult();
     const now = deps.now();
+    // #707: each batch dispatches through ITS OWN recorded profile, not the
+    // engine's default. Successful resolution is cached per tick (per
+    // runBatchTick call); missing profiles are handled per batch. A profile that
+    // no longer resolves (config edited
+    // mid-run) never silently falls back — the silent fallback is precisely
+    // the #680 incident shape (a run that looked like one agent family,
+    // executed as another). The reaction depends on how far the batch got:
+    // - pre-merge (`dissolving` is a legal edge): DISSOLVE with reason
+    //   `dispatch-profile-missing:<name>` — loud, deterministic, one-shot, and
+    //   the members requeue as full-cycle units on the config default, which is
+    //   a coherent recovery rather than a mislabelled continuation.
+    // - post-merge (PR parked/merged — the product already shipped): dissolving
+    //   would discard a landed PR's bookkeeping, so the remaining dispatch (the
+    //   report agent) runs on the default and journals
+    //   `dispatch-profile-missing` once while it holds the decision open — a
+    //   bounded phase (deployed → reported), with the journal acting as the
+    //   durable deduplication record across ticks and process restarts.
+    const profileCache = new Map();
+    const missingProfileBatches = new Set();
+    const missingProfileNotices = new Set(deps.journal
+        .read()
+        .filter((event) => event.event === 'dispatch-profile-missing' && event.unit !== undefined)
+        .map((event) => event.unit));
+    const dispatchFor = (batch) => {
+        if (batch.dispatch_profile === null)
+            return dispatch;
+        const cached = profileCache.get(batch.dispatch_profile);
+        if (cached !== undefined)
+            return cached;
+        if (missingProfileBatches.has(batch.id))
+            return dispatch;
+        try {
+            const resolved = (0, dispatch_1.resolveProfiledDispatch)(config, batch.dispatch_profile);
+            profileCache.set(batch.dispatch_profile, resolved);
+            return resolved;
+        }
+        catch (err) {
+            if (!(err instanceof dispatch_1.DispatchProfileError))
+                throw err;
+            missingProfileBatches.add(batch.id);
+            const current = deps.store.load();
+            const fresh = (0, state_1.findBatch)(current, batch.id);
+            const dissolvable = fresh !== undefined && (0, state_1.allowedBatchTransitions)(fresh.status).includes('dissolving');
+            if (dissolvable) {
+                const liveSlot = slotFor(current, batch.id);
+                if (liveSlot !== undefined &&
+                    liveSlot.pid !== null &&
+                    deps.spawnDeps.isAlive(liveSlot.pid, liveSlot.pid_start ?? undefined)) {
+                    deps.spawnDeps.kill(liveSlot.pid, liveSlot.pid_start ?? undefined);
+                }
+                const outcome = (0, recovery_1.dissolveBatch)(current, batch.id, { strategy: 'full', reason: `dispatch-profile-missing:${batch.dispatch_profile}` }, recoveryDeps(deps, config, fresh, now));
+                deps.store.withLock((s) => ({
+                    state: applyBatchAndIssues(s, outcome.state, batch.id, outcome.requeued),
+                    result: undefined,
+                }));
+                teardownBatch(deps, batch.id);
+                result.failed.push(unit(batch.id));
+                // Resolution failed: clean up any batch/member worktrees, then skip
+                // this batch for the rest of the pass. No further arm can claim it.
+                // Do not cache a missing profile: every batch must receive its own
+                // dissolve/journal reaction rather than inheriting a cached default.
+                return null;
+            }
+            else {
+                const batchUnit = unit(batch.id);
+                if (!missingProfileNotices.has(batchUnit)) {
+                    journalEvent(deps, 'dispatch-profile-missing', batchUnit, {
+                        detail: `profile '${batch.dispatch_profile}' is no longer configured; the post-merge tail runs on the default dispatch`,
+                    });
+                    missingProfileNotices.add(batchUnit);
+                }
+                return dispatch;
+            }
+        }
+    };
     // #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
@@ -2822,7 +2905,12 @@ function runBatchTick(deps, config, dispatch) {
         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);
+            // #707: batch-setup dispatches through the batch's own profile too — it
+            // is the batch's first agent, not an engine-internal step.
+            const batchDispatch = dispatchFor(batch);
+            if (batchDispatch !== null) {
+                claimAndSetup(deps, config, batchDispatch, batchId, now, result);
+            }
         }
     }
     for (const batch of deps.store.load().batches) {
@@ -2837,20 +2925,29 @@ function runBatchTick(deps, config, dispatch) {
         // `abandonBatch` that stops one from being created: it also REPAIRS state
         // files that already carry a leaked slot, which is the only way an
         // operator gets those three hours of held capacity back.
-        if (slot && types_1.TERMINAL_BATCH_STATUSES.has(batch.status)) {
-            deps.store.withLock((s) => ({
-                state: (0, state_1.releaseBatchSlot)(s, batch.id, now),
-                result: undefined,
-            }));
-            journalEvent(deps, 'slot-released', unit(batch.id), {
-                slot: slot.id,
-                detail: `terminal batch (${batch.status}) held slot ${slot.id}`,
-            });
+        if (types_1.TERMINAL_BATCH_STATUSES.has(batch.status)) {
+            if (slot) {
+                deps.store.withLock((s) => ({
+                    state: (0, state_1.releaseBatchSlot)(s, batch.id, now),
+                    result: undefined,
+                }));
+                journalEvent(deps, 'slot-released', unit(batch.id), {
+                    slot: slot.id,
+                    detail: `terminal batch (${batch.status}) held slot ${slot.id}`,
+                });
+            }
             continue;
         }
+        // #707: resolve this batch's profile once per pass — or dissolve/fall
+        // back loudly when it no longer resolves (see `dispatchFor` above).
+        // Terminal batches are skipped before this call so a removed profile does
+        // not generate a missing-profile event on every later tick.
+        const batchDispatch = dispatchFor(batch);
+        if (batchDispatch === null)
+            continue;
         if (slot && (slot.status === 'running' || slot.status === 'assigned')) {
             if (batch.status === 'executing') {
-                reconcileMemberSlot(deps, config, dispatch, batch.id, slot, now, result);
+                reconcileMemberSlot(deps, config, batchDispatch, batch.id, slot, now, result);
             }
             else if (batch.status === 'fixing') {
                 reconcileFixSlot(deps, config, batch.id, slot, now, result);
@@ -2867,7 +2964,7 @@ function runBatchTick(deps, config, dispatch) {
             continue; // live but neither running/assigned (e.g. mid-verify) — next tick
         if (batch.status === 'validating') {
             // A local suite run, not a provider dispatch — unaffected by `paused`.
-            runValidate(deps, config, dispatch, batch.id, now, result);
+            runValidate(deps, config, batchDispatch, batch.id, now, result);
             continue;
         }
         // #629: every branch below spawns a provider agent — hold the wedge
@@ -2876,7 +2973,7 @@ function runBatchTick(deps, config, dispatch) {
         if (paused)
             continue;
         if (batch.status === 'deployed') {
-            spawnReportAgent(deps, config, dispatch, batch.id, now, result);
+            spawnReportAgent(deps, config, batchDispatch, batch.id, now, result);
         }
         else if (batch.status === 'executing') {
             // A prior spawn threw, or `claimAndSpawn` found zero free capacity —
@@ -2887,11 +2984,11 @@ function runBatchTick(deps, config, dispatch) {
             // pre-checks BEFORE any pool/git work, so a full scheduler (or stale
             // member context) exits here without exec'ing, and `claimAndSpawn`
             // remains the authoritative capacity gate.
-            spawnMemberContinuation(deps, config, dispatch, batch.id, now, result);
+            spawnMemberContinuation(deps, config, batchDispatch, batch.id, now, result);
         }
         else if (batch.status === 'reviewing' || batch.status === 'shipping') {
             // Same wedge, for a dead-or-never-claimed tail agent.
-            spawnTailAgent(deps, config, dispatch, batch.id, now, result);
+            spawnTailAgent(deps, config, batchDispatch, batch.id, now, result);
         }
         else if (batch.status === 'fixing') {
             // `beginFixAttempt` already recorded this member's ONE attempt as