llm-relay 0.83.2 → 0.84.0

package/dist/mcp/server.d.ts

@@ -1,25 +1,3 @@
-/**
- * The `llm-relay mcp` server — one dispatch verb, callable from any MCP host.
- *
- * WHAT PROBLEM THIS SOLVES. `llm-relay dispatch --next-command` answers "which lane" correctly and
- * then hands the caller a COMMAND to execute. Two things go wrong with that, and both are measured:
- *
- * 1. The answer's SHAPE depends on the host. A routed Claude Code session gets a `target:` spec to
- *    address as a subagent; a bypassed or headless one gets a `run:` command. The caller must
- *    branch on mechanism, which is exactly what the owner asked never to be necessary.
- * 2. Executing the command correctly is hard. `lane-runner.ts` lists five distinct measured ways
- *    to get it wrong, each of which cost a release or a wasted lane run.
- *
- * This server removes both. Every host makes the same call and receives an ANSWER, not a command.
- *
- * WHERE IT RUNS. As a stdio child of the HOST, launched as `llm-relay mcp`. It is NOT part of the
- * relay daemon, and it answers no HTTP. The daemon's rule that no HTTP turn may spawn a lane is
- * therefore untouched — this process is the host's own spawn mechanism wearing a protocol.
- *
- * SEAMS. Every environment dependency is injected (`buildView`, `spawn`, `now`, `cwd`), so the
- * suite exercises the whole surface without spawning a real lane or spending real quota. Same
- * discipline as `lane-quota-probe.ts` and `availability-snapshot.ts`.
- */
 import type { Config } from "../config.js";
 import type { DispatchView } from "../dispatch.js";
 import { type TreeSnapshotReader } from "./tree-delta.js";
@@ -43,13 +21,20 @@ export type DispatchViewBuilder = (opts: {
     tier: string | undefined;
     lane: string | undefined;
     /**
-     * How this dispatch will run its lanes, so the relay hands back budgets measured in the SAME mode
+     * How this dispatch will run its lanes, so the relay hands back run times measured in the SAME mode
      * (`DispatchMode`). Absent from `dispatch_lanes`, which runs nothing.
      */
     mode?: DispatchMode | undefined;
     /** A routing spec to run as its own one-lane view instead of the ladder (`dispatch`'s `model`). */
     model?: string | undefined;
 }) => Promise<DispatchView>;
