pi-crew 0.9.60 → 0.9.62

package/CHANGELOG.md

@@ -3,10 +3,24 @@
 > **Note:** `atomic-write-v2.ts` / `AtomicWriter` mentioned in historical entries below was consolidated into `atomic-write.ts` as of v0.9.42. This changelog is preserved as historical record — the migration was completed (the v2 class was never adopted; v1 won on simplicity + symlink-safety + link+unlink atomicity). See `docs/migration/atomic-write-v2-migration.md` for the decision rationale.
 
 
+## [0.9.62] — provider-quota attribution per live-session agent + dead-worker alert re-fire fix (2026-08-06)
+
+### Bug fixes
+
+- **Provider-quota responses were attributed to the wrong provider in the opt-in `live-session` runtime.** pi's `after_provider_response` event carries no provider/sessionId, so quota was keyed off the shared module-scoped `currentSessionModel()`: a provider-B response (e.g. a 429) was recorded under the main session's anchor provider A — mis-deprioritizing A, or overwriting a genuine exhaustion signal so the “deprioritize exhausted providers” contract was not reliably honored. (Only reachable via the opt-in `live-session` runtime; the default `child-process` runtime is unaffected since each worker is its own process with anchor==serving provider.) Fix: carry each in-process live agent's resolved model through `AsyncLocalStorage` and attribute quota from it (`resolveProviderForResponse()`, `src/runtime/model/session-model.ts`); **skip** attribution (rather than guess) when live agents are active but the async context is absent; the default `child-process` path is byte-identical to before. Hardening from review: `unregisterLiveAgentModel` now runs **first** in the live-session `finally` block (a thrown `terminateLiveAgent` on the user-cancel path previously skipped it, permanently blinding quota process-wide via `hasActiveLiveAgents()` stuck `true`); `liveAgentModels` is capped at 5,000 entries matching `MAX_LIVE_AGENTS`. Tests in `test/unit/runtime/model/live-agent-quota-attribution.test.ts`. Investigation/spec in `docs/bugs/model-quota-attribution.md`.
+- **Dead-worker dashboard alert re-fired every 5 min for already-terminal runs.** A stale snapshot cache (not auto-invalidated when a run transitions to terminal) kept task status as "running" with an aged heartbeat, so the health loop re-classified it as dead and re-emitted the alert every 5 min; and there was no dismiss/clear path for health notifications. Fix: (1) the health loop in `renderTick` now re-verifies each run against a FRESH manifest-cache read before emitting; terminal runs are skipped and their stale snapshot is purged; (2) `NotificationDescriptor` gains an optional `clear` flag — when a run goes terminal, previously-emitted `recovery_dead_workers` / `recovery_missing_heartbeat` notifications are cleared and their cooldown entries are removed. Genuinely running runs with stale workers still alert (regression-guarded). Tests in `notification-router.test.ts` and `heartbeat-aggregator.test.ts`. Investigation in `docs/bugs/dead-worker-alert-refire.md`.
+
+## [0.9.61] — bundle republish: bug-44 fix shipped in dist (2026-08-05)
+
+### Bug fixes
+
+- **Bug-44 fix was missing from the v0.9.60 npm bundle (hot-fix republish).** The source-level fix for GitHub #44 (chain run fails fast when `workflow:"chain"` is forwarded to steps) landed in commit `5b43d556`, but the published `dist/index.mjs` was built from a stale source tree *before* the fix, so users installing `pi-crew@0.9.60` got the old buggy bundle (the chain runner still forwarded `workflow` to steps). v0.9.61 rebuilds the bundle with the fix included and verified (`grep` for the reject message + fallback logic now matches in `dist/index.mjs`). No source changes — purely a corrected bundle republish.
+
 ## [0.9.60] — subagent model routing: live-session model tracking, fallback policy, quota-aware ordering + iterative-audit hardening (2026-08-05)
 
 ### Bug fixes
 