+/** A lane's traffic as the relay daemon reports it. */
+export interface LaneTraffic {
+    /** Requests with the lane's tag the daemon is serving now. */
+    inFlight: number;
+    /** Epoch ms of the tag's last request start, response write or request end. */
+    lastActivityAt: number;
+}
 export interface McpServerDeps {
     config: Config;
     buildView: DispatchViewBuilder;
@@ -67,6 +52,11 @@ export interface McpServerDeps {
     allowedRoots?: readonly string[];
     /** Reads `git status` for the tree delta (`tree-delta.ts`); defaults to the real git reader. */
     treeSnapshot?: TreeSnapshotReader;
+    /**
+     * Reads a lane's live traffic from the relay daemon (`GET /dispatch/activity`, `lane-activity.ts`).
+     * Absent, or null for a tag, means no signal from the daemon — never "idle".
+     */
+    readLaneActivity?: (tag: string) => Promise<LaneTraffic | null>;
     /** The platform whose environment rules the lane launcher applies; defaults to `process.platform`. */
     platform?: NodeJS.Platform;
     maxDepth?: number;
@@ -180,12 +170,13 @@ export declare const LANE_LADDER_EXHAUSTED_ADVICE: string;
  */
 export declare const LANE_LADDER_PARTIAL_ADVICE: string;
 /**
- * What a caller is told when the walk STOPPED a lane at its time budget and nothing answered after.
+ * What a caller is told when the walk STOPPED an idle lane and nothing answered after.
  *
- * ⚠ The stopped lane did not fail: it was still working when the walk moved on. So "every dispatch
- * lane has now been tried" was false there, and it ended the caller's use of dispatch for a task the
- * stopped lane would have finished (`docs/dispatch-giveup-diagnosis-2026-09-10.md` §5). A NAMED lane
- * runs with no budget, so this names the call that lets it finish.
+ * ⚠ The stopped lane did not fail on its own: the walk stopped it because it showed no activity the
+ * relay could see. So "every dispatch lane has now been tried" is false there, and would end the
+ * caller's use of dispatch for a task the lane might still finish
+ * (`docs/dispatch-giveup-diagnosis-2026-09-10.md` §5). A NAMED lane is never stopped for idleness,
+ * so this names the call that lets it run to its own timeout.
  */
 export declare function laneStoppedAdvice(laneId: string): string;
 /**
@@ -194,11 +185,8 @@ export declare function laneStoppedAdvice(laneId: string): string;
  * jobs 0023 and 0024, which each ran one forced lane and were told to stop delegating.
  */
 export declare const FORCED_LANE_ADVICE: string;
-/**
- * How recent a lane's output or file change must be for the walk to keep it past its budget, and
- * how long each extension lasts.
- */
-export declare const LANE_ACTIVITY_WINDOW_MS = 60000;
+/** How often the walk checks a running lane for activity. */
+export declare const IDLE_POLL_MS = 15000;
 /**
  * MCP clients (`initialize` `clientInfo.name`) measured to survive a long tool call, so `dispatch`
  * may wait for the answer the way the host's own subagent does, up to `routing.mcp.blockingWaitMs`.
@@ -236,6 +224,8 @@ export declare class McpDispatchServer {
     private readonly cancellable;
     /** The `git status` each running agent-mode job started from, with the caller's scope. */
     private readonly trees;
+    /** The activity tag (`lane-activity.ts`) of the lane each running job has started last. */
+    private readonly activityTags;
     constructor(deps: McpServerDeps);
     /**
      * Feed raw stdin bytes. Complete messages are handled concurrently; a partial tail is carried
@@ -321,7 +311,7 @@ export declare class McpDispatchServer {
      *
      * `view.order` is the ONE definition of selection order (`dispatch.ts`). With the walk turned off
      * — or with a view that carries no order — this collapses to EXACTLY the pre-walk behaviour: the
-     * single lane the view named as `next`, tried once, with no attempt budget.
+     * single lane the view named as `next`, tried once, and never stopped for idleness.
      *
      * ⚠ The `Array.isArray` test is a VERSION SKEW guard, not defensive noise. `buildView` reaches the
      * running daemon over HTTP, and a daemon started before this field existed answers without it — an
@@ -364,15 +354,15 @@ export declare class McpDispatchServer {
     /** The snapshot reader, contained: a throwing injected reader reads as "no git tree". */
     private readTree;
     /**
-     * Does the lane at position `i` run with NO attempt budget? The last lane does — there is nowhere
-     * to move to. So does a lane whose later lanes are all unlikely to answer: each is on a streak of
-     * `LANE_UNRELIABLE_STREAK` own failures or more, or marked `failing`. Stopping a lane that may
-     * still answer in order to reach those trades an answer for a near-certain failure — measured
-     * 2026-09-10, when the walk stopped `free-pool` at 90 s to try lanes that had answered 0 of 12,
+     * Is the lane at position `i` never stopped, even when idle? The last lane is not — there is
+     * nowhere to move to. Nor is a lane whose later lanes are all unlikely to answer: each is on a
+     * streak of `LANE_UNRELIABLE_STREAK` own failures or more, or marked `failing`. Stopping a lane
+     * that may still answer in order to reach those trades an answer for a near-certain failure —
+     * measured 2026-09-10, when the walk stopped `free-pool` to try lanes that had answered 0 of 12,
      * 0 of 34 and 0 of 21 runs (`docs/dispatch-giveup-diagnosis-2026-09-10.md` §1). A lane with no
      * record counts as reliable: unmeasured is no opinion, never a failure.
      */
-    private budgetWithheld;
+    private stopWithheld;
     /**
      * A `cli` rung whose configured `maxConcurrent` this MCP server process has already reached for
      * — SKIP it for this walk rather than starting a competing process. Records the skip as an
@@ -397,13 +387,14 @@ export declare class McpDispatchServer {
      */
     private skipIfBelowTier;
     /**
-     * Is the running lane still WORKING? A reason string when it is, else null. Evidence, in order: the
-     * lane wrote output inside `LANE_ACTIVITY_WINDOW_MS`; its git tree changed since the last reading;
-     * a dirty file changed inside the window. `claude -p` buffers its whole answer until exit, so for
-     * the free pool the tree is the only evidence there is. No evidence (answer mode, a cwd outside a
-     * git tree) means not working, and the budget applies as before.
+     * The running lane's most recent ACTIVITY, or null when nothing was seen. Evidence: a request with
+     * the lane's tag in flight at the relay daemon (that is activity NOW), the daemon's last traffic
+     * for the tag, the lane's own last output, and its git working tree (a change since the last
+     * reading is activity now; otherwise the newest dirty file's mtime). `claude -p` holds its output
+     * until exit, so for a pool lane the daemon's traffic is the signal that matters. The tree is read
+     * only when nothing newer than one poll was seen, because each reading runs `git status`.
      */
-    private laneStillWorking;
+    private latestActivity;
     /**
      * For a read-only dispatch, the invocation this lane will be spawned with — its own CLI's
      * read-only tool binding (`readOnlyInvoke`) — or a SKIP when its CLI offers none. Recorded exactly
@@ -417,11 +408,12 @@ export declare class McpDispatchServer {
      */
     private bindReadOnlyOrSkip;
     /**
-     * Run ONE lane, optionally bounded by an attempt budget. Returns what happened; never throws.
+     * Run ONE lane. Returns what happened; never throws.
      *
-     * With `budgetMs === null` the lane is simply awaited — its own `timeoutMs` is the only bound.
-     * With a budget, the lane races a timer: if the timer wins, the lane is KILLED and reported as
-     * `abandoned`.
+     * With `idleMs === null` the lane is simply awaited — its own `timeoutMs` is the only bound.
+     * Otherwise the walk checks the lane every `IDLE_POLL_MS`, and when it has shown no activity
+     * (`latestActivity`) for `idleMs`, the lane is KILLED and reported as `abandoned`. How long the
+     * lane has run does not matter: a slow lane that still works is never stopped.
      *
      * ⚠ It kills rather than hedges. The HTTP request path hedges — it starts a second attempt
      * beside the first — and that is deliberate there, bounded to free deployments by an owner

package/dist/mcp/server.js

@@ -1,6 +1,8 @@
+import { randomUUID } from "node:crypto";
+import { LANE_ACTIVITY_HEADER } from "../lane-activity.js";
 import { DEFAULT_MCP_BLOCKING_WAIT_MS, DEFAULT_MCP_MAX_WAIT_MS, EFFORT_LEVELS } from "../config-types.js";
 import { isToolUseBlock } from "../anthropic.js";
-import { formatAttemptBudget, formatLaneStats, isPassThroughSpec, LANE_UNRELIABLE_STREAK, mcpPassThroughReason } from "../dispatch.js";
+import { formatLaneStats, isPassThroughSpec, LANE_UNRELIABLE_STREAK, mcpPassThroughReason } from "../dispatch.js";
 import { laneOfRung } from "../lane-manifest.js";
 import { defaultTreeSnapshot, newestChangeMs, renderTreeDelta, sameTree, } from "./tree-delta.js";
 import { estimateTokensFromCharacters } from "../metadata.js";
@@ -29,7 +31,7 @@ export const MCP_INSTRUCTIONS = "Use dispatch from every MCP host — Claude, Co
     "Desktop rejects that child model before reaching the relay and ignores its custom provider. " +
     "Call dispatch instead. If this MCP server is unavailable, run `llm-relay dispatch " +
     "--next-command -t <task>` and follow its returned command or target; do not guess from the host.\n\n" +
-    "Let dispatch choose the lane. If a lane is slow or silent, dispatch moves to the next one " +
+    "Let dispatch choose the lane. If a lane stops showing activity, dispatch moves to the next one " +
     "itself and prefers the lane that answered on your next call. Follow the advice at the end of a " +
     "reply: when it says a lane was stopped while it was still working, dispatch again with that " +
     "lane named so it can finish; when it says every lane ran and failed, do the work here — " +
@@ -51,8 +53,8 @@ const TOOLS = [
             "default lane spends none of this session's subscription quota and saves its context. " +
             "Pass model to run one specific model (a routing spec such as deepseek/deepseek-flash or " +
             "pool/high) as its own lane, with no walk. Otherwise it picks the lane from " +
-            "the configured ladder unless you name one, and WALKS that ladder for you: a lane that does " +
-            "not answer inside its budget is stopped and the next one is started, and the lane that " +
+            "the configured ladder unless you name one, and WALKS that ladder for you: a lane that shows " +
+            "no activity for a while is stopped and the next one is started, and the lane that " +
             "answers is preferred next time. Runs the lane correctly — working directory, " +
             "environment and idle timeouts are handled here, so you never build a command line. If the " +
             "lane is still running, returns a jobId to poll with dispatch_status — it blocks at most " +
@@ -336,8 +338,10 @@ function describeJob(job, now) {
         head.push(`read-only: ${job.readOnly.binding}`);
     if (job.launch?.length)
         head.push(`launch: ${job.launch.join("; ")}`);
-    if (job.extended?.length)
-        head.push(`extended: ${job.extended.join("; ")}`);
+    if (job.status === "running" && job.lastActive) {
+        const ago = Math.max(0, Math.round((now - job.lastActive.at) / 1000));
+        head.push(`last activity: ${ago}s ago (${job.lastActive.source})`);
+    }
     const usually = runningTimeToAnswer(job);
     if (usually !== null)
         head.push(usually);
@@ -358,9 +362,9 @@ export const LANE_LADDER_PARTIAL_ADVICE = "Lanes remain untried: this dispatch s
     + "reach them — the lanes above are now demoted, so it will pick different ones — or do the "
     + "work in this session.";
 export function laneStoppedAdvice(laneId) {
-    return (`The walk stopped lane "${laneId}" at its time budget while it was still working — it did not ` +
-        `fail. To let it finish, call dispatch again with lane: "${laneId}" and the same tier and mode (a ` +
-        "named lane runs with no budget, only its own timeout), or do the work in this session.");
+    return (`The walk stopped lane "${laneId}" because it showed no activity for a while — it did not fail ` +
+        `on its own. To let it run to its own timeout, call dispatch again with lane: "${laneId}" and the ` +
+        "same tier and mode (a named lane is never stopped for idleness), or do the work in this session.");
 }
 export const FORCED_LANE_ADVICE = "Only the lane you named was tried, and it did not answer. Call dispatch without lane or model to "
     + "let the walk try the other lanes, or do the work in this session.";
@@ -428,12 +432,12 @@ function failedOutcome(message) {
         semanticFailure: message,
     };
 }
-function attemptReason(status, outcome, elapsedMs, budgetMs) {
+function attemptReason(status, outcome, idleMs) {
     if (status === "completed")
         return undefined;
     if (status === "abandoned") {
-        const budget = budgetMs === null ? `${Math.round(elapsedMs / 1000)}s` : `${Math.round(budgetMs / 1000)}s`;
-        return `no answer within the ${budget} walk budget, so the next lane was started`;
+        const quiet = idleMs === null ? "a long time" : `${Math.round(idleMs / 1000)}s`;
+        return `no activity for ${quiet} (no relay traffic, output or file change), so the next lane was started`;
     }
     if (outcome.semanticFailure !== undefined)
         return outcome.semanticFailure;
@@ -451,10 +455,26 @@ function flagValue(args, flag) {
     const joined = args.find((a) => a.startsWith(`${flag}=`));
     return joined === undefined ? null : joined.slice(flag.length + 1);
 }
-export const LANE_ACTIVITY_WINDOW_MS = 60_000;
-function budgetTimer(ms) {
+export const IDLE_POLL_MS = 15_000;
+function withActivityHeader(existing, tag) {
+    const line = `${LANE_ACTIVITY_HEADER}: ${tag}`;
+    return existing === undefined || existing.trim() === "" ? line : `${existing}\n${line}`;
+}
+function newestActivity(seen) {
+    let best = null;
+    for (const s of seen) {
+        if (typeof s.at === "number" && Number.isFinite(s.at) && (best === null || s.at > best.at)) {
+            best = { at: s.at, source: s.source };
+        }
+    }
+    return best;
+}
+function newActivityTag() {
+    return randomUUID().replaceAll("-", "");
+}
+function pollTimer(ms) {
     return new Promise((resolve) => {
-        const t = setTimeout(() => resolve({ kind: "budget" }), ms);
+        const t = setTimeout(() => resolve({ kind: "poll" }), ms);
         if (typeof t.unref === "function")
             t.unref();
     });
@@ -484,8 +504,6 @@ function laneSummary(lane, inFlight) {
         bits.push(`unreachable: ${lane.unreachable}`);
     if (lane.note)
         bits.push(lane.note);
-    if (lane.attemptBudget)
-        bits.push(formatAttemptBudget(lane.attemptBudget));
     bits.push(...laneEvidenceBits(lane));
     if (lane.maxConcurrent !== null && lane.maxConcurrent !== undefined) {
         bits.push(`in flight: ${inFlight} of ${lane.maxConcurrent}`);
@@ -516,6 +534,7 @@ export class McpDispatchServer {
     clientName;
     cancellable = new Map();
     trees = new Map();
+    activityTags = new Map();
     constructor(deps) {
         this.deps = deps;
         this.jobs = new LaneJobStore(deps.journal ?? nullJobJournal, deps.archive ?? nullJobArchive);
@@ -685,7 +704,11 @@ export class McpDispatchServer {
         }
         const lines = view.ladder.map((l) => laneSummary(l, this.jobs.inFlight(l.id)));
         const next = view.next ? `\n\nnext: ${view.next.id} — ${view.reason}` : `\n\nnext: none — ${view.reason}`;
-        return textResult(`tier: ${view.tier ?? "default"}\n\n${lines.join("\n")}${next}`);
+        const walk = this.deps.config.routing?.dispatchWalk;
+        const rule = walk?.enabled === true
+            ? `\nwalk: a lane is stopped after ${Math.round(walk.idleMs / 1000)}s with no activity (relay traffic, output or file change); the last lane is never stopped`
+            : "\nwalk: off — only the first lane runs";
+        return textResult(`tier: ${view.tier ?? "default"}${rule}\n\n${lines.join("\n")}${next}`);
     }
     toolStatus(args) {
         const jobId = readString(args, "jobId");
@@ -793,7 +816,7 @@ export class McpDispatchServer {
             scope: readStringArray(args, "scope"),
             tier: view.tier ?? undefined,
             timeoutMs: readNumber(args, "timeoutMs") ?? DEFAULT_LANE_TIMEOUT_MS,
-            attemptMs: walk !== null ? walk.attemptMs : null,
+            idleMs: walk !== null ? walk.idleMs : null,
             system: readString(args, "system"),
             schema: readRecord(args, "schema"),
             maxTokens: readNumber(args, "maxTokens"),
@@ -817,11 +840,13 @@ export class McpDispatchServer {
         const waitMs = resolveWaitMs(args["waitMs"], ceiling);
         if ("refusal" in waitMs)
             return textResult(waitMs.refusal, true);
-        const settled = this.runWalk(job.id, view, ordered, task, opts).catch(async (e) => {
+        const settled = this.runWalk(job.id, view, ordered, task, opts)
+            .catch(async (e) => {
             await this.recordTreeDelta(job.id);
             this.jobs.fail(job.id, `dispatch walk failed: ${e.message}`);
             return "done";
-        });
+        })
+            .finally(() => this.activityTags.delete(job.id));
         return this.awaitOrPoll(job.id, settled, waitMs.waitMs, {
             clamp: waitMs.clamped ? { requested: waitMs.requested, ceiling, key: ceilingKey } : undefined,
             progressToken: blocking?.progress === true ? ctx.progressToken : undefined,
@@ -862,10 +887,9 @@ export class McpDispatchServer {
             if (readOnly.bound !== undefined)
                 this.jobs.noteReadOnly(jobId, lane.id, readOnly.bound.binding);
             const isLast = i === laneIds.length - 1;
-            const noBudget = this.budgetWithheld(view, laneIds, i);
+            const idleMs = this.stopWithheld(view, laneIds, i) ? null : opts.idleMs;
             const startedAt = this.now();
-            const budgetMs = lane.attemptBudget?.ms ?? opts.attemptMs;
-            const outcome = await this.runOneLane(jobId, lane, task, opts, noBudget ? null : budgetMs, readOnly.bound?.invoke);
+            const outcome = await this.runOneLane(jobId, lane, task, opts, idleMs, readOnly.bound?.invoke);
             const elapsedMs = Math.max(0, this.now() - startedAt);
             if (this.jobs.get(jobId)?.status === "cancelled")
                 return "done";
@@ -878,7 +902,7 @@ export class McpDispatchServer {
                 abandoned: outcome.abandoned,
                 semanticFailure: outcome.semanticFailure,
             });
-            const reason = attemptReason(status, outcome, elapsedMs, noBudget ? null : budgetMs);
+            const reason = attemptReason(status, outcome, idleMs);
             this.jobs.recordAttempt(jobId, {
                 laneId: lane.id,
                 spec: lane.spec,
@@ -936,7 +960,7 @@ export class McpDispatchServer {
             return null;
         }
     }
-    budgetWithheld(view, laneIds, i) {
+    stopWithheld(view, laneIds, i) {
         return !laneIds.slice(i + 1).some((id) => {
             const later = view.ladder.find((l) => l.id === id);
             return later !== undefined && later.failing === undefined && (later.recentFailures ?? 0) < LANE_UNRELIABLE_STREAK;
@@ -980,27 +1004,31 @@ export class McpDispatchServer {
         this.jobs.noteSkippedLane(jobId);
         return true;
     }
-    async laneStillWorking(jobId) {
+    async latestActivity(jobId) {
         const now = this.now();
-        const lastOutput = this.jobs.get(jobId)?.activity?.lastOutputAt;
-        if (typeof lastOutput === "number" && now - lastOutput <= LANE_ACTIVITY_WINDOW_MS) {
-            return `it wrote output ${Math.round((now - lastOutput) / 1000)}s ago`;
+        const seen = [
+            { at: this.jobs.get(jobId)?.activity?.lastOutputAt, source: "lane output" },
+        ];
+        const tag = this.activityTags.get(jobId);
+        if (tag !== undefined && this.deps.readLaneActivity !== undefined) {
+            const traffic = await this.deps.readLaneActivity(tag).catch(() => null);
+            seen.push(traffic !== null && traffic.inFlight > 0
+                ? { at: now, source: "a request in flight at the relay" }
+                : { at: traffic?.lastActivityAt, source: "relay traffic" });
         }
+        const early = newestActivity(seen);
+        if (early !== null && now - early.at < IDLE_POLL_MS)
+            return early;
         const tree = this.trees.get(jobId);
-        if (tree === undefined)
-            return null;
-        const reading = await this.readTree(tree.cwd);
-        if (reading === null)
-            return null;
-        const previous = tree.lastSeen ?? tree.before;
-        tree.lastSeen = reading;
-        if (!sameTree(previous, reading))
-            return "its working tree changed";
-        const newest = newestChangeMs(tree.cwd, reading);
-        if (newest !== null && now - newest <= LANE_ACTIVITY_WINDOW_MS) {
-            return `a file in its working tree changed ${Math.max(0, Math.round((now - newest) / 1000))}s ago`;
+        const reading = tree === undefined ? null : await this.readTree(tree.cwd);
+        if (tree !== undefined && reading !== null) {
+            const previous = tree.lastSeen ?? tree.before;
+            tree.lastSeen = reading;
+            seen.push(sameTree(previous, reading)
+                ? { at: newestChangeMs(tree.cwd, reading), source: "a file change" }
+                : { at: now, source: "a working tree change" });
         }
-        return null;
+        return newestActivity(seen);
     }
     bindReadOnlyOrSkip(jobId, lane, opts) {
         if (!opts.readOnly)
@@ -1022,7 +1050,8 @@ export class McpDispatchServer {
         this.jobs.noteSkippedLane(jobId);
         return { skipped: true };
     }
-    async runOneLane(jobId, lane, task, opts, budgetMs, invoke) {
+    async runOneLane(jobId, lane, task, opts, idleMs, invoke) {
+        const attemptStart = this.now();
         const started = this.startLane(jobId, lane, task, opts, invoke);
         if ("refusal" in started)
             return { run: emptyRun(), abandoned: false, refusal: started.refusal };
@@ -1032,21 +1061,23 @@ export class McpDispatchServer {
             abandoned: false,
             semanticFailure: e.message,
         }));
-        if (budgetMs === null)
+        if (idleMs === null)
             return guarded;
         const settled = guarded.then((o) => ({ kind: "settled", outcome: o }));
-        let waitMs = budgetMs;
+        let lastActive = attemptStart;
         for (;;) {
-            const raced = await Promise.race([settled, budgetTimer(waitMs)]);
+            const raced = await Promise.race([settled, pollTimer(Math.min(IDLE_POLL_MS, idleMs))]);
             if (raced.kind === "settled")
                 return raced.outcome;
             if (this.jobs.get(jobId)?.status !== "running")
                 break;
-            const working = await this.laneStillWorking(jobId);
-            if (working === null)
+            const seen = await this.latestActivity(jobId);
+            if (seen !== null && seen.at > lastActive) {
+                lastActive = seen.at;
+                this.jobs.noteLastActivity(jobId, seen.at, seen.source);
+            }
+            if (this.now() - lastActive >= idleMs)
                 break;
-            this.jobs.noteExtension(jobId, lane.id, `${lane.id} kept past its ${Math.round(budgetMs / 1000)}s budget because ${working}`);
-            waitMs = LANE_ACTIVITY_WINDOW_MS;
         }
         started.kill();
         return { run: emptyRun(), abandoned: true };
@@ -1061,7 +1092,9 @@ export class McpDispatchServer {
             }
             const controller = new AbortController();
             const signal = AbortSignal.any([AbortSignal.timeout(opts.timeoutMs), controller.signal]);
-            const result = this.runAnswerFetch(lane.spec, task, opts, signal).then((o) => {
+            const tag = newActivityTag();
+            this.activityTags.set(jobId, tag);
+            const result = this.runAnswerFetch(lane.spec, task, opts, signal, tag).then((o) => {
                 const semanticFailure = o.semanticFailure === undefined && !o.run.timedOut && isContentEmpty(o.run.stdout)
                     ? EMPTY_OUTPUT_REASON
                     : o.semanticFailure;
@@ -1093,6 +1126,9 @@ export class McpDispatchServer {
         const expansion = expandEnvReferences(applyLaneEnv(process.env, invoke.env), this.deps.platform);
         const env = expansion.env;
         env[DEPTH_ENV] = String(opts.depth + 1);
+        const tag = newActivityTag();
+        this.activityTags.set(jobId, tag);
+        env["ANTHROPIC_CUSTOM_HEADERS"] = withActivityHeader(env["ANTHROPIC_CUSTOM_HEADERS"], tag);
         this.jobs.noteLaunch(jobId, [...expansion.notes, ...(agy === null ? [] : [agy.note])]);
         const startedAt = this.now();
         this.jobs.beginAttemptActivity(jobId, startedAt);
@@ -1186,7 +1222,7 @@ export class McpDispatchServer {
             });
         }
     }
-    async runAnswerFetch(spec, task, opts, signal) {
+    async runAnswerFetch(spec, task, opts, signal, activityTag) {
         const url = relayLoopbackUrl(this.deps.config, "/v1/messages");
         const body = {
             model: spec,
@@ -1207,6 +1243,7 @@ export class McpDispatchServer {
                     "anthropic-version": "2023-06-01",
                     "content-type": "application/json",
                     "x-api-key": "dummy",
+                    [LANE_ACTIVITY_HEADER]: activityTag,
                 },
                 body: JSON.stringify(body),
                 signal,