+- **Chain run fails fast (~58 ms) with no error when `workflow:"chain"` is forwarded to steps (GitHub #44).** `chain-dispatch.ts` forwarded `params.workflow` (="chain") into every step's executor overrides; `chain-executor.ts` passed it through to each step's `handleRun`, which then executed the dispatcher-only `chain` workflow via the normal `executeTeamRun` path. Since `chain.workflow.md` is a documentation file (not a runnable workflow — it parses to 10 doc-heading steps with unknown roles), validation failed fast with a confusing empty error. Fix: (1) `chain-dispatch.ts` no longer forwards `workflow` (a chain has no per-step workflow; steps use the team's defaultWorkflow); (2) `chain-executor.ts` defensively drops a `"chain"` workflow override; (3) `run.ts` falls back to the team's default workflow when `workflow="chain"` is requested without a `chain` param; (4) `handleChainRun` rejects `workflow:"chain"` with a clear message. Regression tests added in `chain-executor.test.ts`.
 - **Subagent model "jumped" to whatever a previous session had saved.** `ctx.model` is the session's *saved* model, not the live one. A session that restored stale state could report `anthropic/claude-sonnet-4-5` while actually running `minimax/MiniMax-M3`. Subagents inheriting the parent model (`model: false`, which every builtin agent uses) therefore landed on the wrong model. Fix: track the live model via pi's `model_select` event (`src/runtime/model/session-model.ts`) and use it as the parent model for all spawn paths.
 - **Live-session path silently discarded `ctx.model`.** `resolveParentModelFromRegistry` only accepted strings; `ctx.model` is a pi `Model` object. Every live-session subagent that inherited the parent model fell through to `getAvailable()[0]` instead. Fix: accept both objects and strings via `modelRefToString`.
 - **Background/async runs lost the caller's model context.** A detached background run has no `ExtensionContext`, so it lost the `model=` override, the inherited session model, and the auth-filtered model catalogue — silently routing to whatever `models.json` listed first. Fix: persist `modelContext` (override / parent model / available models) on the manifest at dispatch time and re-hydrate it in `background-runner`.

package/dist/index.mjs

@@ -22303,6 +22303,32 @@ var init_model_fallback = __esm({
 });
 
 // src/runtime/model/session-model.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+function registerLiveAgentModel(agentId, model) {
+  if (liveAgentModels.size >= MAX_LIVE_AGENT_MODELS && !liveAgentModels.has(agentId)) {
+    const oldestKey = liveAgentModels.keys().next().value;
+    if (oldestKey !== void 0) {
+      logInternalError(
+        "session-model.liveAgentModels.cap",
+        new Error(`liveAgentModels at cap ${MAX_LIVE_AGENT_MODELS}; evicting oldest ${oldestKey}`)
+      );
+      liveAgentModels.delete(oldestKey);
+    }
+  }
+  liveAgentModels.set(agentId, model);
+}
+function unregisterLiveAgentModel(agentId) {
+  liveAgentModels.delete(agentId);
+}
+function hasActiveLiveAgents() {
+  return liveAgentModels.size > 0;
+}
+function resolveProviderForResponse() {
+  const ctx = liveAgentContext.getStore();
+  if (ctx) return providerOfModelRef(ctx.modelRef);
+  if (hasActiveLiveAgents()) return void 0;
+  return providerOfModelRef(currentSessionModel());
+}
 function noteSessionModel(model, source = "model_select") {
   const normalized = modelRefToString(model);
   if (!normalized) return;
@@ -22342,12 +22368,16 @@ function captureRunModelContext(ctx, override) {
 function sessionModelSnapshot() {
   return { ...state };
 }
-var state;
+var state, liveAgentContext, liveAgentModels, MAX_LIVE_AGENT_MODELS;
 var init_session_model = __esm({
   "src/runtime/model/session-model.ts"() {
     "use strict";
+    init_internal_error();
     init_model_fallback();
     state = { source: "none" };
+    liveAgentContext = new AsyncLocalStorage2();
+    liveAgentModels = /* @__PURE__ */ new Map();
+    MAX_LIVE_AGENT_MODELS = 5e3;
   }
 });
 
@@ -33237,6 +33267,7 @@ async function runLiveSessionTask(input) {
       scopeModelsPatterns: await resolveScopeModelsPatterns(input.manifest.cwd)
     });
     const resolvedModel = modelFromRegistry(input.modelRegistry, modelRouting.candidates[0] ?? modelRouting.requested) ?? input.parentModel;
+    const resolvedModelRef = modelRefToString(resolvedModel) ?? modelRouting.candidates[0];
     if (modelRouting.droppedRequested) {
       appendEventFireAndForget(input.manifest.eventsPath, {
         type: "task.model_dropped",
@@ -33335,6 +33366,7 @@ async function runLiveSessionTask(input) {
       appendEvent,
       input.manifest.eventsPath
     );
+    registerLiveAgentModel(agentId, resolvedModelRef ?? "");
     streamOut = createStreamingOutput(input.manifest, input.task.id);
     let controlCursor = { offset: 0 };
     const seenControlRequestIds = /* @__PURE__ */ new Set();
@@ -33470,7 +33502,10 @@ ${input.prompt}` : input.prompt;
     });
     const sessionTimeoutMs = DEFAULT_LIVE_SESSION.responseTimeoutMs;
     try {
-      await promptWithTimeout(session, effectivePrompt, sessionTimeoutMs, "Live-session");
+      await liveAgentContext.run(
+        { agentId, modelRef: resolvedModelRef ?? "" },
+        () => promptWithTimeout(session, effectivePrompt, sessionTimeoutMs, "Live-session")
+      );
     } catch (promptError) {
       const msg = promptError instanceof Error ? promptError.message : String(promptError);
       appendEventFireAndForget(input.manifest.eventsPath, {
@@ -33643,6 +33678,7 @@ ${input.prompt}` : input.prompt;
       error: message
     };
   } finally {
+    unregisterLiveAgentModel(agentId);
     unsubscribe?.();
     unsubscribeControlRealtime?.();
     if (onSignalAbort) input.signal?.removeEventListener("abort", onSignalAbort);
@@ -33681,6 +33717,7 @@ var init_live_session_runtime = __esm({
     init_model_scope();
     init_runtime_resolver();
     init_runtime_warmup();
+    init_session_model();
     init_sidechain_output();
     init_streaming_output();
     init_sensitive_paths();
@@ -49170,7 +49207,7 @@ var init_dispatch = __esm({
 });
 
 // src/observability/correlation.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
 import { randomBytes as randomBytes2 } from "node:crypto";
 function withCorrelation(ctx, fn) {
   return storage.run(ctx, fn);
@@ -49194,7 +49231,7 @@ var storage;
 var init_correlation = __esm({
   "src/observability/correlation.ts"() {
     "use strict";
-    storage = new AsyncLocalStorage2();
+    storage = new AsyncLocalStorage3();
   }
 });
 
@@ -59883,7 +59920,8 @@ var init_chain_executor = __esm({
 # Current Chain Step
 ${packet.goal}` : packet.goal;
         const stepTeam = context.__chainStepTeam ?? this.overrides.team ?? "default";
-        const stepWorkflow = context.__chainStepWorkflow ?? this.overrides.workflow;
+        const rawWorkflow = context.__chainStepWorkflow ?? this.overrides.workflow;
+        const stepWorkflow = rawWorkflow === "chain" ? void 0 : rawWorkflow;
         const stepModel = context.__chainStepModel ?? this.overrides.model;
         const runParams = {
           action: "run",
@@ -59928,6 +59966,13 @@ async function handleChainRun(params, ctx, handleRun3) {
   if (!chainString || chainString.trim().length === 0) {
     return result("Chain expression is empty.", { action: "run", status: "error" }, true);
   }
+  if (params.workflow === "chain") {
+    return result(
+      "Workflow 'chain' cannot be combined with a chain run: the chain runner owns step execution and has no per-step workflow. Omit `workflow` (steps use the team's defaultWorkflow) or use @team references in the chain expression.",
+      { action: "run", status: "error" },
+      true
+    );
+  }
   const spec = parseChainString(chainString);
   if (spec.steps.length === 0) {
     return result(
@@ -59941,8 +59986,8 @@ async function handleChainRun(params, ctx, handleRun3) {
     ctx,
     overrides: {
       team: params.team,
-      workflow: params.workflow,
-      model: params.model
+      // workflow intentionally omitted — chain runner owns step execution (bug-44)
+      ...params.model ? { model: params.model } : {}
     }
   });
   const runner = new ChainRunner(executor, new HandoffManager());
@@ -61499,7 +61544,7 @@ Commit or stash changes before using worktree mode, or use workspaceMode: 'singl
     workspaceMode: params.workspaceMode
   } : teams.find((item) => item.name === teamName);
   if (!team) return result(`Team '${teamName}' not found.`, { action: "run", status: "error" }, true);
-  const workflowName = directAgent ? "direct-agent" : params.workflow ?? team.defaultWorkflow ?? "default";
+  const workflowName = directAgent ? "direct-agent" : params.workflow === "chain" && !params.chain ? team.defaultWorkflow ?? "default" : params.workflow ?? team.defaultWorkflow ?? "default";
   const baseWorkflow = directAgent ? {
     name: "direct-agent",
     description: `Direct task for ${directAgent.name}`,
@@ -69552,6 +69597,19 @@ var init_notification_router = __esm({
           ...notification,
           timestamp: notification.timestamp ?? now
         };
+        if (withTime.clear) {
+          const clearKey = notificationKey(withTime);
+          const wasInSeen = this.seen.delete(clearKey);
+          if (wasInSeen) {
+            try {
+              this.opts.sink?.(withTime);
+            } catch (sinkError) {
+              logInternalError("notification-sink", sinkError);
+            }
+            this.deliver(withTime);
+          }
+          return true;
+        }
         try {
           this.opts.sink?.(withTime);
         } catch (sinkError) {
@@ -70084,11 +70142,15 @@ async function configureNotifications(ctx, state2, deps) {
       sink: (notification) => state2.notificationSink?.write(notification)
     },
     (notification) => {
-      deps.widgetState.notificationCount = (deps.widgetState.notificationCount ?? 0) + 1;
-      sendFollowUp2(
-        deps.pi,
-        [notification.title, notification.body, notification.runId ? `Run: ${notification.runId}` : void 0].filter((line4) => Boolean(line4)).join("\n")
-      );
+      if (notification.clear) {
+        deps.widgetState.notificationCount = Math.max(0, (deps.widgetState.notificationCount ?? 0) - 1);
+      } else {
+        deps.widgetState.notificationCount = (deps.widgetState.notificationCount ?? 0) + 1;
+        sendFollowUp2(
+          deps.pi,
+          [notification.title, notification.body, notification.runId ? `Run: ${notification.runId}` : void 0].filter((line4) => Boolean(line4)).join("\n")
+        );
+      }
       const currentCtx = deps.getCurrentCtx();
       if (currentCtx) {
         const uiConfig = loadConfig(currentCtx.cwd).config.ui;
@@ -76656,7 +76718,6 @@ function safeStringify(value) {
 // src/extension/registration/lifecycle-handlers.ts
 init_child_pi();
 init_live_agent_manager();
-init_model_fallback();
 init_pi_args();
 init_provider_quota();
 init_session_model();
@@ -76955,8 +77016,7 @@ function installModelTrackingHandlers(pi) {
     noteSessionThinking(event.level);
   });
   pi.on("after_provider_response", (event) => {
-    const model = currentSessionModel();
-    const provider = model ? providerOfModelRef(model) : void 0;
+    const provider = resolveProviderForResponse();
     if (provider) noteProviderResponse(provider, event.status, event.headers);
   });
 }
@@ -77353,12 +77413,40 @@ function setupRenderLoop(pi, ctx, extensionCtx, loadedConfig) {
     const currentSessionId = ctx.currentCtx?.sessionManager?.getSessionId();
     const sessionManifests = filterManifestsForHealthNotifications(manifests, currentSessionId);
     const now = Date.now();
+    const clearHealthNotifications = (runId) => {
+      for (const kind of ["recovery_dead_workers", "recovery_missing_heartbeat"]) {
+        const key = `${kind}_${runId}`;
+        ctx.autoRecoveryLast.delete(key);
+        ctx.notifyOperator({
+          id: key,
+          clear: true,
+          severity: "info",
+          source: "health",
+          runId,
+          title: `Cleared ${kind} for ${runId}`
+        });
+      }
+    };
     for (const run of sessionManifests) {
-      if (run.status !== "running") continue;
+      if (run.status !== "running") {
+        snapshotCache.invalidate(run.runId);
+        clearHealthNotifications(run.runId);
+        continue;
+      }
       try {
+        const freshManifest = ctx.getManifestCache(extensionCtx.cwd).get(run.runId);
+        if (freshManifest?.status !== "running") {
+          snapshotCache.invalidate(run.runId);
+          clearHealthNotifications(run.runId);
+          continue;
+        }
         const snapshot = snapshotCache.get(run.runId);
         if (!snapshot) continue;
-        if (snapshot.manifest.status !== "running") continue;
+        if (snapshot.manifest.status !== "running") {
+          snapshotCache.invalidate(run.runId);
+          clearHealthNotifications(run.runId);
+          continue;
+        }
         const summary = summarizeHeartbeats(snapshot, { now });
         const maybeNotifyHealth = (kind, count2, title, body) => {
           if (count2 <= 0) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-crew",
-  "version": "0.9.60",
+  "version": "0.9.62",
   "description": "Pi extension for coordinated AI teams, workflows, worktrees, and async task orchestration",
   "author": "baphuongna",
   "license": "MIT",

package/src/extension/notification-router.ts

@@ -10,6 +10,8 @@ export interface NotificationDescriptor {
 	title: string;
 	body?: string;
 	timestamp?: number;
+	/** When true, this is a dismiss/clear request for a previously-emitted notification (same id). Bypasses dedup/severity/quiet-hours; the deliver callback drops the matching notification. */
+	clear?: boolean;
 }
 
 export interface NotificationRouterOptions {
@@ -99,6 +101,29 @@ export class NotificationRouter {
 			...notification,
 			timestamp: notification.timestamp ?? now,
 		};
+		// Clear path: remove the id from `seen` so a future genuine re-occurrence
+		// can re-notify. Delivery is guarded on whether the id was actually in
+		// `seen` to keep the clear idempotent (bypassing dedup / severity filter /
+		// quiet hours when it does deliver — a clear must go through so the
+		// dashboard can drop the previously-emitted notification).
+		if (withTime.clear) {
+			const clearKey = notificationKey(withTime);
+			// Idempotent: only deliver the clear if the id was actually in `seen`
+			// (i.e., a notification for it was previously emitted and not yet
+			// cleared). This prevents multi-fire drift when the render loop calls
+			// clearHealthNotifications on consecutive ticks for the same terminal
+			// run — each clear after the first is a silent no-op that returns true.
+			const wasInSeen = this.seen.delete(clearKey);
+			if (wasInSeen) {
+				try {
+					this.opts.sink?.(withTime);
+				} catch (sinkError) {
+					logInternalError("notification-sink", sinkError);
+				}
+				this.deliver(withTime);
+			}
+			return true;
+		}
 		try {
 			this.opts.sink?.(withTime);
 		} catch (sinkError) {

package/src/extension/registration/lifecycle-handlers.ts

@@ -25,10 +25,9 @@ import { CrewBroker } from "../../runtime/broker/crew-broker.ts";
 import { terminateActiveChildPiProcesses } from "../../runtime/child-pi/child-pi.ts";
 import { listLiveAgents } from "../../runtime/live-session/live-agent-manager.ts";
 import type { createManifestCache } from "../../runtime/manifest-cache.ts";
-import { providerOfModelRef } from "../../runtime/model/model-fallback.ts";
 import { cleanupLegacyOrphanTempDirs, cleanupOrphanTempDirs, currentCrewDepth } from "../../runtime/model/pi-args.ts";
 import { clearProviderQuotaCache, noteProviderResponse } from "../../runtime/model/provider-quota.ts";
-import { currentSessionModel, noteSessionModel, noteSessionThinking } from "../../runtime/model/session-model.ts";
+import { noteSessionModel, noteSessionThinking, resolveProviderForResponse } from "../../runtime/model/session-model.ts";
 import { cleanupOrphanWorkers } from "../../runtime/orphan-worker-registry.ts";
 import { reconcileAllStaleRuns } from "../../runtime/recovery/crash-recovery.ts";
 import { CrewScheduler, type ScheduledJob } from "../../runtime/scheduling/scheduler.ts";
@@ -93,8 +92,7 @@ function installModelTrackingHandlers(pi: ExtensionAPI): void {
 	// providers. The event doesn't carry a provider field, so we attribute it
 	// to the currently tracked session model's provider.
 	pi.on("after_provider_response", (event) => {
-		const model = currentSessionModel();
-		const provider = model ? providerOfModelRef(model) : undefined;
+		const provider = resolveProviderForResponse();
 		if (provider) noteProviderResponse(provider, event.status, event.headers);
 	});
 }
@@ -666,12 +664,55 @@ function setupRenderLoop(
 		const currentSessionId = ctx.currentCtx?.sessionManager?.getSessionId();
 		const sessionManifests = filterManifestsForHealthNotifications(manifests, currentSessionId);
 		const now = Date.now();
+		// FIX #2: clear path — when a run is detected terminal, dismiss any
+		// previously-emitted health notification for it AND drop its cooldown
+		// (autoRecoveryLast) so a future genuine re-occurrence can re-notify.
+		// Keeps the dashboard clean and stops the 5-min re-fire cycle.
+		const clearHealthNotifications = (runId: string): void => {
+			for (const kind of ["recovery_dead_workers", "recovery_missing_heartbeat"]) {
+				const key = `${kind}_${runId}`;
+				ctx.autoRecoveryLast.delete(key);
+				ctx.notifyOperator({
+					id: key,
+					clear: true,
+					severity: "info",
+					source: "health",
+					runId,
+					title: `Cleared ${kind} for ${runId}`,
+				});
+			}
+		};
 		for (const run of sessionManifests) {
-			if (run.status !== "running") continue;
+			if (run.status !== "running") {
+				// GATE 1 — preloaded manifest says terminal. Purge any stale snapshot
+				// and clear previously-emitted health notifications so the dashboard
+				// stays clean (belt-and-suspenders with the FIX #1 fresh-read gate).
+				snapshotCache.invalidate(run.runId);
+				clearHealthNotifications(run.runId);
+				continue;
+			}
 			try {
+				// FIX #1: re-verify against a FRESH manifest read. The preloaded `run`
+				// (from lastPreloadedManifests) can lag the on-disk terminal
+				// transition; the manifest cache has a 500ms TTL + file watcher so it
+				// is the source of truth. A terminal run must NEVER reach
+				// maybeNotifyHealth. Also purge the stale snapshot + clear any
+				// previously-emitted health notification for this run.
+				const freshManifest = ctx.getManifestCache(extensionCtx.cwd).get(run.runId);
+				if (freshManifest?.status !== "running") {
+					snapshotCache.invalidate(run.runId);
+					clearHealthNotifications(run.runId);
+					continue;
+				}
 				const snapshot = snapshotCache.get(run.runId);
 				if (!snapshot) continue;
-				if (snapshot.manifest.status !== "running") continue;
+				if (snapshot.manifest.status !== "running") {
+					// GATE 2 — a running snapshot paired with a now-terminal manifest is
+					// stale. Purge it so subsequent ticks get a fresh view, and clear.
+					snapshotCache.invalidate(run.runId);
+					clearHealthNotifications(run.runId);
+					continue;
+				}
 				const summary = summarizeHeartbeats(snapshot, { now });
 				const maybeNotifyHealth = (kind: string, count: number, title: string, body: string): void => {
 					if (count <= 0) return;

package/src/extension/registration/lifecycle.ts

@@ -148,13 +148,19 @@ export async function configureNotifications(ctx: ExtensionContext, state: Lifec
 			sink: (notification) => state.notificationSink?.write(notification),
 		},
 		(notification: NotificationDescriptor) => {
-			deps.widgetState.notificationCount = (deps.widgetState.notificationCount ?? 0) + 1;
-			sendFollowUp(
-				deps.pi,
-				[notification.title, notification.body, notification.runId ? `Run: ${notification.runId}` : undefined]
-					.filter((line): line is string => Boolean(line))
-					.join("\n"),
-			);
+			if (notification.clear) {
+				// Clear/dismiss: decrement the counter (floor 0) and skip the
+				// follow-up message — this is a dismissal, not a new alert.
+				deps.widgetState.notificationCount = Math.max(0, (deps.widgetState.notificationCount ?? 0) - 1);
+			} else {
+				deps.widgetState.notificationCount = (deps.widgetState.notificationCount ?? 0) + 1;
+				sendFollowUp(
+					deps.pi,
+					[notification.title, notification.body, notification.runId ? `Run: ${notification.runId}` : undefined]
+						.filter((line): line is string => Boolean(line))
+						.join("\n"),
+				);
+			}
 			const currentCtx = deps.getCurrentCtx();
 			if (currentCtx) {
 				const uiConfig = loadConfig(currentCtx.cwd).config.ui;

package/src/runtime/live-session/live-session-runtime.ts

@@ -26,6 +26,7 @@ import {
 import { readEnabledModelsPatterns } from "../model/model-scope.ts";
 import { isLiveSessionRuntimeAvailable } from "../model/runtime-resolver.ts";
 import { awaitRuntimeWarmup } from "../model/runtime-warmup.ts";
+import { liveAgentContext, registerLiveAgentModel, unregisterLiveAgentModel } from "../model/session-model.ts";
 import { eventToSidechainType, sidechainOutputPath, writeSidechainEntry } from "../output/sidechain-output.ts";
 // NOTE: buildMemoryBlock is intentionally NOT imported here. The agent memory
 // block is injected via renderTaskPrompt().full (the USER prompt), which is
@@ -705,6 +706,7 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 		});
 		const resolvedModel =
 			modelFromRegistry(input.modelRegistry, modelRouting.candidates[0] ?? modelRouting.requested) ?? input.parentModel;
+		const resolvedModelRef = modelRefToString(resolvedModel) ?? modelRouting.candidates[0];
 		// Surface a warning when the caller's requested model was silently replaced.
 		if (modelRouting.droppedRequested) {
 			appendEventFireAndForget(input.manifest.eventsPath, {
@@ -839,6 +841,7 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 			appendEvent,
 			input.manifest.eventsPath,
 		);
+		registerLiveAgentModel(agentId, resolvedModelRef ?? "");
 		streamOut = createStreamingOutput(input.manifest, input.task.id);
 		let controlCursor: LiveAgentControlCursor = { offset: 0 };
 		const seenControlRequestIds = new Set<string>();
@@ -988,7 +991,9 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 		// Phase 3: Wrap session.prompt with timeout for graceful cancellation
 		const sessionTimeoutMs = DEFAULT_LIVE_SESSION.responseTimeoutMs;
 		try {
-			await promptWithTimeout(session, effectivePrompt, sessionTimeoutMs, "Live-session");
+			await liveAgentContext.run({ agentId, modelRef: resolvedModelRef ?? "" }, () =>
+				promptWithTimeout(session!, effectivePrompt, sessionTimeoutMs, "Live-session"),
+			);
 		} catch (promptError) {
 			const msg = promptError instanceof Error ? promptError.message : String(promptError);
 			// P7: fire-and-forget — return value not needed.
@@ -1181,6 +1186,12 @@ export async function runLiveSessionTask(input: LiveSessionSpawnInput): Promise<
 			error: message,
 		};
 	} finally {
+		// Unregister the live-agent model FIRST: a synchronous Map.delete that must run on
+		// every exit path. If skipped (e.g. terminateLiveAgent throws on session.abort()),
+		// hasActiveLiveAgents() stays true for the process lifetime and permanently disables
+		// quota attribution (priority-2 skip) — including the main session's own tracking.
+		// (Review finding H1/M1.)
+		unregisterLiveAgentModel(agentId);
 		// H6: Unsubscribe listeners FIRST before clearing timer to prevent race
 		unsubscribe?.();
 		unsubscribeControlRealtime?.();

package/src/runtime/model/session-model.ts

@@ -17,8 +17,10 @@
  * the pi events; the spawn paths read it through {@link resolveParentModel}.
  */
 
+import { AsyncLocalStorage } from "node:async_hooks";
 import type { RunModelContext } from "../../state/types.ts";
-import { availableModelInfosFromRegistry, modelRefToString } from "./model-fallback.ts";
+import { logInternalError } from "../../utils/internal-error.ts";
+import { availableModelInfosFromRegistry, modelRefToString, providerOfModelRef } from "./model-fallback.ts";
 
 export type SessionModelSource = "model_select" | "session_start" | "none";
 
@@ -31,6 +33,78 @@ interface SessionModelState {
 
 const state: SessionModelState = { source: "none" };
 
+// --- Live-session per-agent quota attribution ---
+//
+// In the opt-in `live-session` runtime, multiple in-process subagents share
+// this ONE module-scoped tracker. The `after_provider_response` event carries
+// no sessionId/model field, so the global `currentSessionModel()` returns the
+// MAIN session's model regardless of which in-process agent actually produced
+// the response. That mis-attributes quota (e.g. a provider-B 429 written under
+// provider-A's key).
+//
+// AsyncLocalStorage propagates each live agent's known model through the
+// async call chain. `resolveProviderForResponse()` checks it first, then falls
+// back to a guard (skip attribution when live agents are active but context
+// is absent — prevents contamination), then the original global tracker (the
+// default child-process path, unchanged).
+
+/** Per-agent async context for live-session quota attribution. */
+export const liveAgentContext = new AsyncLocalStorage<{ agentId: string; modelRef: string }>();
+
+/** Registered live-session agent models (agentId → "provider/id"). */
+const liveAgentModels = new Map<string, string>();
+
+// Cap the tracker to prevent unbounded growth if a caller registers an agent
+// but fails to unregister it (e.g. a crashed/disposed live agent). Matches the
+// precedent in live-agent-manager.ts (MAX_LIVE_AGENTS). When at cap, evict the
+// oldest insertion (Map preserves insertion order); a leaked entry also pins
+// hasActiveLiveAgents()=true, so bounding it matters beyond raw memory.
+const MAX_LIVE_AGENT_MODELS = 5_000;
+
+/** Record a live-session agent's resolved model for quota attribution. */
+export function registerLiveAgentModel(agentId: string, model: string): void {
+	if (liveAgentModels.size >= MAX_LIVE_AGENT_MODELS && !liveAgentModels.has(agentId)) {
+		const oldestKey = liveAgentModels.keys().next().value;
+		if (oldestKey !== undefined) {
+			logInternalError(
+				"session-model.liveAgentModels.cap",
+				new Error(`liveAgentModels at cap ${MAX_LIVE_AGENT_MODELS}; evicting oldest ${oldestKey}`),
+			);
+			liveAgentModels.delete(oldestKey);
+		}
+	}
+	liveAgentModels.set(agentId, model);
+}
+
+/** Remove a live-session agent's model (called in the finally block). */
+export function unregisterLiveAgentModel(agentId: string): void {
+	liveAgentModels.delete(agentId);
+}
+
+/** Whether any live-session agents are currently registered. */
+export function hasActiveLiveAgents(): boolean {
+	return liveAgentModels.size > 0;
+}
+
+/**
+ * Resolve the provider for an `after_provider_response` event.
+ *
+ * Priority:
+ *   1. Async context from the live-session agent that issued the request
+ *      (correct per-agent attribution — pi-crew knows each agent's model).
+ *   2. Live agents are active but the context didn't propagate → skip
+ *      attribution entirely (return undefined) to PREVENT cross-agent
+ *      contamination.
+ *   3. No live agents (default child-process runtime) → original behavior:
+ *      attribute to the global session model's provider.
+ */
+export function resolveProviderForResponse(): string | undefined {
+	const ctx = liveAgentContext.getStore();
+	if (ctx) return providerOfModelRef(ctx.modelRef);
+	if (hasActiveLiveAgents()) return undefined;
+	return providerOfModelRef(currentSessionModel());
+}
+
 /**
  * Record the model the main session is running. Accepts pi's `Model` object
  * (`{ provider, id }`) or a `"provider/id"` string; anything unrecognized is
@@ -132,4 +206,5 @@ export function __test_resetSessionModel(): void {
 	state.thinking = undefined;
 	state.source = "none";
 	state.updatedAt = undefined;
+	liveAgentModels.clear();
 }