pi-crew 0.9.58 → 0.9.60

package/dist/index.mjs

@@ -5867,16 +5867,16 @@ var init_assert = __esm({
     init_errors2();
     init_error();
     init_check();
-    __classPrivateFieldSet = function(receiver, state, value, kind, f) {
+    __classPrivateFieldSet = function(receiver, state2, value, kind, f) {
       if (kind === "m") throw new TypeError("Private method is not writable");
       if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-      if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-      return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value;
+      if (typeof state2 === "function" ? receiver !== state2 || !f : !state2.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+      return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state2.set(receiver, value), value;
     };
-    __classPrivateFieldGet = function(receiver, state, kind, f) {
+    __classPrivateFieldGet = function(receiver, state2, kind, f) {
       if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-      if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-      return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+      if (typeof state2 === "function" ? receiver !== state2 || !f : !state2.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+      return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state2.get(receiver);
     };
     AssertError = class extends TypeBoxError {
       constructor(iterator) {
@@ -8234,7 +8234,7 @@ var init_validation_types = __esm({
 });
 
 // src/schema/config-schema.ts
-var PiTeamsAutonomyProfileSchema, PiTeamsAutonomousConfigSchema, PiTeamsLimitsConfigSchema, PiTeamsRuntimeConfigSchema, PiTeamsControlConfigSchema, PiTeamsWorktreeConfigSchema, GoalWrapWorkflowConfigSchema, PiTeamsGoalWrapConfigSchema, AgentOverrideSchema, PiTeamsAgentsConfigSchema, PiTeamsToolsConfigSchema, PiTeamsTelemetryConfigSchema, PiTeamsPolicyConfigSchema, PiTeamsNotificationsConfigSchema, PiTeamsObservabilityConfigSchema, PiTeamsReliabilityConfigSchema, PiTeamsOtlpConfigSchema, PiTeamsUiConfigSchema, CrewBrokerConfigSchema, PiTeamsConfigSchema;
+var PiTeamsAutonomyProfileSchema, PiTeamsAutonomousConfigSchema, PiTeamsLimitsConfigSchema, PiTeamsModelFallbackConfigSchema, PiTeamsRuntimeConfigSchema, PiTeamsControlConfigSchema, PiTeamsWorktreeConfigSchema, GoalWrapWorkflowConfigSchema, PiTeamsGoalWrapConfigSchema, AgentOverrideSchema, PiTeamsAgentsConfigSchema, PiTeamsToolsConfigSchema, PiTeamsTelemetryConfigSchema, PiTeamsPolicyConfigSchema, PiTeamsNotificationsConfigSchema, PiTeamsObservabilityConfigSchema, PiTeamsReliabilityConfigSchema, PiTeamsOtlpConfigSchema, PiTeamsUiConfigSchema, CrewBrokerConfigSchema, PiTeamsConfigSchema;
 var init_config_schema = __esm({
   "src/schema/config-schema.ts"() {
     "use strict";
@@ -8272,6 +8272,16 @@ var init_config_schema = __esm({
       },
       { additionalProperties: false }
     );
+    PiTeamsModelFallbackConfigSchema = Type.Object(
+      {
+        maxAutoFallbacks: Type.Optional(Type.Integer({ minimum: 0 })),
+        order: Type.Optional(Type.Union([Type.Literal("parentFirst"), Type.Literal("asIs")])),
+        requireCredentials: Type.Optional(Type.Boolean()),
+        quotaAwareOrdering: Type.Optional(Type.Boolean()),
+        defaultSubagentModel: Type.Optional(Type.String({ minLength: 1 }))
+      },
+      { additionalProperties: false }
+    );
     PiTeamsRuntimeConfigSchema = Type.Object(
       {
         mode: Type.Optional(
@@ -8311,7 +8321,8 @@ var init_config_schema = __esm({
             },
             { additionalProperties: false }
           )
-        )
+        ),
+        modelFallback: Type.Optional(PiTeamsModelFallbackConfigSchema)
       },
       { additionalProperties: false }
     );
@@ -12323,10 +12334,17 @@ function parseRoleLine(line4) {
     metadata.skills = raw.replace(/\s*,\s*/g, ",").trim();
     return "";
   });
-  descriptionSource = descriptionSource.replace(/\b(agent|model|maxConcurrency)\s*=\s*(\S+)/g, (_match, key, raw) => {
-    metadata[key] = raw.trim();
+  descriptionSource = descriptionSource.replace(/\bfallbackModels\s*=\s*([\w/.:-]+(?:\s*,\s*[\w/.:-]+)*)/g, (_match, raw) => {
+    metadata.fallbackModels = raw.replace(/\s*,\s*/g, ",").trim();
     return "";
   });
+  descriptionSource = descriptionSource.replace(
+    /\b(agent|model|thinking|maxConcurrency)\s*=\s*(\S+)/g,
+    (_match, key, raw) => {
+      metadata[key] = raw.trim();
+      return "";
+    }
+  );
   const description = descriptionSource.replace(/\s+/g, " ").trim() || void 0;
   const maxConcurrency = metadata.maxConcurrency ? (() => {
     const p = Number.parseInt(metadata.maxConcurrency, 10);
@@ -12337,6 +12355,8 @@ function parseRoleLine(line4) {
     agent: metadata.agent ?? name,
     description,
     model: metadata.model,
+    fallbackModels: metadata.fallbackModels ? metadata.fallbackModels.split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+    thinking: metadata.thinking?.trim() || void 0,
     skills: parseRoleSkills(metadata.skills),
     maxConcurrency: maxConcurrency && maxConcurrency > 0 ? maxConcurrency : void 0
   };
@@ -12871,14 +12891,23 @@ function toPiSessionId(runId) {
 }
 function extractSessionId(ctx) {
   if (typeof ctx !== "object" || ctx === null) return void 0;
-  let raw;
   try {
-    raw = Object.getOwnPropertyDescriptor(ctx, "sessionId")?.value;
+    const sm = ctx.sessionManager;
+    if (sm && typeof sm === "object") {
+      const cached2 = sessionIdCache.get(sm);
+      if (cached2) return cached2;
+      const id = sm.getSessionId?.();
+      if (typeof id === "string" && id.length > 0) {
+        sessionIdCache.set(sm, id);
+        return id;
+      }
+    }
+    const direct = Object.getOwnPropertyDescriptor(ctx, "sessionId")?.value;
+    if (typeof direct === "string" && direct.length > 0) return direct;
   } catch {
     return void 0;
   }
-  if (typeof raw !== "string" || raw.length === 0) return void 0;
-  return raw;
+  return void 0;
 }
 function extractBrokerSessionId(ctx) {
   if (typeof ctx !== "object" || ctx === null) return void 0;
@@ -12893,9 +12922,11 @@ function extractBrokerSessionId(ctx) {
     return void 0;
   }
 }
+var sessionIdCache;
 var init_session_utils = __esm({
   "src/utils/session-utils.ts"() {
     "use strict";
+    sessionIdCache = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -13013,9 +13044,9 @@ var init_cancellation_token = __esm({
         this.throwIfCancelled();
         this.#lastHeartbeatAt = this.#now().toISOString();
         this.#lastHeartbeatStage = stage;
-        const state = this.state();
-        this.#onHeartbeat?.(state);
-        return state;
+        const state2 = this.state();
+        this.#onHeartbeat?.(state2);
+        return state2;
       }
       throwIfCancelled() {
         if (this.aborted) throw new CrewCancellationError(this.#reason ?? cancellationReasonFromUnknown(this.#controller.signal.reason));
@@ -13943,12 +13974,13 @@ function buildPiWorkerArgs(input) {
   const args = ["--mode", "json", "-p"];
   if (input.sessionEnabled === false) args.push("--no-session");
   const resolvedModel = input.model ?? input.agent.model;
+  const effectiveThinking = input.thinkingOverride ?? input.agent.thinking;
   if (resolvedModel) {
-    const modelWithThinking = applyThinkingSuffix(resolvedModel, input.agent.thinking);
+    const modelWithThinking = applyThinkingSuffix(resolvedModel, effectiveThinking);
     if (modelWithThinking) args.push("--model", modelWithThinking);
   }
-  if (!resolvedModel && input.agent.thinking && input.agent.thinking !== "off" && isValidThinkingLevel(input.agent.thinking)) {
-    args.push("--thinking", input.agent.thinking);
+  if (!resolvedModel && effectiveThinking && effectiveThinking !== "off" && isValidThinkingLevel(effectiveThinking)) {
+    args.push("--thinking", effectiveThinking);
   }
   const policy = resolveToolPolicy(input.agent, input.role);
   const explicitTools = policy.tools;
@@ -14914,7 +14946,8 @@ function prepareSpawnContext(input, effectiveTask) {
     sessionEnabled: true,
     maxDepth: input.maxDepth,
     skillPaths: input.skillPaths,
-    role: input.role
+    role: input.role,
+    thinkingOverride: input.thinkingOverride
   });
   if (input.steeringFile) built.env.PI_CREW_STEERING_FILE = input.steeringFile;
   if (input.brokerSpawn?.socketPath && input.brokerSpawn.token) {
@@ -17832,45 +17865,45 @@ function readJsonlTail(filePath, tailBytes) {
     }
   }
 }
-function readLinesSince(filePath, state) {
+function readLinesSince(filePath, state2) {
   let fd;
   try {
     fd = fs24.openSync(filePath, "r");
   } catch {
     return {
       lines: [],
-      state: { byteOffset: state.byteOffset, lineCount: state.lineCount },
+      state: { byteOffset: state2.byteOffset, lineCount: state2.lineCount },
       eof: true
     };
   }
   try {
     const stat2 = fs24.fstatSync(fd);
     const fileSize = stat2.size;
-    if (fileSize <= state.byteOffset) {
+    if (fileSize <= state2.byteOffset) {
       return {
         lines: [],
-        state: { byteOffset: fileSize, lineCount: state.lineCount },
+        state: { byteOffset: fileSize, lineCount: state2.lineCount },
         eof: true
       };
     }
-    const bytesToRead = fileSize - state.byteOffset;
+    const bytesToRead = fileSize - state2.byteOffset;
     const buf = Buffer.alloc(bytesToRead);
     let totalRead = 0;
     while (totalRead < bytesToRead) {
       const chunkSize = Math.min(CHUNK_SIZE, bytesToRead - totalRead);
-      const bytesRead = fs24.readSync(fd, buf, totalRead, chunkSize, state.byteOffset + totalRead);
+      const bytesRead = fs24.readSync(fd, buf, totalRead, chunkSize, state2.byteOffset + totalRead);
       if (bytesRead === 0) break;
       totalRead += bytesRead;
     }
     const content = buf.toString("utf-8", 0, totalRead);
     const lines = [];
-    let lineCount = state.lineCount;
-    let committedOffset = state.byteOffset;
+    let lineCount = state2.lineCount;
+    let committedOffset = state2.byteOffset;
     let searchFrom = 0;
     let newlineIdx;
     while ((newlineIdx = content.indexOf("\n", searchFrom)) !== -1) {
       const lineText = content.slice(searchFrom, newlineIdx);
-      committedOffset = state.byteOffset + newlineIdx + 1;
+      committedOffset = state2.byteOffset + newlineIdx + 1;
       searchFrom = newlineIdx + 1;
       if (lineText.length > 0) {
         lines.push(lineText);
@@ -17892,8 +17925,8 @@ function readLinesSince(filePath, state) {
     }
   }
 }
-function readJsonlSince(filePath, state) {
-  const result4 = readLinesSince(filePath, state);
+function readJsonlSince(filePath, state2) {
+  const result4 = readLinesSince(filePath, state2);
   const items = [];
   for (const line4 of result4.lines) {
     try {
@@ -20958,12 +20991,12 @@ function readDeliveryState(manifest) {
     if (obj.messages && typeof obj.messages === "object" && !Array.isArray(obj.messages)) {
       for (const [id, status] of Object.entries(obj.messages)) if (isStatus(status)) messages[id] = status;
     }
-    const state = {
+    const state2 = {
       messages,
       updatedAt: typeof obj.updatedAt === "string" ? obj.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
     };
-    setDeliveryCacheEntry(filePath, { mtimeMs: stat2.mtimeMs, state });
-    return state;
+    setDeliveryCacheEntry(filePath, { mtimeMs: stat2.mtimeMs, state: state2 });
+    return state2;
   } catch (error) {
     const quarantinePath = `${filePath}.corrupt-${Date.now()}`;
     try {
@@ -20978,25 +21011,25 @@ function readDeliveryState(manifest) {
     return { messages: {}, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
 }
-function writeDeliveryState(manifest, state, options) {
+function writeDeliveryState(manifest, state2, options) {
   ensureRunMailbox(manifest);
   const MAX_DELIVERY_MESSAGES = 1e4;
-  if (Object.keys(state.messages).length > MAX_DELIVERY_MESSAGES) {
-    const sorted = Object.entries(state.messages).sort(([, a], [, b]) => {
+  if (Object.keys(state2.messages).length > MAX_DELIVERY_MESSAGES) {
+    const sorted = Object.entries(state2.messages).sort(([, a], [, b]) => {
       const order = { queued: 0, delivered: 1, acknowledged: 2 };
       return (order[a] ?? 3) - (order[b] ?? 3);
     });
     const trimmed = sorted.slice(0, MAX_DELIVERY_MESSAGES);
-    state.messages = Object.fromEntries(trimmed);
+    state2.messages = Object.fromEntries(trimmed);
   }
   const filePath = deliveryFile(manifest, true);
-  atomicWriteFile(filePath, `${JSON.stringify(redactSecrets(state), null, 2)}
+  atomicWriteFile(filePath, `${JSON.stringify(redactSecrets(state2), null, 2)}
 `, {
     durability: options?.durability ?? "best-effort"
   });
   try {
     const postStat = fs29.statSync(filePath);
-    setDeliveryCacheEntry(filePath, { mtimeMs: postStat.mtimeMs, state });
+    setDeliveryCacheEntry(filePath, { mtimeMs: postStat.mtimeMs, state: state2 });
   } catch {
     deliveryCache.delete(filePath);
   }
@@ -21611,6 +21644,713 @@ var init_runtime_resolver = __esm({
   }
 });
 
+// src/runtime/model/model-resolver.ts
+function fuzzyResolveModelId(input, models) {
+  const query = input.toLowerCase();
+  let bestMatch;
+  let bestScore = 0;
+  for (const m of models) {
+    const id = m.id.toLowerCase();
+    const name = (m.name ?? "").toLowerCase();
+    const full = `${m.provider}/${m.id}`.toLowerCase();
+    let score = 0;
+    if (id === query || full === query) {
+      score = 100;
+    } else if (id.includes(query) || full.includes(query)) {
+      score = 60 + query.length / id.length * 30;
+    } else if (name.includes(query)) {
+      score = 40 + query.length / (name.length || 1) * 20;
+    } else if (query.split(/[\s\-/]+/).every((part) => id.includes(part) || name.includes(part) || m.provider.toLowerCase().includes(part))) {
+      score = 20;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = m;
+    }
+  }
+  return bestMatch && bestScore >= 20 ? `${bestMatch.provider}/${bestMatch.id}` : void 0;
+}
+var init_model_resolver = __esm({
+  "src/runtime/model/model-resolver.ts"() {
+    "use strict";
+  }
+});
+
+// src/runtime/model/model-scope.ts
+function patternToRegExp(pattern) {
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+  return new RegExp(`${escaped.replace(/\*/g, ".*")}`, "i");
+}
+function matchesModelPattern(modelId, pattern) {
+  if (!modelId || !pattern) return false;
+  const id = modelId.trim();
+  const pat = pattern.trim();
+  if (!id || !pat) return false;
+  if (id.toLowerCase() === pat.toLowerCase()) return true;
+  if (pat.includes("*")) {
+    try {
+      return patternToRegExp(pat).test(id);
+    } catch {
+      return false;
+    }
+  }
+  return id.toLowerCase().includes(pat.toLowerCase());
+}
+function checkModelScope(modelId, patterns, source) {
+  if (!modelId) {
+    return {
+      inScope: true,
+      source,
+      model: "",
+      reason: "no model specified"
+    };
+  }
+  if (!patterns || patterns.length === 0) {
+    return { inScope: true, source, model: modelId };
+  }
+  for (const pattern of patterns) {
+    if (matchesModelPattern(modelId, pattern)) {
+      return {
+        inScope: true,
+        source,
+        model: modelId,
+        matchedPattern: pattern
+      };
+    }
+  }
+  return {
+    inScope: false,
+    source,
+    model: modelId,
+    reason: `model "${modelId}" is not in enabledModels allowlist (${patterns.join(", ")})`
+  };
+}
+async function readEnabledModelsPatterns(cwd, agentDir) {
+  try {
+    const mod = await import("@earendil-works/pi-coding-agent").catch(() => null);
+    if (!mod) return [];
+    const SettingsManagerCtor = mod.SettingsManager;
+    if (!SettingsManagerCtor?.create) return [];
+    const sm = SettingsManagerCtor.create(cwd, agentDir);
+    const patterns = sm.getEnabledModels?.();
+    return Array.isArray(patterns) ? patterns : [];
+  } catch {
+    return [];
+  }
+}
+var init_model_scope = __esm({
+  "src/runtime/model/model-scope.ts"() {
+    "use strict";
+  }
+});
+
+// src/runtime/model/provider-quota.ts
+function headerNumber(headers, ...names) {
+  for (const name of names) {
+    const raw = headers[name] ?? headers[name.toLowerCase()];
+    if (raw === void 0) continue;
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+  }
+  return void 0;
+}
+function headerRaw(headers, ...names) {
+  for (const name of names) {
+    const raw = headers[name] ?? headers[name.toLowerCase()];
+    if (raw !== void 0) return raw;
+  }
+  return void 0;
+}
+function parseResetValue(value, nowMs3) {
+  const trimmed = value.trim();
+  if (/^\d+$/.test(trimmed)) {
+    const secs = Number.parseInt(trimmed, 10);
+    if (Number.isFinite(secs) && secs >= 0) return nowMs3 + secs * 1e3;
+  }
+  if (GO_DURATION_RE.test(trimmed)) {
+    let durationMs = 0;
+    for (const seg of trimmed.matchAll(GO_DURATION_SEG_RE)) {
+      const n = Number.parseInt(seg[1], 10);
+      const unit = seg[2];
+      durationMs += unit === "s" ? n * 1e3 : unit === "m" ? n * 6e4 : n * 36e5;
+    }
+    return nowMs3 + durationMs;
+  }
+  const parsed = Date.parse(trimmed);
+  if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  return void 0;
+}
+function headerResetMs(headers, nowMs3) {
+  const resetRaw = headerRaw(headers, "x-ratelimit-reset-requests", "x-ratelimit-reset");
+  if (resetRaw !== void 0) {
+    const parsed = parseResetValue(resetRaw, nowMs3);
+    if (parsed !== void 0) return parsed;
+  }
+  const retryRaw = headerRaw(headers, "retry-after");
+  if (retryRaw !== void 0) {
+    return parseResetValue(retryRaw, nowMs3);
+  }
+  return void 0;
+}
+function noteProviderResponse(provider, status, headers, nowMs3 = Date.now()) {
+  const key = provider.toLowerCase();
+  const entry = {
+    provider: key,
+    remainingRequests: headerNumber(headers, "x-ratelimit-remaining-requests", "x-ratelimit-remaining"),
+    remainingTokens: headerNumber(headers, "x-ratelimit-remaining-tokens"),
+    resetAtMs: headerResetMs(headers, nowMs3),
+    lastStatus: status,
+    updatedAtMs: nowMs3
+  };
+  quotaCache.set(key, entry);
+  const evictionCutoff = nowMs3 - 2 * QUOTA_TTL_MS;
+  for (const [cacheKey2, cached2] of quotaCache) {
+    if (cached2.updatedAtMs < evictionCutoff) quotaCache.delete(cacheKey2);
+  }
+}
+function isProviderDeprioritized(provider, nowMs3 = Date.now()) {
+  const entry = quotaCache.get(provider.toLowerCase());
+  if (!entry) return false;
+  if (nowMs3 - entry.updatedAtMs > QUOTA_TTL_MS) return false;
+  if (entry.lastStatus === 429) return true;
+  if (entry.remainingRequests === 0 || entry.remainingTokens === 0) return true;
+  if (entry.resetAtMs !== void 0 && entry.resetAtMs > nowMs3) {
+    if (entry.remainingRequests !== void 0 && entry.remainingRequests < 5) return true;
+    if (entry.remainingTokens !== void 0 && entry.remainingTokens < 1e3) return true;
+  }
+  return false;
+}
+function deprioritizedProviders(providers, nowMs3 = Date.now()) {
+  return providers.filter((p) => isProviderDeprioritized(p, nowMs3));
+}
+function providerRankFromQuota(providers, nowMs3 = Date.now()) {
+  const rank = {};
+  for (const provider of providers) {
+    const key = provider.toLowerCase();
+    const entry = quotaCache.get(key);
+    if (!entry || nowMs3 - entry.updatedAtMs > QUOTA_TTL_MS) {
+      rank[key] = Number.MAX_SAFE_INTEGER;
+      continue;
+    }
+    if (isProviderDeprioritized(key, nowMs3)) {
+      rank[key] = Number.MAX_SAFE_INTEGER - 1;
+      continue;
+    }
+    const remaining = entry.remainingRequests ?? entry.remainingTokens;
+    rank[key] = remaining !== void 0 ? Math.max(0, 1e3 - remaining) : Number.MAX_SAFE_INTEGER;
+  }
+  return rank;
+}
+function clearProviderQuotaCache() {
+  quotaCache.clear();
+}
+var QUOTA_TTL_MS, quotaCache, GO_DURATION_RE, GO_DURATION_SEG_RE;
+var init_provider_quota = __esm({
+  "src/runtime/model/provider-quota.ts"() {
+    "use strict";
+    QUOTA_TTL_MS = 5 * 60 * 1e3;
+    quotaCache = /* @__PURE__ */ new Map();
+    GO_DURATION_RE = /^(\d+[smh])+$/;
+    GO_DURATION_SEG_RE = /(\d+)([smh])/g;
+  }
+});
+
+// src/runtime/model/model-fallback.ts
+import * as fs31 from "node:fs";
+import * as os9 from "node:os";
+import * as path27 from "node:path";
+function modelInfoFromUnknown(value) {
+  if (typeof value === "string") {
+    const raw = value.trim();
+    if (!raw) return void 0;
+    const slashIdx = raw.indexOf("/");
+    if (slashIdx <= 0) return { provider: "", id: raw, fullId: raw };
+    return {
+      provider: raw.slice(0, slashIdx),
+      id: raw.slice(slashIdx + 1),
+      fullId: raw
+    };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const record = value;
+  if (typeof record.provider !== "string" || typeof record.id !== "string") return void 0;
+  return {
+    provider: record.provider,
+    id: record.id,
+    fullId: `${record.provider}/${record.id}`
+  };
+}
+function availableModelInfosFromRegistry(registry2) {
+  if (!registry2 || typeof registry2 !== "object" || Array.isArray(registry2)) return void 0;
+  const candidate = registry2;
+  const raw = typeof candidate.getAvailable === "function" ? candidate.getAvailable() : typeof candidate.getAll === "function" ? candidate.getAll() : void 0;
+  if (!Array.isArray(raw)) return void 0;
+  return raw.map(modelInfoFromUnknown).filter((entry) => entry !== void 0);
+}
+function modelStringFromUnknown(model) {
+  return modelInfoFromUnknown(model)?.fullId;
+}
+function modelRefToString(model) {
+  return modelInfoFromUnknown(model)?.fullId;
+}
+function providerOfModelRef(model) {
+  if (!model) return void 0;
+  const slashIdx = model.indexOf("/");
+  return slashIdx > 0 ? model.slice(0, slashIdx) : void 0;
+}
+function uniqueModelInfos(models) {
+  const seen = /* @__PURE__ */ new Set();
+  return models.filter((model) => {
+    if (seen.has(model.fullId)) return false;
+    seen.add(model.fullId);
+    return true;
+  });
+}
+function readJsonObject(filePath) {
+  try {
+    const parsed = JSON.parse(fs31.readFileSync(filePath, "utf-8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function piAgentDir() {
+  const envDir = process.env.PI_CODING_AGENT_DIR?.trim();
+  if (envDir) {
+    if (envDir === "~") return os9.homedir();
+    if (envDir.startsWith("~/")) return path27.join(os9.homedir(), envDir.slice(2));
+    return envDir;
+  }
+  return path27.join(os9.homedir(), ".pi", "agent");
+}
+function settingsModelInfo(settings) {
+  if (typeof settings?.defaultProvider !== "string" || typeof settings.defaultModel !== "string") return void 0;
+  return {
+    provider: settings.defaultProvider,
+    id: settings.defaultModel,
+    fullId: `${settings.defaultProvider}/${settings.defaultModel}`
+  };
+}
+function modelsJsonInfos(modelsJson) {
+  if (!modelsJson?.providers || typeof modelsJson.providers !== "object" || Array.isArray(modelsJson.providers)) return [];
+  const infos = [];
+  for (const [provider, rawConfig] of Object.entries(modelsJson.providers)) {
+    if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) continue;
+    const config = rawConfig;
+    if (Array.isArray(config.models)) {
+      for (const rawModel of config.models) {
+        if (!rawModel || typeof rawModel !== "object" || Array.isArray(rawModel)) continue;
+        const id = rawModel.id;
+        if (typeof id === "string") infos.push({ provider, id, fullId: `${provider}/${id}` });
+      }
+    }
+    if (config.modelOverrides && typeof config.modelOverrides === "object" && !Array.isArray(config.modelOverrides)) {
+      for (const id of Object.keys(config.modelOverrides)) infos.push({ provider, id, fullId: `${provider}/${id}` });
+    }
+  }
+  return infos;
+}
+function providersWithCredentials(modelsJson, env = process.env) {
+  const providers = /* @__PURE__ */ new Set();
+  const auth = readJsonObject(path27.join(piAgentDir(), "auth.json"));
+  for (const key of Object.keys(auth ?? {})) providers.add(key);
+  if (modelsJson?.providers && typeof modelsJson.providers === "object" && !Array.isArray(modelsJson.providers)) {
+    for (const [provider, rawConfig] of Object.entries(modelsJson.providers)) {
+      if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) continue;
+      const config = rawConfig;
+      if (typeof config.apiKey === "string" && config.apiKey.trim()) providers.add(provider);
+      if (typeof config.baseUrl === "string" && config.baseUrl.trim()) providers.add(provider);
+    }
+  }
+  for (const key of Object.keys(env)) {
+    const match = /^([A-Z0-9]+(?:_[A-Z0-9]+)*)_API_KEY$/.exec(key);
+    if (match && env[key]?.trim()) providers.add(match[1].toLowerCase().replace(/_/g, "-"));
+  }
+  return providers;
+}
+function fileSignature(filePath) {
+  try {
+    const stat2 = fs31.statSync(filePath);
+    return `${stat2.mtimeMs}:${stat2.size}`;
+  } catch {
+    return "-";
+  }
+}
+function configuredModelInfosFromPiConfig(cwd, options) {
+  const agentDir = piAgentDir();
+  const globalSettingsPath = path27.join(agentDir, "settings.json");
+  const modelsJsonPath = path27.join(agentDir, "models.json");
+  const authPath = path27.join(agentDir, "auth.json");
+  const projectSettingsPath = cwd ? path27.join(cwd, ".pi", "settings.json") : void 0;
+  const cacheKey2 = `${agentDir}\0${cwd ?? ""}`;
+  const signature = [globalSettingsPath, modelsJsonPath, authPath, ...projectSettingsPath ? [projectSettingsPath] : []].map(fileSignature).join("|");
+  const cached2 = configuredModelCache.get(cacheKey2);
+  if (cached2?.signature === signature) return options?.requireCredentials ? cached2.credentialed : cached2.all;
+  const globalSettings = readJsonObject(globalSettingsPath);
+  const projectSettings = projectSettingsPath ? readJsonObject(projectSettingsPath) : void 0;
+  const effectiveSettings = {
+    ...globalSettings ?? {},
+    ...projectSettings ?? {}
+  };
+  const defaultModel = settingsModelInfo(effectiveSettings);
+  const modelsJson = readJsonObject(modelsJsonPath);
+  const all = uniqueModelInfos([...defaultModel ? [defaultModel] : [], ...modelsJsonInfos(modelsJson)]);
+  const credentialedProviders = providersWithCredentials(modelsJson);
+  const credentialed = all.filter(
+    (info2) => info2.fullId === defaultModel?.fullId || credentialedProviders.has(info2.provider.toLowerCase())
+  );
+  configuredModelCache.set(cacheKey2, { signature, all, credentialed });
+  if (configuredModelCache.size > 32) {
+    const oldestKey = configuredModelCache.keys().next().value;
+    if (oldestKey !== void 0) configuredModelCache.delete(oldestKey);
+  }
+  return options?.requireCredentials ? credentialed : all;
+}
+function splitThinkingSuffix(model) {
+  const colonIdx = model.lastIndexOf(":");
+  if (colonIdx === -1) return { baseModel: model, thinkingSuffix: "" };
+  return {
+    baseModel: model.substring(0, colonIdx),
+    thinkingSuffix: model.substring(colonIdx)
+  };
+}
+function resolveModelCandidate(model, availableModels, preferredProvider) {
+  if (!model) return void 0;
+  if (model.includes("/")) return model;
+  if (!availableModels || availableModels.length === 0) return model;
+  const { baseModel, thinkingSuffix } = splitThinkingSuffix(model);
+  const matches = availableModels.filter((entry) => entry.id === baseModel);
+  if (preferredProvider) {
+    const preferredMatch = matches.find((entry) => entry.provider === preferredProvider);
+    if (preferredMatch) return `${preferredMatch.fullId}${thinkingSuffix}`;
+  }
+  if (matches.length !== 1) {
+    const fuzzy = fuzzyResolveModelId(baseModel, availableModels);
+    if (fuzzy) return `${fuzzy}${thinkingSuffix}`;
+    return model;
+  }
+  return `${matches[0].fullId}${thinkingSuffix}`;
+}
+function isRetryableModelFailure(error) {
+  if (!error) return false;
+  if (NON_RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(error))) return false;
+  return RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(error));
+}
+function formatModelAttemptNote(attempt, nextModel) {
+  const failure = attempt.error?.trim() || `exit ${attempt.exitCode ?? 1}`;
+  return nextModel ? `[fallback] ${attempt.model} failed: ${failure}. Retrying with ${nextModel}.` : `[fallback] ${attempt.model} failed: ${failure}.`;
+}
+function buildModelCandidates(primaryModel, fallbackModels, availableModels, preferredProvider) {
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  for (const raw of [primaryModel, ...fallbackModels ?? []]) {
+    if (!raw) continue;
+    const normalized = resolveModelCandidate(raw.trim(), availableModels, preferredProvider);
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    candidates.push(normalized);
+  }
+  return candidates;
+}
+function isAvailableModel(model, availableModels) {
+  if (!availableModels || availableModels.length === 0) return true;
+  const { baseModel } = splitThinkingSuffix(model);
+  if (baseModel.includes("/")) return availableModels.some((entry) => entry.fullId === baseModel);
+  if (availableModels.some((entry) => entry.id === baseModel)) return true;
+  const fuzzy = fuzzyResolveModelId(baseModel, availableModels);
+  return fuzzy !== void 0;
+}
+function orderAutoFallbacks(candidates, policy, anchorProvider) {
+  if (!policy || policy.order === "asIs") return candidates;
+  const deprioritized = new Set((policy.deprioritizedProviders ?? []).map((p) => p.toLowerCase()));
+  const rank = policy.providerRank ?? {};
+  const rankFor = (provider) => {
+    if (!provider) return Number.MAX_SAFE_INTEGER;
+    const value = rank[provider] ?? rank[provider.toLowerCase()];
+    return typeof value === "number" ? value : Number.MAX_SAFE_INTEGER;
+  };
+  return candidates.map((model, index) => {
+    const provider = providerOfModelRef(model);
+    return {
+      model,
+      index,
+      exhausted: provider && deprioritized.has(provider.toLowerCase()) ? 1 : 0,
+      anchored: anchorProvider && provider === anchorProvider ? 0 : 1,
+      rank: rankFor(provider)
+    };
+  }).sort((a, b) => a.exhausted - b.exhausted || a.anchored - b.anchored || a.rank - b.rank || a.index - b.index).map((entry) => entry.model);
+}
+function resolveModelFallbackPolicy(config, env = process.env) {
+  const envMaxAuto = env.PI_CREW_MAX_AUTO_FALLBACKS;
+  let maxAutoFallbacks;
+  if (envMaxAuto) {
+    const parsed = Number.parseInt(envMaxAuto, 10);
+    if (Number.isFinite(parsed) && parsed >= 0) {
+      maxAutoFallbacks = parsed;
+    } else if (Number.isFinite(parsed)) {
+      logInternalError(
+        "model-fallback.max-auto-fallbacks-invalid",
+        void 0,
+        `PI_CREW_MAX_AUTO_FALLBACKS="${envMaxAuto}" is negative, clamped to 0`,
+        "warn"
+      );
+      maxAutoFallbacks = 0;
+    } else {
+      logInternalError(
+        "model-fallback.max-auto-fallbacks-invalid",
+        void 0,
+        `PI_CREW_MAX_AUTO_FALLBACKS="${envMaxAuto}" is invalid, falling back to config`,
+        "warn"
+      );
+      maxAutoFallbacks = config?.maxAutoFallbacks;
+    }
+  } else {
+    maxAutoFallbacks = config?.maxAutoFallbacks;
+  }
+  const order = env.PI_CREW_MODEL_FALLBACK_ORDER ?? config?.order;
+  const requireCredentials = env.PI_CREW_MODEL_REQUIRE_CREDENTIALS === "1" ? true : env.PI_CREW_MODEL_REQUIRE_CREDENTIALS === "0" ? false : config?.requireCredentials;
+  const quotaAware = config?.quotaAwareOrdering !== false;
+  if (maxAutoFallbacks === void 0 && !order && requireCredentials === void 0 && config?.quotaAwareOrdering === void 0)
+    return void 0;
+  return {
+    ...maxAutoFallbacks !== void 0 && Number.isFinite(maxAutoFallbacks) ? { maxAutoFallbacks } : {},
+    ...order ? { order } : {},
+    ...requireCredentials !== void 0 ? { requireCredentials } : {},
+    quotaAwareOrdering: quotaAware
+  };
+}
+function resolveDefaultSubagentModel(config, env = process.env) {
+  return env.PI_CREW_MODEL?.trim() || config?.defaultSubagentModel?.trim() || void 0;
+}
+function buildConfiguredModelRouting(input) {
+  const registryModels = availableModelInfosFromRegistry(input.modelRegistry);
+  const configModels = configuredModelInfosFromPiConfig(input.cwd, {
+    requireCredentials: input.policy?.requireCredentials
+  });
+  const availableModels = registryModels && registryModels.length > 0 ? registryModels : configModels.length > 0 ? configModels : registryModels;
+  const parentModel = modelStringFromUnknown(input.parentModel);
+  const preferredProvider = providerOfModelRef(parentModel) ?? availableModels?.[0]?.provider;
+  const defaultSubagent = input.defaultSubagentModel?.trim() || void 0;
+  const effectiveAgentModel = input.agentModel?.trim() ? input.agentModel : defaultSubagent ?? parentModel;
+  const requested = [input.overrideModel, input.stepModel, input.teamRoleModel, effectiveAgentModel].find(
+    (model) => Boolean(model?.trim())
+  );
+  if (availableModels && availableModels.length === 0)
+    return {
+      requested,
+      candidates: [],
+      reason: "no configured Pi models available"
+    };
+  const declaredRaw = [
+    input.overrideModel,
+    input.stepModel,
+    input.teamRoleModel,
+    effectiveAgentModel,
+    // When defaultSubagentModel replaced parentModel as the effective agent
+    // model, keep parentModel as an explicit fallback before the auto tail.
+    ...defaultSubagent && !input.agentModel?.trim() ? [parentModel] : [],
+    ...input.teamRoleFallbackModels ?? [],
+    ...input.fallbackModels ?? []
+  ];
+  const parentModelRaw = effectiveAgentModel?.trim() || void 0;
+  const parentModelFallback = defaultSubagent && !input.agentModel?.trim() ? parentModel : void 0;
+  const declaredModels = declaredRaw.filter((model) => Boolean(model?.trim())).filter((model, idx) => {
+    if (parentModelRaw && idx === 0 && model.trim() === parentModelRaw) return true;
+    if (parentModelFallback && model.trim() === parentModelFallback) return true;
+    return isAvailableModel(model.trim(), availableModels);
+  });
+  const declaredCandidates = buildModelCandidates(declaredModels[0], declaredModels.slice(1), availableModels, preferredProvider);
+  const autoRaw = availableModels ? availableModels.map((model) => model.fullId) : parentModel ? [parentModel] : [];
+  const declaredSet = new Set(declaredCandidates);
+  const autoResolved = buildModelCandidates(void 0, autoRaw, availableModels, preferredProvider).filter(
+    (candidate) => !declaredSet.has(candidate)
+  );
+  const anchorProvider = providerOfModelRef(declaredCandidates[0]) ?? providerOfModelRef(parentModel);
+  let effectivePolicy = input.policy;
+  if (effectivePolicy?.quotaAwareOrdering !== false && autoResolved.length > 0) {
+    const tailProviders = [...new Set(autoResolved.map((m) => providerOfModelRef(m)).filter((p) => Boolean(p)))];
+    const deprioritized = deprioritizedProviders(tailProviders);
+    const rank = providerRankFromQuota(tailProviders);
+    if (deprioritized.length > 0 || Object.keys(rank).length > 0) {
+      effectivePolicy = {
+        ...effectivePolicy,
+        deprioritizedProviders: [...effectivePolicy?.deprioritizedProviders ?? [], ...deprioritized],
+        providerRank: { ...rank, ...effectivePolicy?.providerRank ?? {} }
+      };
+    }
+  }
+  const autoOrdered = orderAutoFallbacks(autoResolved, effectivePolicy, anchorProvider);
+  const autoCandidates = effectivePolicy?.maxAutoFallbacks === void 0 ? autoOrdered : autoOrdered.slice(0, Math.max(0, effectivePolicy.maxAutoFallbacks));
+  const candidates = [...declaredCandidates, ...autoCandidates];
+  const resolvedRequested = requested ? resolveModelCandidate(requested, availableModels, preferredProvider) : void 0;
+  const droppedRequested = requested && candidates[0] && resolvedRequested !== candidates[0] ? requested : void 0;
+  const reason = droppedRequested ? "requested model unavailable; selected configured Pi fallback" : candidates.length > 1 ? "configured Pi fallback chain" : void 0;
+  let scopeVerdict;
+  if (input.scopeModelsPatterns && input.scopeModelsPatterns.length > 0) {
+    const resolved = candidates[0] ?? requested;
+    const source = input.isFrontmatterOverride ? "frontmatter" : input.overrideModel ? "caller" : input.stepModel ? "caller" : input.teamRoleModel ? "caller" : input.agentModel?.trim() ? "frontmatter" : "resolved";
+    scopeVerdict = checkModelScope(resolved, input.scopeModelsPatterns, source);
+    if (!scopeVerdict.inScope && source === "caller" && !input.isFrontmatterOverride) {
+      throw errors.modelOutOfScope(resolved ?? "", input.scopeModelsPatterns);
+    }
+  }
+  return {
+    requested,
+    candidates,
+    reason,
+    droppedRequested,
+    autoFallbackCount: autoCandidates.length,
+    scopeVerdict
+  };
+}
+function warnOutOfScopeSoft(verdict, scope, prefix = "Model") {
+  if (!verdict || verdict.inScope || verdict.source === "caller") return;
+  logInternalError(
+    scope,
+    void 0,
+    `${prefix} "${verdict.model}" from source "${verdict.source}" is outside enabledModels scope: ${verdict.reason ?? "unknown"}. Running anyway (soft warn).`,
+    "warn"
+  );
+}
+var configuredModelCache, RETRYABLE_MODEL_FAILURE_PATTERNS, NON_RETRYABLE_MODEL_FAILURE_PATTERNS;
+var init_model_fallback = __esm({
+  "src/runtime/model/model-fallback.ts"() {
+    "use strict";
+    init_errors3();
+    init_internal_error();
+    init_model_resolver();
+    init_model_scope();
+    init_provider_quota();
+    configuredModelCache = /* @__PURE__ */ new Map();
+    RETRYABLE_MODEL_FAILURE_PATTERNS = [
+      /rate.?limit/i,
+      /too many requests/i,
+      /\b429\b/,
+      /rate_limit_error/i,
+      /quota/i,
+      /provider.*unavailable/i,
+      /model.*unavailable/i,
+      /model.*disabled/i,
+      /model.*not found/i,
+      /unknown model/i,
+      /overloaded/i,
+      /service unavailable/i,
+      /temporar(?:ily)? unavailable/i,
+      /connection refused/i,
+      /fetch failed/i,
+      /network error/i,
+      /socket hang up/i,
+      /upstream/i,
+      /timed? out/i,
+      /timeout/i,
+      /\b502\b/,
+      /\b503\b/,
+      /\b504\b/,
+      //
+      // Provider-side 5xx / generic api_error. The pi-core retry layer already
+      // retries these (agent-session.ts matches `500|server error|internal error`),
+      // but the pi-crew MODEL FALLBACK layer must ALSO treat them as retryable so
+      // that when the provider is hard-down across all 3 provider retries, we fail
+      // over to the next configured model instead of giving up. Reported case
+      // (2026-06-17): `500 {"type":"error","error":{"type":"api_error",
+      // "message":"unknown error, 999 (1000)"}}` — a transient provider outage that
+      // should trigger the fallback chain, not abort.
+      //
+      // `api_error` is the OpenAI-compatible generic error type (vs rate_limit_error
+      // / overloaded_error / etc.) and almost always means a transient server fault.
+      //
+      // `unknown error` is the body of the generic message; `internal`/`server`
+      // catch the common phrasings. `\b500\b`/`\b501\b` catch the HTTP status in
+      // the rendered error string.
+      /\b500\b/,
+      /\b501\b/,
+      /api_error/i,
+      /unknown error/i,
+      /internal(?:_server)?[ _]error/i,
+      /server error/i,
+      /bad gateway/i,
+      //
+      // Broader retryable patterns (added 2026-06-25, FIX 2):
+      // - `/provider[_ ]?error/i`: OpenAI-compatible "Provider error" generic fault.
+      // - `/context[_ ]?length[_ ]?exceeded/i`: "context_length_exceeded" from
+      //   OpenAI/Anthropic — when the configured model is the bottleneck, a
+      //   different model in the fallback chain may have a larger window.
+      // - `/safety/i`: Anthropic safety blocks — typically retryable on a
+      //   different model in the fallback chain.
+      // - `/is[_ ]?overloaded/i`: alias to the existing `/overloaded/i` pattern
+      //   to catch phrasings like "upstream is overloaded".
+      // - `/\b408\b/`: HTTP 408 Request Timeout — transient, provider-side.
+      //
+      // Intentionally NOT added: `/bad_request/` — can mean bad input (e.g.
+      // invalid schema), which is non-retryable.
+      /provider[_ ]?error/i,
+      /context[_ ]?length[_ ]?exceeded/i,
+      /safety/i,
+      /is[_ ]?overloaded/i,
+      /\b408\b/
+    ];
+    NON_RETRYABLE_MODEL_FAILURE_PATTERNS = [
+      /auth(?:entication)?/i,
+      /unauthori[sz]ed/i,
+      /forbidden/i,
+      /api key/i,
+      /token expired/i,
+      /invalid key/i,
+      /billing/i,
+      /credit/i
+    ];
+  }
+});
+
+// src/runtime/model/session-model.ts
+function noteSessionModel(model, source = "model_select") {
+  const normalized = modelRefToString(model);
+  if (!normalized) return;
+  if (source === "session_start" && state.source === "model_select") return;
+  state.model = normalized;
+  state.source = source;
+  state.updatedAt = Date.now();
+}
+function noteSessionThinking(level) {
+  if (typeof level !== "string") return;
+  const value = level.trim();
+  state.thinking = value && value !== "off" ? value : void 0;
+}
+function currentSessionModel() {
+  return state.model;
+}
+function currentSessionThinking() {
+  return state.thinking;
+}
+function resolveParentModel(ctxModel) {
+  return state.model ?? modelRefToString(ctxModel);
+}
+function captureRunModelContext(ctx, override) {
+  const parentModel = resolveParentModel(ctx.model);
+  const registryModels = availableModelInfosFromRegistry(ctx.modelRegistry);
+  const availableModels = registryModels && registryModels.length > 0 ? registryModels.map((model) => model.fullId) : void 0;
+  const parentThinking = currentSessionThinking() ?? (typeof ctx.thinkingLevel === "string" ? ctx.thinkingLevel : void 0);
+  const trimmedOverride = override?.trim() || void 0;
+  if (!parentModel && !availableModels && !parentThinking && !trimmedOverride) return void 0;
+  return {
+    ...trimmedOverride ? { override: trimmedOverride } : {},
+    ...parentModel ? { parentModel } : {},
+    ...parentThinking && parentThinking !== "off" ? { parentThinking } : {},
+    ...availableModels ? { availableModels } : {}
+  };
+}
+function sessionModelSnapshot() {
+  return { ...state };
+}
+var state;
+var init_session_model = __esm({
+  "src/runtime/model/session-model.ts"() {
+    "use strict";
+    init_model_fallback();
+    state = { source: "none" };
+  }
+});
+
 // src/extension/team-tool/config-patch.ts
 function sanitizeObject2(obj) {
   if (obj === null || obj === void 0 || typeof obj !== "object") return obj;
@@ -21914,14 +22654,14 @@ var init_i18n = __esm({
 });
 
 // src/runtime/async-marker.ts
-import * as fs31 from "node:fs";
-import * as path27 from "node:path";
+import * as fs32 from "node:fs";
+import * as path28 from "node:path";
 function asyncStartMarkerPath(manifest) {
-  return path27.join(manifest.stateRoot, "async.pid");
+  return path28.join(manifest.stateRoot, "async.pid");
 }
 function hasAsyncStartMarker(manifest) {
   try {
-    const raw = JSON.parse(fs31.readFileSync(asyncStartMarkerPath(manifest), "utf-8"));
+    const raw = JSON.parse(fs32.readFileSync(asyncStartMarkerPath(manifest), "utf-8"));
     return typeof raw.pid === "number" && Number.isInteger(raw.pid) && raw.pid > 0 && typeof raw.startedAt === "string" && raw.startedAt.length > 0;
   } catch {
     return false;
@@ -22034,8 +22774,8 @@ var init_process_status = __esm({
 });
 
 // src/runtime/run-tracker.ts
-import * as fs32 from "node:fs";
-import * as path28 from "node:path";
+import * as fs33 from "node:fs";
+import * as path29 from "node:path";
 function registerRunPromise(runId) {
   let resolve25;
   let reject;
@@ -22083,8 +22823,8 @@ async function waitForRun(runId, cwd, options = {}) {
   let attempt = 0;
   while (Date.now() < deadline) {
     if (attempt === 0) {
-      const runDir = path28.join(projectCrewRoot(cwd), "state", "runs", runId);
-      if (!fs32.existsSync(runDir)) {
+      const runDir = path29.join(projectCrewRoot(cwd), "state", "runs", runId);
+      if (!fs33.existsSync(runDir)) {
         throw new Error(`Run ${runId} not found. No run directory at ${runDir}`);
       }
     }
@@ -22234,13 +22974,13 @@ var init_crew_hooks = __esm({
 });
 
 // src/runtime/skill-effectiveness.ts
-import { existsSync as existsSync23, mkdirSync as mkdirSync14, readFileSync as readFileSync22, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname16, join as join28 } from "node:path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync14, readFileSync as readFileSync23, writeFileSync as writeFileSync4 } from "node:fs";
+import { dirname as dirname16, join as join29 } from "node:path";
 function getSkillMetricsPath(cwd, runId) {
-  return join28(projectCrewRoot(cwd), `state/runs/${runId}/skill-metrics.jsonl`);
+  return join29(projectCrewRoot(cwd), `state/runs/${runId}/skill-metrics.jsonl`);
 }
 function getSkillActivationsPath(cwd, runId) {
-  return join28(projectCrewRoot(cwd), `state/runs/${runId}/skill-activations.jsonl`);
+  return join29(projectCrewRoot(cwd), `state/runs/${runId}/skill-activations.jsonl`);
 }
 function ensureSkillMetricsDir(cwd, runId) {
   const dir = dirname16(getSkillMetricsPath(cwd, runId));
@@ -22297,7 +23037,7 @@ function getSkillActivations(cwd, runId) {
   if (!existsSync23(path89)) {
     return [];
   }
-  const content = readFileSync22(path89, "utf-8");
+  const content = readFileSync23(path89, "utf-8");
   if (!content.trim()) {
     return [];
   }
@@ -22475,10 +23215,10 @@ __export(skill_instructions_exports, {
   resetSkillCacheStats: () => resetSkillCacheStats,
   resolveTaskSkillNames: () => resolveTaskSkillNames
 });
-import * as fs33 from "node:fs";
-import * as path29 from "node:path";
+import * as fs34 from "node:fs";
+import * as path30 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
-import * as os9 from "node:os";
+import * as os10 from "node:os";
 function isValidSkillName(name) {
   return name.length > 0 && name.length <= MAX_SKILL_NAME_CHARS && isSafePathId(name);
 }
@@ -22528,18 +23268,18 @@ function candidateSkillDirs(cwd) {
     // F6 (v0.7.9): same five roots as discover-skills, in the same precedence
     // order. The first hit wins, so a project `.pi/skills/foo/SKILL.md`
     // overrides both the bundled `foo` and any legacy `<cwd>/skills/foo`.
-    { root: path29.resolve(cwd, ".pi", "skills"), source: "project-pi" },
+    { root: path30.resolve(cwd, ".pi", "skills"), source: "project-pi" },
     {
-      root: path29.resolve(cwd, ".agents", "skills"),
+      root: path30.resolve(cwd, ".agents", "skills"),
       source: "project-agents"
     },
-    { root: path29.resolve(cwd, "skills"), source: "project" },
-    { root: path29.join(getAgentDir(), "skills"), source: "user-pi" },
+    { root: path30.resolve(cwd, "skills"), source: "project" },
+    { root: path30.join(getAgentDir(), "skills"), source: "user-pi" },
     {
-      root: path29.join(os9.homedir(), ".agents", "skills"),
+      root: path30.join(os10.homedir(), ".agents", "skills"),
       source: "user-agents"
     },
-    { root: path29.join(os9.homedir(), ".pi", "skills"), source: "user-pi" }
+    { root: path30.join(os10.homedir(), ".pi", "skills"), source: "user-pi" }
   ];
 }
 function rememberSkill(key, value) {
@@ -22577,7 +23317,7 @@ function _setSkillCacheMaxEntriesForTesting(max) {
 }
 function cachedSkillFresh(value) {
   try {
-    const stat2 = fs33.statSync(value.path);
+    const stat2 = fs34.statSync(value.path);
     return stat2.mtimeMs === value.mtimeMs && stat2.size === value.size;
   } catch {
     return false;
@@ -22585,7 +23325,7 @@ function cachedSkillFresh(value) {
 }
 function readSkillMarkdown(cwd, name) {
   if (!isValidSkillName(name)) return void 0;
-  const cacheKey2 = `${path29.resolve(cwd)}:${name}`;
+  const cacheKey2 = `${path30.resolve(cwd)}:${name}`;
   const cached2 = skillReadCache.get(cacheKey2);
   if (cached2 && cachedSkillFresh(cached2)) {
     skillCacheStats.hits++;
@@ -22596,13 +23336,13 @@ function readSkillMarkdown(cwd, name) {
   skillCacheStats.currentSize = skillReadCache.size;
   for (const entry of candidateSkillDirs(cwd)) {
     try {
-      const relative9 = path29.join(name, "SKILL.md");
+      const relative9 = path30.join(name, "SKILL.md");
       const contained = resolveRealContainedPath(entry.root, relative9);
-      if (!fs33.existsSync(contained)) continue;
-      if (fs33.lstatSync(contained).isSymbolicLink()) continue;
+      if (!fs34.existsSync(contained)) continue;
+      if (fs34.lstatSync(contained).isSymbolicLink()) continue;
       const filePath = resolveRealContainedPath(entry.root, relative9);
-      const stat2 = fs33.statSync(filePath);
-      const rawContent = fs33.readFileSync(filePath, "utf-8");
+      const stat2 = fs34.statSync(filePath);
+      const rawContent = fs34.readFileSync(filePath, "utf-8");
       return rememberSkill(cacheKey2, {
         path: filePath,
         source: entry.source,
@@ -22671,7 +23411,7 @@ Skill '${safeName}' was selected but no SKILL.md file was found. Continue with t
       if (!pushSection(missing)) omittedCount += 1;
       continue;
     }
-    skillPaths.push(path29.dirname(loaded.path));
+    skillPaths.push(path30.dirname(loaded.path));
     const description = frontmatterDescription(loaded.content);
     const source = loaded.source === "project" ? `project:skills/${safeName}` : `package:skills/${safeName}`;
     const weighted = weightedSkills?.find((w) => w.skillId === name);
@@ -22686,7 +23426,7 @@ Skill '${safeName}' was selected but no SKILL.md file was found. Continue with t
       // spec "small instruction + large local reference" pattern, e.g.
       // effective-html's `references/html-effectiveness/`) leave the agent
       // guessing the skill dir. No behavior change for corpus-less skills.
-      `Path: ${path29.dirname(loaded.path)}`
+      `Path: ${path30.dirname(loaded.path)}`
     ].filter(Boolean).join("\n");
     const rawContent = loaded.compacted;
     const wrappedContent = `<!-- skill: ${safeName} -->
@@ -22730,7 +23470,7 @@ var init_skill_instructions = __esm({
     init_safe_paths();
     init_skill_effectiveness();
     init_peer_dep();
-    PACKAGE_SKILLS_DIR = path29.resolve(path29.dirname(fileURLToPath4(import.meta.url)), "..", "..", "skills");
+    PACKAGE_SKILLS_DIR = path30.resolve(path30.dirname(fileURLToPath4(import.meta.url)), "..", "..", "skills");
     MAX_SKILL_CHARS = 1500;
     MAX_TOTAL_CHARS = 6e3;
     MAX_SKILL_NAME_CHARS = 80;
@@ -23630,15 +24370,15 @@ var init_anchor = __esm({
 });
 
 // src/runtime/agent-observability.ts
-import * as fs34 from "node:fs";
+import * as fs35 from "node:fs";
 function readTextTail(filePath, maxBytes = 64e3) {
-  if (!fs34.existsSync(filePath)) return { path: filePath, text: "", bytes: 0, truncated: false };
-  const stat2 = fs34.statSync(filePath);
+  if (!fs35.existsSync(filePath)) return { path: filePath, text: "", bytes: 0, truncated: false };
+  const stat2 = fs35.statSync(filePath);
   const bytesToRead = Math.min(stat2.size, Math.max(0, maxBytes));
-  const fd = fs34.openSync(filePath, "r");
+  const fd = fs35.openSync(filePath, "r");
   try {
     const buffer = Buffer.alloc(bytesToRead);
-    fs34.readSync(fd, buffer, 0, bytesToRead, stat2.size - bytesToRead);
+    fs35.readSync(fd, buffer, 0, bytesToRead, stat2.size - bytesToRead);
     return {
       path: filePath,
       text: buffer.toString("utf-8"),
@@ -23646,7 +24386,7 @@ function readTextTail(filePath, maxBytes = 64e3) {
       truncated: stat2.size > bytesToRead
     };
   } finally {
-    fs34.closeSync(fd);
+    fs35.closeSync(fd);
   }
 }
 function compactDuration(ms) {
@@ -23685,8 +24425,8 @@ function outputWarning(manifest, agent) {
   if (agent.status !== "completed") return "";
   try {
     const outputPath = agentOutputPath(manifest, agent.taskId);
-    if (!fs34.existsSync(outputPath)) return " no-output";
-    return fs34.statSync(outputPath).size === 0 ? " no-output" : "";
+    if (!fs35.existsSync(outputPath)) return " no-output";
+    return fs35.statSync(outputPath).size === 0 ? " no-output" : "";
   } catch {
     return " no-output";
   }
@@ -23738,9 +24478,9 @@ var init_agent_observability = __esm({
 });
 
 // src/skills/validate.ts
-import * as fs35 from "node:fs";
+import * as fs36 from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import * as path30 from "node:path";
+import * as path31 from "node:path";
 function getYaml() {
   if (!yamlModule) {
     const require4 = createRequire3(import.meta.url);
@@ -23776,11 +24516,11 @@ function warn(path89, field, reason) {
 }
 function validateSkillFrontmatter(skillDir) {
   const errors2 = [];
-  const skillMdPath = path30.join(skillDir, "SKILL.md");
-  const derivedName = path30.basename(skillDir);
+  const skillMdPath = path31.join(skillDir, "SKILL.md");
+  const derivedName = path31.basename(skillDir);
   let content;
   try {
-    content = fs35.readFileSync(skillMdPath, "utf-8");
+    content = fs36.readFileSync(skillMdPath, "utf-8");
   } catch (e) {
     errors2.push(hard(skillDir, "SKILL.md", `Cannot read SKILL.md: ${e.message}`));
     return { ok: false, errors: errors2 };
@@ -23911,25 +24651,25 @@ var init_validate = __esm({
 });
 
 // src/skills/discover-skills.ts
-import * as fs36 from "node:fs";
-import * as os10 from "node:os";
-import * as path31 from "node:path";
+import * as fs37 from "node:fs";
+import * as os11 from "node:os";
+import * as path32 from "node:path";
 import { fileURLToPath as fileURLToPath5 } from "node:url";
 function listSkillDirs(cwd) {
   return [
     { root: PACKAGE_SKILLS_DIR2, source: "package" },
-    { root: path31.resolve(cwd, ".pi", "skills"), source: "project-pi" },
+    { root: path32.resolve(cwd, ".pi", "skills"), source: "project-pi" },
     {
-      root: path31.resolve(cwd, ".agents", "skills"),
+      root: path32.resolve(cwd, ".agents", "skills"),
       source: "project-agents"
     },
-    { root: path31.resolve(cwd, "skills"), source: "project" },
-    { root: path31.join(getAgentDir(), "skills"), source: "user-pi" },
+    { root: path32.resolve(cwd, "skills"), source: "project" },
+    { root: path32.join(getAgentDir(), "skills"), source: "user-pi" },
     {
-      root: path31.join(os10.homedir(), ".agents", "skills"),
+      root: path32.join(os11.homedir(), ".agents", "skills"),
       source: "user-agents"
     },
-    { root: path31.join(os10.homedir(), ".pi", "skills"), source: "user-pi" }
+    { root: path32.join(os11.homedir(), ".pi", "skills"), source: "user-pi" }
   ];
 }
 function readDescription(content) {
@@ -23954,29 +24694,29 @@ function discoverSkills(cwd) {
   const results = [];
   const diagnostics = [];
   for (const dir of listSkillDirs(cwd)) {
-    if (!fs36.existsSync(dir.root)) continue;
+    if (!fs37.existsSync(dir.root)) continue;
     try {
-      for (const entry of fs36.readdirSync(dir.root, {
+      for (const entry of fs37.readdirSync(dir.root, {
         withFileTypes: true
       })) {
         if (!entry.isDirectory()) continue;
         if (!isSafePathId(entry.name)) continue;
-        const skillDirPath = path31.join(dir.root, entry.name);
+        const skillDirPath = path32.join(dir.root, entry.name);
         try {
-          if (fs36.lstatSync(skillDirPath).isSymbolicLink()) continue;
+          if (fs37.lstatSync(skillDirPath).isSymbolicLink()) continue;
         } catch {
           continue;
         }
-        const skillMdRelative = path31.join(entry.name, "SKILL.md");
+        const skillMdRelative = path32.join(entry.name, "SKILL.md");
         let skillMdPath;
         try {
           skillMdPath = resolveContainedPath(dir.root, skillMdRelative);
         } catch {
           continue;
         }
-        if (!fs36.existsSync(skillMdPath)) continue;
+        if (!fs37.existsSync(skillMdPath)) continue;
         try {
-          if (fs36.lstatSync(skillMdPath).isSymbolicLink()) continue;
+          if (fs37.lstatSync(skillMdPath).isSymbolicLink()) continue;
         } catch {
           continue;
         }
@@ -23988,12 +24728,12 @@ function discoverSkills(cwd) {
             skillMdPath = readPath;
           } catch {
           }
-          const content = fs36.readFileSync(readPath, "utf-8");
+          const content = fs37.readFileSync(readPath, "utf-8");
           const { description: desc, parseError } = readDescription(content);
           description = desc;
           if (parseError) {
             diagnostics.push({
-              path: path31.dirname(skillMdPath),
+              path: path32.dirname(skillMdPath),
               field: "frontmatter",
               reason: parseError,
               severity: "error"
@@ -24015,7 +24755,7 @@ function discoverSkills(cwd) {
   }
   const filtered = [];
   for (const skill of results) {
-    const validation = validateSkillFrontmatter(path31.dirname(skill.path));
+    const validation = validateSkillFrontmatter(path32.dirname(skill.path));
     if (validation.ok) {
       filtered.push(skill);
     } else {
@@ -24034,7 +24774,7 @@ var init_discover_skills = __esm({
     init_internal_error();
     init_safe_paths();
     init_validate();
-    PACKAGE_SKILLS_DIR2 = path31.resolve(path31.dirname(fileURLToPath5(import.meta.url)), "..", "..", "skills");
+    PACKAGE_SKILLS_DIR2 = path32.resolve(path32.dirname(fileURLToPath5(import.meta.url)), "..", "..", "skills");
     CACHE_TTL_MS = 3e4;
     cache2 = null;
     lastDiagnostics = [];
@@ -24141,15 +24881,15 @@ var init_capability_inventory = __esm({
 });
 
 // src/runtime/foreground-control.ts
-import * as fs37 from "node:fs";
-import * as path32 from "node:path";
+import * as fs38 from "node:fs";
+import * as path33 from "node:path";
 function foregroundControlPath(manifest) {
-  return path32.join(manifest.stateRoot, "foreground-control.json");
+  return path33.join(manifest.stateRoot, "foreground-control.json");
 }
 function readLastRequest(controlPath) {
-  if (!fs37.existsSync(controlPath)) return void 0;
+  if (!fs38.existsSync(controlPath)) return void 0;
   try {
-    const parsed = JSON.parse(fs37.readFileSync(controlPath, "utf-8"));
+    const parsed = JSON.parse(fs38.readFileSync(controlPath, "utf-8"));
     return parsed.requests?.at(-1);
   } catch {
     return void 0;
@@ -24173,7 +24913,7 @@ function readForegroundControlStatus(manifest, tasks) {
 function writeForegroundInterruptRequest(manifest, reason = "User requested foreground interrupt.") {
   const controlPath = foregroundControlPath(manifest);
   const lockDir = `${controlPath}.lock`;
-  const pidFile = path32.join(lockDir, "pid");
+  const pidFile = path33.join(lockDir, "pid");
   let requests = [];
   const acquireLock = () => {
     const timeout = 5e3;
@@ -24181,7 +24921,7 @@ function writeForegroundInterruptRequest(manifest, reason = "User requested fore
     const start = Date.now();
     while (true) {
       try {
-        fs37.mkdirSync(lockDir, { recursive: true });
+        fs38.mkdirSync(lockDir, { recursive: true });
         try {
           atomicWriteFile(pidFile, String(process.pid));
         } catch {
@@ -24190,7 +24930,7 @@ function writeForegroundInterruptRequest(manifest, reason = "User requested fore
       } catch {
         if (Date.now() - start > timeout) {
           try {
-            const raw = fs37.readFileSync(pidFile, "utf-8").trim();
+            const raw = fs38.readFileSync(pidFile, "utf-8").trim();
             const ownerPid = Number.parseInt(raw, 10);
             if (!Number.isNaN(ownerPid) && ownerPid !== process.pid) {
               let alive = false;
@@ -24200,7 +24940,7 @@ function writeForegroundInterruptRequest(manifest, reason = "User requested fore
               } catch {
               }
               if (!alive) {
-                fs37.rmSync(lockDir, {
+                fs38.rmSync(lockDir, {
                   recursive: true,
                   force: true
                 });
@@ -24217,7 +24957,7 @@ function writeForegroundInterruptRequest(manifest, reason = "User requested fore
           throw err2;
         }
         try {
-          const raw = fs37.readFileSync(pidFile, "utf-8").trim();
+          const raw = fs38.readFileSync(pidFile, "utf-8").trim();
           const ownerPid = Number.parseInt(raw, 10);
           if (!Number.isNaN(ownerPid) && ownerPid !== process.pid) {
             let alive = false;
@@ -24227,9 +24967,9 @@ function writeForegroundInterruptRequest(manifest, reason = "User requested fore
             } catch {
             }
             if (!alive) {
-              const stat2 = fs37.statSync(lockDir);
+              const stat2 = fs38.statSync(lockDir);
               if (Date.now() - stat2.mtimeMs > staleMs) {
-                fs37.rmSync(lockDir, {
+                fs38.rmSync(lockDir, {
                   recursive: true,
                   force: true
                 });
@@ -24245,15 +24985,15 @@ function writeForegroundInterruptRequest(manifest, reason = "User requested fore
   };
   const releaseLock2 = () => {
     try {
-      fs37.rmSync(lockDir, { recursive: true, force: true });
+      fs38.rmSync(lockDir, { recursive: true, force: true });
     } catch {
     }
   };
   acquireLock();
   try {
-    if (fs37.existsSync(controlPath)) {
+    if (fs38.existsSync(controlPath)) {
       try {
-        const parsed = JSON.parse(fs37.readFileSync(controlPath, "utf-8"));
+        const parsed = JSON.parse(fs38.readFileSync(controlPath, "utf-8"));
         requests = Array.isArray(parsed.requests) ? parsed.requests : [];
       } catch {
         requests = [];
@@ -24266,7 +25006,7 @@ function writeForegroundInterruptRequest(manifest, reason = "User requested fore
       reason,
       acknowledged: false
     };
-    fs37.mkdirSync(path32.dirname(controlPath), { recursive: true });
+    fs38.mkdirSync(path33.dirname(controlPath), { recursive: true });
     atomicWriteFile(controlPath, `${JSON.stringify({ requests: [...requests, request] }, null, 2)}
 `);
     appendEvent(manifest.eventsPath, {
@@ -24309,7 +25049,7 @@ var init_worker_heartbeat = __esm({
 });
 
 // src/runtime/live-session/live-agent-control.ts
-import * as fs38 from "node:fs";
+import * as fs39 from "node:fs";
 function liveAgentControlFile(manifest, taskId) {
   return agentStateFile(manifest, taskId, "live-control.jsonl");
 }
@@ -24327,7 +25067,7 @@ function appendLiveAgentControlRequest(manifest, input) {
     createdAt: (/* @__PURE__ */ new Date()).toISOString()
   };
   const filePath = liveAgentControlFile(manifest, input.taskId);
-  fs38.appendFileSync(filePath, `${JSON.stringify(request)}
+  fs39.appendFileSync(filePath, `${JSON.stringify(request)}
 `, "utf-8");
   return request;
 }
@@ -24338,8 +25078,8 @@ function readLiveAgentControlRequests(manifest, taskId, cursor = { offset: 0 })
   } catch {
     return { requests: [], cursor };
   }
-  if (!fs38.existsSync(filePath)) return { requests: [], cursor };
-  const text = fs38.readFileSync(filePath, "utf-8");
+  if (!fs39.existsSync(filePath)) return { requests: [], cursor };
+  const text = fs39.readFileSync(filePath, "utf-8");
   const lines = text.split(/\r?\n/).filter(Boolean);
   const requests = lines.slice(cursor.offset).flatMap((line4) => {
     try {
@@ -25134,379 +25874,6 @@ var init_mcp_proxy = __esm({
   }
 });
 
-// src/runtime/model/model-resolver.ts
-function fuzzyResolveModelId(input, models) {
-  const query = input.toLowerCase();
-  let bestMatch;
-  let bestScore = 0;
-  for (const m of models) {
-    const id = m.id.toLowerCase();
-    const name = (m.name ?? "").toLowerCase();
-    const full = `${m.provider}/${m.id}`.toLowerCase();
-    let score = 0;
-    if (id === query || full === query) {
-      score = 100;
-    } else if (id.includes(query) || full.includes(query)) {
-      score = 60 + query.length / id.length * 30;
-    } else if (name.includes(query)) {
-      score = 40 + query.length / (name.length || 1) * 20;
-    } else if (query.split(/[\s\-/]+/).every((part) => id.includes(part) || name.includes(part) || m.provider.toLowerCase().includes(part))) {
-      score = 20;
-    }
-    if (score > bestScore) {
-      bestScore = score;
-      bestMatch = m;
-    }
-  }
-  return bestMatch && bestScore >= 20 ? `${bestMatch.provider}/${bestMatch.id}` : void 0;
-}
-var init_model_resolver = __esm({
-  "src/runtime/model/model-resolver.ts"() {
-    "use strict";
-  }
-});
-
-// src/runtime/model/model-scope.ts
-function patternToRegExp(pattern) {
-  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-  return new RegExp(`${escaped.replace(/\*/g, ".*")}`, "i");
-}
-function matchesModelPattern(modelId, pattern) {
-  if (!modelId || !pattern) return false;
-  const id = modelId.trim();
-  const pat = pattern.trim();
-  if (!id || !pat) return false;
-  if (id.toLowerCase() === pat.toLowerCase()) return true;
-  if (pat.includes("*")) {
-    try {
-      return patternToRegExp(pat).test(id);
-    } catch {
-      return false;
-    }
-  }
-  return id.toLowerCase().includes(pat.toLowerCase());
-}
-function checkModelScope(modelId, patterns, source) {
-  if (!modelId) {
-    return {
-      inScope: true,
-      source,
-      model: "",
-      reason: "no model specified"
-    };
-  }
-  if (!patterns || patterns.length === 0) {
-    return { inScope: true, source, model: modelId };
-  }
-  for (const pattern of patterns) {
-    if (matchesModelPattern(modelId, pattern)) {
-      return {
-        inScope: true,
-        source,
-        model: modelId,
-        matchedPattern: pattern
-      };
-    }
-  }
-  return {
-    inScope: false,
-    source,
-    model: modelId,
-    reason: `model "${modelId}" is not in enabledModels allowlist (${patterns.join(", ")})`
-  };
-}
-async function readEnabledModelsPatterns(cwd, agentDir) {
-  try {
-    const mod = await import("@earendil-works/pi-coding-agent").catch(() => null);
-    if (!mod) return [];
-    const SettingsManagerCtor = mod.SettingsManager;
-    if (!SettingsManagerCtor?.create) return [];
-    const sm = SettingsManagerCtor.create(cwd, agentDir);
-    const patterns = sm.getEnabledModels?.();
-    return Array.isArray(patterns) ? patterns : [];
-  } catch {
-    return [];
-  }
-}
-var init_model_scope = __esm({
-  "src/runtime/model/model-scope.ts"() {
-    "use strict";
-  }
-});
-
-// src/runtime/model/model-fallback.ts
-import * as fs39 from "node:fs";
-import * as os11 from "node:os";
-import * as path33 from "node:path";
-function modelInfoFromUnknown(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
-  const record = value;
-  if (typeof record.provider !== "string" || typeof record.id !== "string") return void 0;
-  return {
-    provider: record.provider,
-    id: record.id,
-    fullId: `${record.provider}/${record.id}`
-  };
-}
-function availableModelInfosFromRegistry(registry2) {
-  if (!registry2 || typeof registry2 !== "object" || Array.isArray(registry2)) return void 0;
-  const candidate = registry2;
-  const raw = typeof candidate.getAvailable === "function" ? candidate.getAvailable() : typeof candidate.getAll === "function" ? candidate.getAll() : void 0;
-  if (!Array.isArray(raw)) return void 0;
-  return raw.map(modelInfoFromUnknown).filter((entry) => entry !== void 0);
-}
-function modelStringFromUnknown(model) {
-  return modelInfoFromUnknown(model)?.fullId;
-}
-function uniqueModelInfos(models) {
-  const seen = /* @__PURE__ */ new Set();
-  return models.filter((model) => {
-    if (seen.has(model.fullId)) return false;
-    seen.add(model.fullId);
-    return true;
-  });
-}
-function readJsonObject(filePath) {
-  try {
-    const parsed = JSON.parse(fs39.readFileSync(filePath, "utf-8"));
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function piAgentDir() {
-  const envDir = process.env.PI_CODING_AGENT_DIR?.trim();
-  if (envDir) {
-    if (envDir === "~") return os11.homedir();
-    if (envDir.startsWith("~/")) return path33.join(os11.homedir(), envDir.slice(2));
-    return envDir;
-  }
-  return path33.join(os11.homedir(), ".pi", "agent");
-}
-function settingsModelInfo(settings) {
-  if (typeof settings?.defaultProvider !== "string" || typeof settings.defaultModel !== "string") return void 0;
-  return {
-    provider: settings.defaultProvider,
-    id: settings.defaultModel,
-    fullId: `${settings.defaultProvider}/${settings.defaultModel}`
-  };
-}
-function modelsJsonInfos(modelsJson) {
-  if (!modelsJson?.providers || typeof modelsJson.providers !== "object" || Array.isArray(modelsJson.providers)) return [];
-  const infos = [];
-  for (const [provider, rawConfig] of Object.entries(modelsJson.providers)) {
-    if (!rawConfig || typeof rawConfig !== "object" || Array.isArray(rawConfig)) continue;
-    const config = rawConfig;
-    if (Array.isArray(config.models)) {
-      for (const rawModel of config.models) {
-        if (!rawModel || typeof rawModel !== "object" || Array.isArray(rawModel)) continue;
-        const id = rawModel.id;
-        if (typeof id === "string") infos.push({ provider, id, fullId: `${provider}/${id}` });
-      }
-    }
-    if (config.modelOverrides && typeof config.modelOverrides === "object" && !Array.isArray(config.modelOverrides)) {
-      for (const id of Object.keys(config.modelOverrides)) infos.push({ provider, id, fullId: `${provider}/${id}` });
-    }
-  }
-  return infos;
-}
-function configuredModelInfosFromPiConfig(cwd) {
-  const agentDir = piAgentDir();
-  const globalSettings = readJsonObject(path33.join(agentDir, "settings.json"));
-  const projectSettings = cwd ? readJsonObject(path33.join(cwd, ".pi", "settings.json")) : void 0;
-  const effectiveSettings = {
-    ...globalSettings ?? {},
-    ...projectSettings ?? {}
-  };
-  const defaultModel = settingsModelInfo(effectiveSettings);
-  return uniqueModelInfos([
-    ...defaultModel ? [defaultModel] : [],
-    ...modelsJsonInfos(readJsonObject(path33.join(agentDir, "models.json")))
-  ]);
-}
-function splitThinkingSuffix(model) {
-  const colonIdx = model.lastIndexOf(":");
-  if (colonIdx === -1) return { baseModel: model, thinkingSuffix: "" };
-  return {
-    baseModel: model.substring(0, colonIdx),
-    thinkingSuffix: model.substring(colonIdx)
-  };
-}
-function resolveModelCandidate(model, availableModels, preferredProvider) {
-  if (!model) return void 0;
-  if (model.includes("/")) return model;
-  if (!availableModels || availableModels.length === 0) return model;
-  const { baseModel, thinkingSuffix } = splitThinkingSuffix(model);
-  const matches = availableModels.filter((entry) => entry.id === baseModel);
-  if (preferredProvider) {
-    const preferredMatch = matches.find((entry) => entry.provider === preferredProvider);
-    if (preferredMatch) return `${preferredMatch.fullId}${thinkingSuffix}`;
-  }
-  if (matches.length !== 1) {
-    const fuzzy = fuzzyResolveModelId(baseModel, availableModels);
-    if (fuzzy) return `${fuzzy}${thinkingSuffix}`;
-    return model;
-  }
-  return `${matches[0].fullId}${thinkingSuffix}`;
-}
-function isRetryableModelFailure(error) {
-  if (!error) return false;
-  if (NON_RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(error))) return false;
-  return RETRYABLE_MODEL_FAILURE_PATTERNS.some((pattern) => pattern.test(error));
-}
-function formatModelAttemptNote(attempt, nextModel) {
-  const failure = attempt.error?.trim() || `exit ${attempt.exitCode ?? 1}`;
-  return nextModel ? `[fallback] ${attempt.model} failed: ${failure}. Retrying with ${nextModel}.` : `[fallback] ${attempt.model} failed: ${failure}.`;
-}
-function buildModelCandidates(primaryModel, fallbackModels, availableModels, preferredProvider) {
-  const seen = /* @__PURE__ */ new Set();
-  const candidates = [];
-  for (const raw of [primaryModel, ...fallbackModels ?? []]) {
-    if (!raw) continue;
-    const normalized = resolveModelCandidate(raw.trim(), availableModels, preferredProvider);
-    if (!normalized || seen.has(normalized)) continue;
-    seen.add(normalized);
-    candidates.push(normalized);
-  }
-  return candidates;
-}
-function isAvailableModel(model, availableModels) {
-  if (!availableModels || availableModels.length === 0) return true;
-  const { baseModel } = splitThinkingSuffix(model);
-  if (baseModel.includes("/")) return availableModels.some((entry) => entry.fullId === baseModel);
-  if (availableModels.some((entry) => entry.id === baseModel)) return true;
-  const fuzzy = fuzzyResolveModelId(baseModel, availableModels);
-  return fuzzy !== void 0;
-}
-function buildConfiguredModelRouting(input) {
-  const registryModels = availableModelInfosFromRegistry(input.modelRegistry);
-  const configModels = configuredModelInfosFromPiConfig(input.cwd);
-  const availableModels = registryModels && registryModels.length > 0 ? registryModels : configModels.length > 0 ? configModels : registryModels;
-  const parentModel = modelStringFromUnknown(input.parentModel);
-  const preferredProvider = parentModel?.split("/")[0] ?? availableModels?.[0]?.provider;
-  const effectiveAgentModel = input.agentModel?.trim() ? input.agentModel : parentModel;
-  const requested = [input.overrideModel, input.stepModel, input.teamRoleModel, effectiveAgentModel].find(
-    (model) => Boolean(model?.trim())
-  );
-  if (availableModels && availableModels.length === 0)
-    return {
-      requested,
-      candidates: [],
-      reason: "no configured Pi models available"
-    };
-  const rawModels = availableModels ? [
-    input.overrideModel,
-    input.stepModel,
-    input.teamRoleModel,
-    effectiveAgentModel,
-    ...input.fallbackModels ?? [],
-    ...availableModels.map((model) => model.fullId)
-  ] : [input.overrideModel, input.stepModel, input.teamRoleModel, effectiveAgentModel, ...input.fallbackModels ?? [], parentModel];
-  const parentModelRaw = effectiveAgentModel?.trim() || void 0;
-  const configuredModels = rawModels.filter((model) => Boolean(model?.trim())).filter((model, idx) => {
-    if (parentModelRaw && idx === 0 && model.trim() === parentModelRaw) return true;
-    return isAvailableModel(model.trim(), availableModels);
-  });
-  const candidates = buildModelCandidates(configuredModels[0], configuredModels.slice(1), availableModels, preferredProvider);
-  const reason = requested && candidates[0] && resolveModelCandidate(requested, availableModels, preferredProvider) !== candidates[0] ? "requested model unavailable; selected configured Pi fallback" : candidates.length > 1 ? "configured Pi fallback chain" : void 0;
-  let scopeVerdict;
-  if (input.scopeModelsPatterns && input.scopeModelsPatterns.length > 0) {
-    const resolved = candidates[0] ?? requested;
-    const source = input.overrideModel ? "caller" : input.agentModel ? "frontmatter" : "resolved";
-    scopeVerdict = checkModelScope(resolved, input.scopeModelsPatterns, source);
-    if (!scopeVerdict.inScope && source === "caller" && !input.isFrontmatterOverride) {
-      throw errors.modelOutOfScope(resolved ?? "", input.scopeModelsPatterns);
-    }
-  }
-  return { requested, candidates, reason, scopeVerdict };
-}
-var RETRYABLE_MODEL_FAILURE_PATTERNS, NON_RETRYABLE_MODEL_FAILURE_PATTERNS;
-var init_model_fallback = __esm({
-  "src/runtime/model/model-fallback.ts"() {
-    "use strict";
-    init_errors3();
-    init_model_resolver();
-    init_model_scope();
-    RETRYABLE_MODEL_FAILURE_PATTERNS = [
-      /rate.?limit/i,
-      /too many requests/i,
-      /\b429\b/,
-      /rate_limit_error/i,
-      /quota/i,
-      /provider.*unavailable/i,
-      /model.*unavailable/i,
-      /model.*disabled/i,
-      /model.*not found/i,
-      /unknown model/i,
-      /overloaded/i,
-      /service unavailable/i,
-      /temporar(?:ily)? unavailable/i,
-      /connection refused/i,
-      /fetch failed/i,
-      /network error/i,
-      /socket hang up/i,
-      /upstream/i,
-      /timed? out/i,
-      /timeout/i,
-      /\b502\b/,
-      /\b503\b/,
-      /\b504\b/,
-      //
-      // Provider-side 5xx / generic api_error. The pi-core retry layer already
-      // retries these (agent-session.ts matches `500|server error|internal error`),
-      // but the pi-crew MODEL FALLBACK layer must ALSO treat them as retryable so
-      // that when the provider is hard-down across all 3 provider retries, we fail
-      // over to the next configured model instead of giving up. Reported case
-      // (2026-06-17): `500 {"type":"error","error":{"type":"api_error",
-      // "message":"unknown error, 999 (1000)"}}` — a transient provider outage that
-      // should trigger the fallback chain, not abort.
-      //
-      // `api_error` is the OpenAI-compatible generic error type (vs rate_limit_error
-      // / overloaded_error / etc.) and almost always means a transient server fault.
-      //
-      // `unknown error` is the body of the generic message; `internal`/`server`
-      // catch the common phrasings. `\b500\b`/`\b501\b` catch the HTTP status in
-      // the rendered error string.
-      /\b500\b/,
-      /\b501\b/,
-      /api_error/i,
-      /unknown error/i,
-      /internal(?:_server)?[ _]error/i,
-      /server error/i,
-      /bad gateway/i,
-      //
-      // Broader retryable patterns (added 2026-06-25, FIX 2):
-      // - `/provider[_ ]?error/i`: OpenAI-compatible "Provider error" generic fault.
-      // - `/context[_ ]?length[_ ]?exceeded/i`: "context_length_exceeded" from
-      //   OpenAI/Anthropic — when the configured model is the bottleneck, a
-      //   different model in the fallback chain may have a larger window.
-      // - `/safety/i`: Anthropic safety blocks — typically retryable on a
-      //   different model in the fallback chain.
-      // - `/is[_ ]?overloaded/i`: alias to the existing `/overloaded/i` pattern
-      //   to catch phrasings like "upstream is overloaded".
-      // - `/\b408\b/`: HTTP 408 Request Timeout — transient, provider-side.
-      //
-      // Intentionally NOT added: `/bad_request/` — can mean bad input (e.g.
-      // invalid schema), which is non-retryable.
-      /provider[_ ]?error/i,
-      /context[_ ]?length[_ ]?exceeded/i,
-      /safety/i,
-      /is[_ ]?overloaded/i,
-      /\b408\b/
-    ];
-    NON_RETRYABLE_MODEL_FAILURE_PATTERNS = [
-      /auth(?:entication)?/i,
-      /unauthori[sz]ed/i,
-      /forbidden/i,
-      /api key/i,
-      /token expired/i,
-      /invalid key/i,
-      /billing/i,
-      /credit/i
-    ];
-  }
-});
-
 // src/runtime/output/sidechain-output.ts
 import * as fs40 from "node:fs";
 import * as path34 from "node:path";
@@ -32556,6 +32923,20 @@ async function resolveScopeModelsPatterns(cwd, agentDir) {
   if (!scopeModels) return [];
   return readEnabledModelsPatterns(cwd, agentDir);
 }
+function resolveLiveModelFallbackPolicy(cwd) {
+  try {
+    return resolveModelFallbackPolicy(loadConfig(cwd).config.runtime?.modelFallback);
+  } catch {
+    return void 0;
+  }
+}
+function resolveLiveDefaultSubagentModel(cwd) {
+  try {
+    return resolveDefaultSubagentModel(loadConfig(cwd).config.runtime?.modelFallback);
+  } catch {
+    return void 0;
+  }
+}
 function modelFromRegistry(modelRegistry, modelId) {
   if (!modelId?.includes("/")) return void 0;
   const registry2 = asRecord6(modelRegistry);
@@ -32570,7 +32951,7 @@ function modelFromRegistry(modelRegistry, modelId) {
   }
 }
 function resolveParentModelFromRegistry(modelRegistry, rawParentModel) {
-  const raw = typeof rawParentModel === "string" ? rawParentModel.trim() : void 0;
+  const raw = modelRefToString(rawParentModel);
   if (raw) {
     const candidate = raw.includes("/") ? raw : (() => {
       const m = modelFromRegistry(modelRegistry, raw);
@@ -32581,18 +32962,11 @@ function resolveParentModelFromRegistry(modelRegistry, rawParentModel) {
     })();
     if (candidate && modelFromRegistry(modelRegistry, candidate)) return candidate;
   }
-  const registry2 = modelRegistry;
-  if (registry2 && typeof registry2.getAvailable === "function") {
-    try {
-      const available = registry2.getAvailable();
-      if (Array.isArray(available) && available.length > 0) {
-        const first = available[0];
-        if (first && typeof first.provider === "string" && typeof first.id === "string") {
-          return `${first.provider}/${first.id}`;
-        }
-      }
-    } catch {
-    }
+  const available = availableModelInfosFromRegistry(modelRegistry);
+  if (available && available.length > 0) {
+    const parentProvider = providerOfModelRef(raw);
+    const sameProvider = parentProvider ? available.find((entry) => entry.provider === parentProvider) : void 0;
+    return (sameProvider ?? available[0]).fullId;
   }
   return raw;
 }
@@ -32852,14 +33226,32 @@ async function runLiveSessionTask(input) {
       overrideModel: input.modelOverride,
       stepModel: input.step.model,
       teamRoleModel: input.teamRoleModel,
+      teamRoleFallbackModels: input.teamRoleFallbackModels,
       agentModel: input.agent.model,
+      defaultSubagentModel: resolveLiveDefaultSubagentModel(input.manifest.cwd),
       fallbackModels: input.agent.fallbackModels,
       parentModel: effectiveParentModel,
       modelRegistry: input.modelRegistry,
       cwd: input.manifest.cwd,
+      policy: resolveLiveModelFallbackPolicy(input.manifest.cwd),
       scopeModelsPatterns: await resolveScopeModelsPatterns(input.manifest.cwd)
     });
     const resolvedModel = modelFromRegistry(input.modelRegistry, modelRouting.candidates[0] ?? modelRouting.requested) ?? input.parentModel;
+    if (modelRouting.droppedRequested) {
+      appendEventFireAndForget(input.manifest.eventsPath, {
+        type: "task.model_dropped",
+        runId: input.manifest.runId,
+        taskId: input.task.id,
+        message: `Requested model "${modelRouting.droppedRequested}" is not available; using "${modelRouting.candidates[0] ?? "default"}" instead.`,
+        data: {
+          requested: modelRouting.droppedRequested,
+          resolved: modelRouting.candidates[0],
+          fallbackChain: modelRouting.candidates
+        }
+      });
+    }
+    warnOutOfScopeSoft(modelRouting.scopeVerdict, "live-session.model-out-of-scope");
+    const effectiveThinking = input.teamRoleThinking ?? input.agent.thinking;
     const mcpProxy = buildMcpProxyFromSession([], { shareMcp: true });
     const submitResultTool = createSubmitResultTool((result4) => {
       customToolYieldResult = result4;
@@ -32880,7 +33272,7 @@ async function runLiveSessionTask(input) {
       } : {},
       ...input.modelRegistry ? { modelRegistry: input.modelRegistry } : {},
       ...resolvedModel ? { model: resolvedModel } : {},
-      ...input.agent.thinking ? { thinkingLevel: input.agent.thinking } : {},
+      ...effectiveThinking ? { thinkingLevel: effectiveThinking } : {},
       ...mcpProxy.enableMcp ? {} : { enableMCP: false },
       customTools
     });
@@ -33218,7 +33610,15 @@ ${input.prompt}` : input.prompt;
       stderr: created.modelFallbackMessage ?? "",
       jsonEvents,
       usage,
-      yieldResult
+      yieldResult,
+      modelRouting: {
+        requested: modelRouting.requested,
+        resolved: modelRefToString(resolvedModel) ?? modelRouting.candidates[0] ?? "default",
+        fallbackChain: modelRouting.candidates,
+        reason: modelRouting.reason,
+        droppedRequested: modelRouting.droppedRequested,
+        autoFallbackCount: modelRouting.autoFallbackCount
+      }
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
@@ -36955,6 +37355,43 @@ function buildTeamDoctorReport(input) {
         }
       ];
     }),
+    section("Model Routing", () => {
+      const snapshot = sessionModelSnapshot();
+      const liveModel = currentSessionModel();
+      const policy = resolveModelFallbackPolicy(loadConfig(input.cwd).config.runtime?.modelFallback);
+      const sampleRouting = buildConfiguredModelRouting({
+        parentModel: liveModel,
+        cwd: input.cwd,
+        policy
+      });
+      return [
+        {
+          label: "session model (live)",
+          ok: true,
+          detail: liveModel ?? "not tracked yet"
+        },
+        {
+          label: "session model (source)",
+          ok: true,
+          detail: `${snapshot.source}${snapshot.updatedAt ? ` @ ${new Date(snapshot.updatedAt).toISOString()}` : ""}`
+        },
+        {
+          label: "fallback policy",
+          ok: true,
+          detail: policy ? `maxAuto=${policy.maxAutoFallbacks ?? "\u221E"} order=${policy.order ?? "parentFirst"} creds=${policy.requireCredentials ?? false} quota=${policy.quotaAwareOrdering ?? true}` : "legacy (unbounded, unordered)"
+        },
+        {
+          label: "sample chain (no explicit model)",
+          ok: true,
+          detail: sampleRouting.candidates.length > 0 ? sampleRouting.candidates.join(" \u2192 ") : "(empty)"
+        },
+        {
+          label: "auto tail size",
+          ok: true,
+          detail: `${sampleRouting.autoFallbackCount ?? 0} models`
+        }
+      ];
+    }),
     section("Discovery", () => {
       const agentModelHints = discoveredAgentsAll.filter((agent) => agent.model || agent.fallbackModels?.length).length;
       return [
@@ -37139,7 +37576,9 @@ var init_doctor = __esm({
     init_config();
     init_defaults();
     init_drift_detector();
+    init_model_fallback();
     init_runtime_warmup();
+    init_session_model();
     init_pi_spawn();
     init_zombie_scanner();
     init_team_tool_schema();
@@ -41164,7 +41603,7 @@ var init_async_runner = __esm({
 });
 
 // src/runtime/goal-workflow/goal-state-store.ts
-import { closeSync as closeSync10, existsSync as existsSync44, mkdirSync as mkdirSync26, openSync as openSync10, readdirSync as readdirSync20, readFileSync as readFileSync42, statSync as statSync32, unlinkSync as unlinkSync7 } from "node:fs";
+import { closeSync as closeSync10, existsSync as existsSync44, mkdirSync as mkdirSync26, openSync as openSync10, readdirSync as readdirSync20, readFileSync as readFileSync42, statSync as statSync33, unlinkSync as unlinkSync7 } from "node:fs";
 import { dirname as dirname32 } from "node:path";
 function resolveGoalsRoot(cwd) {
   const crewRoot = projectCrewRoot(cwd) ?? userCrewRoot();
@@ -41207,22 +41646,22 @@ var init_goal_state_store = __esm({
         }
       }
       /** Atomically persist a goal state. Emits a goal.state_changed event if eventsPath given. */
-      save(state, eventsPath) {
-        assertSafePathId("goalId", state.goalId);
-        const path89 = goalFilePath(this.cwd, state.goalId);
-        const next = { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      save(state2, eventsPath) {
+        assertSafePathId("goalId", state2.goalId);
+        const path89 = goalFilePath(this.cwd, state2.goalId);
+        const next = { ...state2, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
         try {
           mkdirSync26(dirname32(path89), { recursive: true });
           atomicWriteJson(path89, next);
           if (eventsPath) {
             appendEvent(eventsPath, {
               type: "goal.state_changed",
-              runId: state.goalId,
-              data: { goalId: state.goalId, state: state.state }
+              runId: state2.goalId,
+              data: { goalId: state2.goalId, state: state2.state }
             });
           }
         } catch (error) {
-          logInternalError("goal-state-store.save", error, `goalId=${state.goalId}`);
+          logInternalError("goal-state-store.save", error, `goalId=${state2.goalId}`);
           throw error;
         }
       }
@@ -41240,8 +41679,8 @@ var init_goal_state_store = __esm({
         return next;
       }
       /** Convenience: transition state with optional event emission. */
-      setStatus(goalId, state, eventsPath) {
-        return this.patch(goalId, { state }, eventsPath);
+      setStatus(goalId, state2, eventsPath) {
+        return this.patch(goalId, { state: state2 }, eventsPath);
       }
       /**
        * Compare-And-Set status for atomic stuck↔resume transitions (P1b, RFC v0.5 §P1b).
@@ -41295,7 +41734,7 @@ var init_goal_state_store = __esm({
           const code = error.code;
           if (code !== "EEXIST") return false;
           try {
-            const stat2 = statSync32(lockPath2);
+            const stat2 = statSync33(lockPath2);
             if (Date.now() - stat2.mtimeMs > 5e3) {
               unlinkSync7(lockPath2);
               const fd = openSync10(lockPath2, "wx");
@@ -41388,7 +41827,7 @@ var init_verification_integrity = __esm({
 
 // src/runtime/workspace-lock.ts
 import { createHash as createHash7 } from "node:crypto";
-import { closeSync as closeSync11, existsSync as existsSync45, mkdirSync as mkdirSync27, openSync as openSync11, readdirSync as readdirSync21, readFileSync as readFileSync44, statSync as statSync34, unlinkSync as unlinkSync8, writeFileSync as writeFileSync8 } from "node:fs";
+import { closeSync as closeSync11, existsSync as existsSync45, mkdirSync as mkdirSync27, openSync as openSync11, readdirSync as readdirSync21, readFileSync as readFileSync44, statSync as statSync35, unlinkSync as unlinkSync8, writeFileSync as writeFileSync8 } from "node:fs";
 import * as path50 from "node:path";
 function workspaceLockPath(cwd) {
   const absCwd = path50.resolve(cwd);
@@ -42694,8 +43133,8 @@ function registerPiCrewPowerbarSegments(events, config) {
     label: "pi-crew workflow steps"
   });
 }
-function updatePiCrewPowerbar(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount = 0, preloadedManifests) {
-  powerbarPublisher.update(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount, preloadedManifests);
+function updatePiCrewPowerbar(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount = 0, preloadedManifests, workspaceId) {
+  powerbarPublisher.update(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount, preloadedManifests, workspaceId);
 }
 function powerbarKey(payload) {
   return `${payload.text ?? ""}|${payload.suffix ?? ""}|${payload.bar ?? ""}|${payload.color ?? ""}|${payload.icon ?? ""}|${payload.barSegments ?? ""}`;
@@ -42739,8 +43178,8 @@ function buildStepsPayload(active, allTasks) {
     color
   };
 }
-function requestPowerbarUpdate(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount = 0, preloadedManifests) {
-  powerbarPublisher.request(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount, preloadedManifests);
+function requestPowerbarUpdate(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount = 0, preloadedManifests, workspaceId) {
+  powerbarPublisher.request(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount, preloadedManifests, workspaceId);
 }
 function disposePowerbarCoalescer() {
   powerbarPublisher.dispose();
@@ -42762,6 +43201,7 @@ var init_powerbar_publisher = __esm({
     init_usage();
     init_file_coalescer();
     init_internal_error();
+    init_session_utils();
     init_discover_workflows();
     init_render_coalescer();
     init_widget_formatters();
@@ -42777,13 +43217,25 @@ var init_powerbar_publisher = __esm({
           const a = this.#latestArgs;
           this.#latestArgs = null;
           if (!a) return;
-          this.update(a.events, a.cwd, a.config, a.manifestCache, a.snapshotCache, a.ctx, a.notificationCount, a.preloadedManifests);
+          this.update(
+            a.events,
+            a.cwd,
+            a.config,
+            a.manifestCache,
+            a.snapshotCache,
+            a.ctx,
+            a.notificationCount,
+            a.preloadedManifests,
+            a.workspaceId
+          );
         }, 200);
       }
-      update(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount = 0, preloadedManifests) {
+      update(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount = 0, preloadedManifests, workspaceId) {
         if (config?.powerbar === false) return;
         const useStatusFallback = !hasPowerbarConsumer(events);
-        const runs = preloadedManifests ?? (manifestCache2 ? manifestCache2.list(20) : listRecentRuns(cwd, 20));
+        const effectiveWorkspaceId = workspaceId ?? extractSessionId(ctx);
+        const allRuns = preloadedManifests ?? (manifestCache2 ? manifestCache2.list(20) : listRecentRuns(cwd, 20));
+        const runs = effectiveWorkspaceId ? allRuns.filter((run) => !run.ownerSessionId || run.ownerSessionId === effectiveWorkspaceId) : allRuns;
         const active = runs.map((run) => {
           let snapshot;
           try {
@@ -42839,7 +43291,8 @@ var init_powerbar_publisher = __esm({
         const tokenTotal = hasUsage ? (usage.input ?? 0) + (usage.output ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0) : snapshotTokens;
         const model = config?.showModel === false ? void 0 : agents.find((agent) => agent.model)?.model?.split("/").at(-1);
         const tokenText = config?.showTokens === false || !tokenTotal ? void 0 : compactTokens(tokenTotal);
-        const liveRunning = listLiveAgents().filter((a) => a.status === "running").length;
+        const liveAgents2 = effectiveWorkspaceId ? listLiveAgentsByWorkspace(effectiveWorkspaceId) : listLiveAgents();
+        const liveRunning = liveAgents2.filter((a) => a.status === "running").length;
         const runningCount = agents.filter((a) => a.status === "running").length;
         const queuedCount = active.reduce(
           (sum, item) => sum + item.tasks.reduce((s, t2) => s + (t2.status === "queued" || t2.status === "waiting" ? 1 : 0), 0),
@@ -42893,7 +43346,7 @@ var init_powerbar_publisher = __esm({
        * into a single render pass within 200ms, preventing UI flicker from
        * event bursts.
        */
-      request(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount = 0, preloadedManifests) {
+      request(events, cwd, config, manifestCache2, snapshotCache, ctx, notificationCount = 0, preloadedManifests, workspaceId) {
         if (config?.powerbar === false) return;
         this.#latestArgs = {
           events,
@@ -42903,7 +43356,8 @@ var init_powerbar_publisher = __esm({
           snapshotCache,
           ctx,
           notificationCount,
-          preloadedManifests
+          preloadedManifests,
+          workspaceId
         };
         this.#coalescer.request();
       }
@@ -43945,19 +44399,19 @@ function ensureShared() {
   return shared;
 }
 function registerOverlayScheduler(render, onInvalidate) {
-  const state = ensureShared();
-  state.renderers.add(render);
-  if (onInvalidate) state.invalidators.add(onInvalidate);
+  const state2 = ensureShared();
+  state2.renderers.add(render);
+  if (onInvalidate) state2.invalidators.add(onInvalidate);
   return {
     schedule: () => {
-      state.scheduler.schedule();
+      state2.scheduler.schedule();
     },
     dispose: () => {
-      state.renderers.delete(render);
-      if (onInvalidate) state.invalidators.delete(onInvalidate);
-      if (state.renderers.size === 0) {
-        state.scheduler.dispose();
-        if (shared === state) shared = void 0;
+      state2.renderers.delete(render);
+      if (onInvalidate) state2.invalidators.delete(onInvalidate);
+      if (state2.renderers.size === 0) {
+        state2.scheduler.dispose();
+        if (shared === state2) shared = void 0;
       }
     }
   };
@@ -44611,12 +45065,13 @@ function shouldRecoverTask(task, deadMs) {
   if (!task.heartbeat) return true;
   return task.heartbeat.alive === false || isWorkerHeartbeatStale(task.heartbeat, deadMs);
 }
-function detectInterruptedRuns(cwd, manifestCache2, deadMs = 3e5) {
+function detectInterruptedRuns(cwd, manifestCache2, deadMs = 3e5, currentSessionId) {
   const plans = [];
   for (const manifest of manifestCache2.list(50)) {
     if (manifest.status !== "running" && manifest.status !== "blocked") continue;
     if (isPlanApprovalPending(manifest)) continue;
     if (manifest.async?.pid !== void 0 && checkProcessLiveness(manifest.async.pid).alive) continue;
+    if (currentSessionId && manifest.ownerSessionId && manifest.ownerSessionId === currentSessionId) continue;
     const loaded = loadRunManifestById(cwd, manifest.runId);
     if (!loaded) continue;
     const resumableTasks = loaded.tasks.filter((task) => shouldRecoverTask(task, deadMs)).map((task) => task.id);
@@ -44788,7 +45243,7 @@ function hasRecentLifeEvidence(entry, manifestUpdatedAt, now, staleThresholdMs)
   if (Number.isFinite(hbAge) && hbAge <= staleThresholdMs) return true;
   return false;
 }
-function purgeStaleActiveRunIndex(staleThresholdMs = 3e5, now = Date.now()) {
+function purgeStaleActiveRunIndex(staleThresholdMs = 3e5, now = Date.now(), currentSessionId) {
   const purged = [];
   const kept = [];
   const entries = readActiveRunRegistry();
@@ -44830,6 +45285,10 @@ function purgeStaleActiveRunIndex(staleThresholdMs = 3e5, now = Date.now()) {
       purged.push(entry.runId);
       continue;
     }
+    if (currentSessionId && manifest?.ownerSessionId && manifest.ownerSessionId === currentSessionId) {
+      kept.push(entry.runId);
+      continue;
+    }
     if (manifest?.status === "running" && manifest.async?.pid !== void 0) {
       const pidAlive = checkProcessLiveness(manifest.async.pid).alive;
       if (!pidAlive && !hasRecentLifeEvidence(entry, manifest.updatedAt, now, staleThresholdMs)) {
@@ -44930,9 +45389,13 @@ function purgeStaleActiveRunIndex(staleThresholdMs = 3e5, now = Date.now()) {
   }
   return { purged, kept };
 }
-function reconcileAllStaleRuns(cwd, manifestCache2, now = Date.now()) {
+function reconcileAllStaleRuns(cwd, manifestCache2, now = Date.now(), currentSessionId) {
   const results = [];
-  const runIds = manifestCache2.list(50).filter((m) => m.status === "running" || m.status === "blocked").map((m) => m.runId);
+  const runIds = manifestCache2.list(50).filter((m) => {
+    if (m.status !== "running" && m.status !== "blocked") return false;
+    if (currentSessionId && m.ownerSessionId && m.ownerSessionId === currentSessionId) return false;
+    return true;
+  }).map((m) => m.runId);
   for (const runId of runIds) {
     const cached2 = manifestCache2.get(runId);
     if (!cached2) continue;
@@ -45016,7 +45479,7 @@ function activeWidgetRuns(cwd, manifestCache2, snapshotCache, preloadedManifests
   if (now - lastStaleReconcileAt > STALE_RECONCILE_INTERVAL_MS && manifestCache2) {
     lastStaleReconcileAt = now;
     try {
-      reconcileAllStaleRuns(cwd, manifestCache2);
+      reconcileAllStaleRuns(cwd, manifestCache2, Date.now(), workspaceId);
     } catch {
     }
   }
@@ -45417,9 +45880,9 @@ function uninstallResizeListener() {
     process.stdout.removeListener("resize", onResize);
   }
 }
-function updateCrewWidget(ctx, state, config, manifestCache2, snapshotCache, preloadedManifests) {
+function updateCrewWidget(ctx, state2, config, manifestCache2, snapshotCache, preloadedManifests) {
   if (!ctx.hasUI) return;
-  state.frame += 1;
+  state2.frame += 1;
   const maxLines = config?.widgetMaxLines ?? MAX_LINES_DEFAULT;
   let workspaceId = ctx.sessionManager?.getSessionId?.();
   if (!workspaceId && manifestCache2) {
@@ -45428,73 +45891,75 @@ function updateCrewWidget(ctx, state, config, manifestCache2, snapshotCache, pre
     if (active?.ownerSessionId) workspaceId = active.ownerSessionId;
   }
   const runs = activeWidgetRuns(ctx.cwd, manifestCache2, snapshotCache, preloadedManifests, workspaceId);
-  const lines = buildWidgetLines(ctx.cwd, state.frame, maxLines, runs, state.notificationCount ?? 0, getRenderWidth());
+  const lines = buildWidgetLines(ctx.cwd, state2.frame, maxLines, runs, state2.notificationCount ?? 0, getRenderWidth());
   const placement = config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
   ctx.ui.setStatus(STATUS_KEY, lines.length ? statusSummary(runs) : void 0);
-  const shouldClearLegacy = state.legacyCleared !== true || state.lastPlacement !== placement;
+  const shouldClearLegacy = state2.legacyCleared !== true || state2.lastPlacement !== placement;
   if (shouldClearLegacy) {
     setExtensionWidget(ctx, LEGACY_WIDGET_KEY, void 0, { placement });
-    state.legacyCleared = true;
+    state2.legacyCleared = true;
   }
   if (!lines.length) {
-    if (state.lastVisibility !== "hidden" || state.lastPlacement !== placement) {
+    if (state2.lastVisibility !== "hidden" || state2.lastPlacement !== placement) {
       setExtensionWidget(ctx, WIDGET_KEY, void 0, { placement });
-      state.lastVisibility = "hidden";
-      state.lastPlacement = placement;
-      state.lastKey = WIDGET_KEY;
-      state.lastMaxLines = maxLines;
-      state.lastCwd = ctx.cwd;
-      state.model = void 0;
+      state2.lastVisibility = "hidden";
+      state2.lastPlacement = placement;
+      state2.lastKey = WIDGET_KEY;
+      state2.lastMaxLines = maxLines;
+      state2.lastCwd = ctx.cwd;
+      state2.model = void 0;
     }
     requestRender(ctx);
     return;
   }
-  const needsWidgetInstall = state.lastVisibility !== "visible" || state.lastPlacement !== placement || state.lastKey !== WIDGET_KEY || state.lastMaxLines !== maxLines || state.lastCwd !== ctx.cwd || !state.model;
-  if (!state.model)
-    state.model = {
+  const needsWidgetInstall = state2.lastVisibility !== "visible" || state2.lastPlacement !== placement || state2.lastKey !== WIDGET_KEY || state2.lastMaxLines !== maxLines || state2.lastCwd !== ctx.cwd || !state2.model;
+  if (!state2.model)
+    state2.model = {
       cwd: ctx.cwd,
-      frame: state.frame,
+      frame: state2.frame,
       maxLines,
-      notificationCount: state.notificationCount ?? 0,
+      notificationCount: state2.notificationCount ?? 0,
       manifestCache: manifestCache2,
       snapshotCache,
-      preloadManifests: preloadedManifests
+      preloadManifests: preloadedManifests,
+      workspaceId
     };
   else {
-    state.model.cwd = ctx.cwd;
-    state.model.frame = state.frame;
-    state.model.maxLines = maxLines;
-    state.model.notificationCount = state.notificationCount ?? 0;
-    state.model.manifestCache = manifestCache2;
-    state.model.snapshotCache = snapshotCache;
-    state.model.preloadManifests = preloadedManifests;
+    state2.model.cwd = ctx.cwd;
+    state2.model.frame = state2.frame;
+    state2.model.maxLines = maxLines;
+    state2.model.notificationCount = state2.notificationCount ?? 0;
+    state2.model.manifestCache = manifestCache2;
+    state2.model.snapshotCache = snapshotCache;
+    state2.model.preloadManifests = preloadedManifests;
+    state2.model.workspaceId = workspaceId;
   }
   if (needsWidgetInstall) {
-    const model = state.model;
+    const model = state2.model;
     setExtensionWidget(ctx, WIDGET_KEY, ((_tui, theme) => new CrewWidgetComponent(model, theme, _tui)), {
       placement,
       persist: true
     });
-    state.lastVisibility = "visible";
-    state.lastPlacement = placement;
-    state.lastKey = WIDGET_KEY;
-    state.lastMaxLines = maxLines;
-    state.lastCwd = ctx.cwd;
+    state2.lastVisibility = "visible";
+    state2.lastPlacement = placement;
+    state2.lastKey = WIDGET_KEY;
+    state2.lastMaxLines = maxLines;
+    state2.lastCwd = ctx.cwd;
   }
   requestRender(ctx);
 }
-function stopCrewWidget(ctx, state, config) {
+function stopCrewWidget(ctx, state2, config) {
   uninstallResizeListener();
   if (ctx?.hasUI) {
     const placement = config?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
     ctx.ui.setStatus(STATUS_KEY, void 0);
     setExtensionWidget(ctx, LEGACY_WIDGET_KEY, void 0, { placement });
     setExtensionWidget(ctx, WIDGET_KEY, void 0, { placement });
-    state.lastVisibility = "hidden";
-    state.lastPlacement = placement;
-    state.lastKey = WIDGET_KEY;
-    state.model = void 0;
-    state.legacyCleared = true;
+    state2.lastVisibility = "hidden";
+    state2.lastPlacement = placement;
+    state2.lastKey = WIDGET_KEY;
+    state2.model = void 0;
+    state2.legacyCleared = true;
     requestRender(ctx);
   }
 }
@@ -45603,7 +46068,13 @@ var init_widget = __esm({
         if (activeResizeTarget === this) activeResizeTarget = void 0;
       }
       render(width) {
-        const runs = activeWidgetRuns(this.model.cwd, this.model.manifestCache, this.model.snapshotCache, this.model.preloadManifests);
+        const runs = activeWidgetRuns(
+          this.model.cwd,
+          this.model.manifestCache,
+          this.model.snapshotCache,
+          this.model.preloadManifests,
+          this.model.workspaceId
+        );
         const now = Date.now();
         let sigBase;
         if (this.cachedBuildSignature !== "" && now - this.cachedBuildSignatureAt < SIGNATURE_CACHE_TTL_MS) {
@@ -45708,7 +46179,7 @@ var init_tool_progress_formatter = __esm({
 });
 
 // src/extension/registration/team-tool.ts
-import { statSync as statSync37 } from "node:fs";
+import { statSync as statSync38 } from "node:fs";
 import { Text as Text3 } from "@earendil-works/pi-tui";
 async function handleTeamTool(params, ctx) {
   if (!_cachedHandleTeamTool) {
@@ -45731,7 +46202,7 @@ function resolveCwdOverride(baseCwd, override) {
   if (!override) return { ok: true, cwd: baseCwd };
   try {
     const resolved = resolveRealContainedPath(baseCwd, override);
-    const stat2 = statSync37(resolved);
+    const stat2 = statSync38(resolved);
     if (!stat2.isDirectory())
       return {
         ok: false,
@@ -52641,6 +53112,20 @@ function resolveConfiguredMaxAttempts(cwd) {
 function computeSpawnBudgetMax(attemptModelsCount, configuredMaxAttempts) {
   return attemptModelsCount * (configuredMaxAttempts + 1);
 }
+function resolveTaskModelFallbackPolicy(cwd) {
+  try {
+    return resolveModelFallbackPolicy(loadConfig(cwd).config.runtime?.modelFallback);
+  } catch {
+    return void 0;
+  }
+}
+function resolveTaskDefaultSubagentModel(cwd) {
+  try {
+    return resolveDefaultSubagentModel(loadConfig(cwd).config.runtime?.modelFallback);
+  } catch {
+    return void 0;
+  }
+}
 function detectRetryableModelFailureFromOutput(parsed) {
   const messages = parsed.errorMessages;
   if (messages && messages.length > 0) {
@@ -52686,24 +53171,45 @@ async function runChildProcessTask(ctx) {
   let transcriptPath;
   let terminalEvidence = [];
   let startupEvidence = ctx.startupEvidence;
+  const modelFallbackPolicy = resolveTaskModelFallbackPolicy(task.cwd);
+  const defaultSubagentModel = resolveTaskDefaultSubagentModel(task.cwd);
   const modelRoutingPlan = buildConfiguredModelRouting({
     overrideModel: input.modelOverride,
     stepModel: input.step.model,
     teamRoleModel: input.teamRoleModel,
+    teamRoleFallbackModels: input.teamRoleFallbackModels,
     agentModel: input.agent.model,
+    defaultSubagentModel,
     fallbackModels: input.agent.fallbackModels,
     parentModel: input.parentModel,
     modelRegistry: input.modelRegistry,
     cwd: task.cwd,
+    policy: modelFallbackPolicy,
     scopeModelsPatterns: await resolveTaskScopeModelsPatterns(task.cwd)
   });
   const candidates = modelRoutingPlan.candidates;
-  const attemptModels = candidates.length > 0 ? candidates : [void 0];
+  if (modelRoutingPlan.droppedRequested) {
+    void appendEventAsync(manifest.eventsPath, {
+      type: "task.model_dropped",
+      runId: manifest.runId,
+      taskId: task.id,
+      message: `Requested model "${modelRoutingPlan.droppedRequested}" is not available; using "${candidates[0] ?? "default"}" instead.`,
+      data: {
+        requested: modelRoutingPlan.droppedRequested,
+        resolved: candidates[0],
+        fallbackChain: candidates
+      }
+    }).catch(() => {
+    });
+  }
+  warnOutOfScopeSoft(modelRoutingPlan.scopeVerdict, "child-executor.initial-out-of-scope");
+  const attemptModels = candidates.length > 0 ? [...candidates] : [void 0];
   if (input.spawnBudget && input.spawnBudget.max === 0) {
     input.spawnBudget.max = computeSpawnBudgetMax(attemptModels.length, resolveConfiguredMaxAttempts(task.cwd));
   }
   const logs = [];
   let finalStderr = "";
+  let reResolveUsed = false;
   modelAttempts = [];
   let finalCheckpointWritten = false;
   let lastAgentRecordPersistedAt = 0;
@@ -52824,6 +53330,7 @@ async function runChildProcessTask(ctx) {
         excludeContextBash: input.runtimeConfig?.excludeContextBash,
         sessionId: manifest.sessionId,
         role: task.role,
+        thinkingOverride: input.teamRoleThinking,
         runId: manifest.runId,
         agentId: task.id,
         artifactsRoot: manifest.artifactsRoot,
@@ -52992,7 +53499,8 @@ async function runChildProcessTask(ctx) {
     );
     if (!error) break;
     let nextModel = attemptModels[i + 1];
-    if (!nextModel && isRetryableModelFailure(error)) {
+    if (!nextModel && !reResolveUsed && isRetryableModelFailure(error)) {
+      reResolveUsed = true;
       const reResolved = buildConfiguredModelRouting({
         overrideModel: void 0,
         stepModel: void 0,
@@ -53002,10 +53510,17 @@ async function runChildProcessTask(ctx) {
         parentModel: attempt.model,
         modelRegistry: input.modelRegistry,
         cwd: task.cwd,
+        policy: modelFallbackPolicy,
         scopeModelsPatterns: await resolveTaskScopeModelsPatterns(task.cwd)
       });
-      const alt = reResolved.candidates.find((c) => c !== attempt.model);
-      if (alt) nextModel = alt;
+      warnOutOfScopeSoft(reResolved.scopeVerdict, "child-executor.re-resolve-out-of-scope", "Re-resolved model");
+      const tried = new Set(modelAttempts.map((a) => a.model));
+      const alt = reResolved.candidates.find((candidate) => !tried.has(candidate));
+      if (alt) {
+        attemptModels.push(alt);
+        nextModel = alt;
+        if (input.spawnBudget) input.spawnBudget.max += 1;
+      }
     }
     if (!nextModel || !isRetryableModelFailure(error)) break;
     logs.push(formatModelAttemptNote(attempt, nextModel), "");
@@ -53074,7 +53589,9 @@ async function runChildProcessTask(ctx) {
       resolved: resolvedModel,
       fallbackChain: candidates,
       reason: fallbackReason ?? modelRoutingPlan.reason,
-      usedAttempt
+      usedAttempt,
+      droppedRequested: modelRoutingPlan.droppedRequested,
+      autoFallbackCount: modelRoutingPlan.autoFallbackCount
     }
   };
   tasks = updateTask(tasks, task);
@@ -54985,6 +55502,8 @@ async function runLiveTask(input) {
     modelRegistry: input.modelRegistry,
     modelOverride: input.modelOverride,
     teamRoleModel: input.teamRoleModel,
+    teamRoleFallbackModels: input.teamRoleFallbackModels,
+    teamRoleThinking: input.teamRoleThinking,
     isCurrent,
     workspaceId: input.workspaceId,
     // Phase 2: Pass output schema for yield validation
@@ -55028,6 +55547,14 @@ async function runLiveTask(input) {
       usage: liveResult.usage,
       agentProgress: applyUsageToProgress(task.agentProgress, liveResult.usage)
     };
+  if (liveResult.modelRouting)
+    task = {
+      ...task,
+      modelRouting: {
+        ...liveResult.modelRouting,
+        usedAttempt: 0
+      }
+    };
   persistLiveProgress({ type: "attempt_finished" }, true);
   const resultArtifact = writeArtifact(manifest.artifactsRoot, {
     kind: "result",
@@ -55154,6 +55681,8 @@ async function runTeamTask(input) {
         modelRegistry: input.modelRegistry,
         modelOverride: input.modelOverride,
         teamRoleModel: input.teamRoleModel,
+        teamRoleFallbackModels: input.teamRoleFallbackModels,
+        teamRoleThinking: input.teamRoleThinking,
         workspaceId: input.workspaceId
       });
       task = live.task;
@@ -56682,10 +57211,7 @@ async function cancelRunFromSignal(ctx) {
   return { kind: "return", result: { manifest: ctx.manifest, tasks: ctx.tasks } };
 }
 async function terminaliseRunWithDrain(ctx, opts) {
-  const inflightTaskIds = /* @__PURE__ */ new Set();
-  for (const unit of ctx.pendingUnits.values()) {
-    for (const id of unit.taskIds) inflightTaskIds.add(id);
-  }
+  const inflightTaskIds = ctx.dispatchedTaskIds;
   const outcomes = await drainPendingUnits(ctx.pendingUnits, ctx.runController);
   const validResults = [];
   for (const outcome of outcomes) {
@@ -57006,6 +57532,8 @@ async function dispatchBatch(ctx, decision2) {
       modelRegistry: input.modelRegistry,
       modelOverride: input.modelOverride,
       teamRoleModel: teamRole?.model,
+      teamRoleThinking: teamRole?.thinking,
+      teamRoleFallbackModels: teamRole?.fallbackModels,
       teamRoleSkills: teamRole?.skills,
       skillOverride: input.skillOverride,
       limits: input.limits,
@@ -57191,6 +57719,7 @@ async function dispatchBatch(ctx, decision2) {
       promise: rawPromise,
       wrapped
     });
+    for (const id of unitTaskIds) ctx.dispatchedTaskIds.add(id);
   }
 }
 async function mergeUnitResult(ctx) {
@@ -57551,6 +58080,7 @@ async function executeTeamRunCore(input, manifest, workflow) {
     queueIndex,
     wfMachine,
     pendingUnits,
+    dispatchedTaskIds: /* @__PURE__ */ new Set(),
     runController,
     runtimeKind,
     adaptivePlanInjected,
@@ -59677,14 +60207,14 @@ var init_dwf_state_store = __esm({
         }
       }
       /** Atomically persist a checkpoint state. Stamps `updatedAt` (callers need not set it). */
-      save(state) {
+      save(state2) {
         const path89 = this.path;
-        const next = { ...state, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        const next = { ...state2, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
         try {
           mkdirSync39(dirname37(path89), { recursive: true });
           atomicWriteJson(path89, next);
         } catch (error) {
-          logInternalError("dwf-state-store.save", error, `runId=${state.runId}`);
+          logInternalError("dwf-state-store.save", error, `runId=${state2.runId}`);
           throw error;
         }
       }
@@ -60583,9 +61113,9 @@ async function runDynamicWorkflow(input) {
     resumedState,
     // round-18 P2-3: checkpoint after each ctx.agent() call so a crash between calls
     // leaves durable state. onCheckpoint captures the closure values at call time.
-    onCheckpoint: (state) => {
+    onCheckpoint: (state2) => {
       try {
-        dwfStore.save(state);
+        dwfStore.save(state2);
       } catch (error) {
         logInternalError("dynamic-workflow-runner.checkpoint-save", error, `runId=${manifest.runId}`);
       }
@@ -61183,6 +61713,10 @@ ${dwfResult.manifest.summary ?? ""}`,
     ...updatedManifest,
     runtimeResolution,
     runConfig: executedConfig,
+    // Background/async runs re-enter through background-runner in a detached
+    // process with no ExtensionContext. Snapshot the model routing inputs so
+    // they survive the hand-off instead of being rediscovered from models.json.
+    modelContext: captureRunModelContext(ctx, params.model),
     // Persist budget config on the manifest so it's observable post-run
     // (events.jsonl, status reads, audits). The team-runner reads these
     // from the input, but persisting them means consumers can verify
@@ -61393,7 +61927,7 @@ ${dwfResult.manifest.summary ?? ""}`,
           runtime,
           runtimeConfig: executedConfig.runtime,
           parentContext: buildParentContext(ctx),
-          parentModel: ctx.model,
+          parentModel: resolveParentModel(ctx.model),
           modelRegistry: ctx.modelRegistry,
           modelOverride: params.model,
           skillOverride,
@@ -61459,7 +61993,7 @@ ${dwfResult.manifest.summary ?? ""}`,
       runtime,
       runtimeConfig: executedConfig.runtime,
       parentContext: buildParentContext(ctx),
-      parentModel: ctx.model,
+      parentModel: resolveParentModel(ctx.model),
       modelRegistry: ctx.modelRegistry,
       modelOverride: params.model,
       skillOverride,
@@ -61508,6 +62042,7 @@ var init_run2 = __esm({
     init_param_error();
     init_async_runner();
     init_runtime_resolver();
+    init_session_model();
     init_event_log();
     init_i18n();
     init_async_marker();
@@ -61916,7 +62451,7 @@ async function handleResume2(params, ctx) {
     runtime: decision2.runtime,
     runtimeConfig: decision2.executedConfig.runtime,
     parentContext: buildParentContext(ctx),
-    parentModel: ctx.model,
+    parentModel: resolveParentModel(ctx.model),
     modelRegistry: ctx.modelRegistry,
     modelOverride: params.model,
     skillOverride: decision2.resumeSkillOverride,
@@ -62163,6 +62698,7 @@ var init_team_tool2 = __esm({
     init_run_index();
     init_direct_run();
     init_runtime_resolver();
+    init_session_model();
     init_pi_json_output();
     init_config_patch();
     init_context();
@@ -63194,16 +63730,16 @@ function readRunTranscript(manifest, taskId, options = {}) {
   readRunTranscriptCache.set(cacheKey2, { parsedAt: now, result: result4 });
   return result4;
 }
-function renderViewerBase(state, width, lines, title, subtitle) {
+function renderViewerBase(state2, width, lines, title, subtitle) {
   const inner = Math.max(20, width - 4);
   const bodyText = lines.join("\n");
-  const { visualLines, skippedCount } = truncateToVisualLines(bodyText, state.lastHeight, inner);
-  const maxScroll = Math.max(0, visualLines.length - state.lastHeight);
-  if (state.autoScroll) state.scroll = maxScroll;
-  state.scroll = Math.min(state.scroll, maxScroll);
-  const visible = visualLines.slice(state.scroll, state.scroll + state.lastHeight);
-  const statusLine = `${visualLines.length} lines \xB7 ${visualLines.length ? Math.round((state.scroll + visible.length) / visualLines.length * 100) : 100}% \xB7 auto-scroll ${state.autoScroll ? "on" : "off"}`;
-  const fg = (color, text) => state.theme.fg(color, text);
+  const { visualLines, skippedCount } = truncateToVisualLines(bodyText, state2.lastHeight, inner);
+  const maxScroll = Math.max(0, visualLines.length - state2.lastHeight);
+  if (state2.autoScroll) state2.scroll = maxScroll;
+  state2.scroll = Math.min(state2.scroll, maxScroll);
+  const visible = visualLines.slice(state2.scroll, state2.scroll + state2.lastHeight);
+  const statusLine = `${visualLines.length} lines \xB7 ${visualLines.length ? Math.round((state2.scroll + visible.length) / visualLines.length * 100) : 100}% \xB7 auto-scroll ${state2.autoScroll ? "on" : "off"}`;
+  const fg = (color, text) => state2.theme.fg(color, text);
   const row = (text) => `${fg("border", "\u2502")} ${pad(truncate(text, inner), inner)} ${fg("border", "\u2502")}`;
   const linesOut = [
     fg("border", `\u256D${"\u2500".repeat(inner + 2)}\u256E`),
@@ -63772,11 +64308,11 @@ function extractDwfPhaseState(events) {
   });
   return { phases, currentPhase };
 }
-function renderDwfPhaseLines(state, options) {
+function renderDwfPhaseLines(state2, options) {
   const ascii = options?.ascii === true;
   const lines = [];
-  if (state.phases.length > 1) lines.push(DWF_PHASE_HEADER);
-  for (const entry of state.phases) {
+  if (state2.phases.length > 1) lines.push(DWF_PHASE_HEADER);
+  for (const entry of state2.phases) {
     lines.push(`  ${markerFor(entry.status, ascii)} Phase: ${entry.name}`);
   }
   return lines;
@@ -64582,7 +65118,8 @@ var init_run_dashboard = __esm({
         if (!this.options.runProvider) return;
         const selectedRunId = this.selectedRunId();
         const next = this.options.runProvider();
-        this.runs = Array.isArray(next) ? next : this.runs;
+        const unfiltered = Array.isArray(next) ? next : this.runs;
+        this.runs = this.options.workspaceId ? unfiltered.filter((run) => !run.ownerSessionId || run.ownerSessionId === this.options.workspaceId) : unfiltered;
         if (selectedRunId) {
           const nextIndex = groupedRuns(this.runs, this.options.snapshotCache).filter((row) => row.run).findIndex((row) => row.run?.runId === selectedRunId);
           if (nextIndex >= 0) this.selected = nextIndex;
@@ -65703,24 +66240,24 @@ var init_mascot = __esm({
         }
       }
       tickTypewriter() {
-        const state = this.effectState;
-        if (state.pos === void 0) return true;
+        const state2 = this.effectState;
+        if (state2.pos === void 0) return true;
         for (let i = 0; i < 18; i++) {
-          const row = Math.floor(state.pos / ARMIN_WIDTH);
-          const x = state.pos % ARMIN_WIDTH;
+          const row = Math.floor(state2.pos / ARMIN_WIDTH);
+          const x = state2.pos % ARMIN_WIDTH;
           if (row >= ARMIN_DISPLAY_HEIGHT) return true;
           this.currentArminGrid[row][x] = this.finalArminGrid[row][x];
-          state.pos++;
+          state2.pos++;
         }
         return false;
       }
       tickScanline() {
-        const state = this.effectState;
-        if (state.row === void 0) return true;
+        const state2 = this.effectState;
+        if (state2.row === void 0) return true;
         for (let step = 0; step < 3; step++) {
-          if (state.row >= ARMIN_DISPLAY_HEIGHT) return true;
-          for (let x = 0; x < ARMIN_WIDTH; x++) this.currentArminGrid[state.row][x] = this.finalArminGrid[state.row][x];
-          state.row++;
+          if (state2.row >= ARMIN_DISPLAY_HEIGHT) return true;
+          for (let x = 0; x < ARMIN_WIDTH; x++) this.currentArminGrid[state2.row][x] = this.finalArminGrid[state2.row][x];
+          state2.row++;
         }
         return false;
       }
@@ -65756,33 +66293,33 @@ var init_mascot = __esm({
         return allSettled;
       }
       tickFade() {
-        const state = this.effectState;
-        if (!state.positions || state.idx === void 0) return true;
+        const state2 = this.effectState;
+        if (!state2.positions || state2.idx === void 0) return true;
         for (let i = 0; i < 54; i++) {
-          if (state.idx >= state.positions.length) return true;
-          const [row, x] = state.positions[state.idx];
+          if (state2.idx >= state2.positions.length) return true;
+          const [row, x] = state2.positions[state2.idx];
           this.currentArminGrid[row][x] = this.finalArminGrid[row][x];
-          state.idx++;
+          state2.idx++;
         }
         return false;
       }
       tickCrt() {
-        const state = this.effectState;
-        if (state.expansion === void 0) return true;
+        const state2 = this.effectState;
+        if (state2.expansion === void 0) return true;
         const midRow = Math.floor(ARMIN_DISPLAY_HEIGHT / 2);
         this.currentArminGrid = emptyArminGrid();
-        const top = midRow - state.expansion;
-        const bottom = midRow + state.expansion;
+        const top = midRow - state2.expansion;
+        const bottom = midRow + state2.expansion;
         for (let row = Math.max(0, top); row <= Math.min(ARMIN_DISPLAY_HEIGHT - 1, bottom); row++) {
           for (let x = 0; x < ARMIN_WIDTH; x++) this.currentArminGrid[row][x] = this.finalArminGrid[row][x];
         }
-        state.expansion += 3;
-        return state.expansion > ARMIN_DISPLAY_HEIGHT;
+        state2.expansion += 3;
+        return state2.expansion > ARMIN_DISPLAY_HEIGHT;
       }
       tickGlitch() {
-        const state = this.effectState;
-        if (state.phase === void 0 || state.glitchFrames === void 0) return true;
-        if (state.phase < state.glitchFrames) {
+        const state2 = this.effectState;
+        if (state2.phase === void 0 || state2.glitchFrames === void 0) return true;
+        if (state2.phase < state2.glitchFrames) {
           const offset = Math.floor(Math.random() * 7) - 3;
           const swapRow = Math.floor(Math.random() * ARMIN_DISPLAY_HEIGHT);
           const doShift = Math.random() < 0.3;
@@ -65797,7 +66334,7 @@ var init_mascot = __esm({
               }
             }
           }
-          state.phase += 3;
+          state2.phase += 3;
           return false;
         }
         for (let row = 0; row < ARMIN_DISPLAY_HEIGHT; row++) {
@@ -65808,13 +66345,13 @@ var init_mascot = __esm({
         return true;
       }
       tickDissolve() {
-        const state = this.effectState;
-        if (!state.positions || state.idx === void 0) return true;
+        const state2 = this.effectState;
+        if (!state2.positions || state2.idx === void 0) return true;
         for (let i = 0; i < 66; i++) {
-          if (state.idx >= state.positions.length) return true;
-          const [row, x] = state.positions[state.idx];
+          if (state2.idx >= state2.positions.length) return true;
+          const [row, x] = state2.positions[state2.idx];
           this.currentArminGrid[row][x] = this.finalArminGrid[row][x];
-          state.idx++;
+          state2.idx++;
         }
         return false;
       }
@@ -67808,6 +68345,7 @@ var init_commands = __esm({
 });
 
 // src/runtime/subagent-manager.ts
+import { randomUUID as randomUUID8 } from "node:crypto";
 import * as fs100 from "node:fs";
 import * as path81 from "node:path";
 function isValidSubagentId(id) {
@@ -67926,6 +68464,7 @@ var init_subagent_manager = __esm({
       "resultConsumed",
       "background",
       "ownerSessionGeneration",
+      "ownerSessionId",
       "stuckNotified",
       "blockedAt",
       "turnCount",
@@ -67952,7 +68491,7 @@ var init_subagent_manager = __esm({
       }
       spawn(options, runner, signal) {
         const record = {
-          id: `agent_${Date.now().toString(36)}_${(++this.counter).toString(36)}`,
+          id: `agent_${Date.now().toString(36)}_${randomUUID8().slice(0, 8)}_${(++this.counter).toString(36)}`,
           type: options.type,
           description: options.description,
           prompt: options.prompt,
@@ -67962,6 +68501,7 @@ var init_subagent_manager = __esm({
           skill: options.skill,
           background: options.background,
           ownerSessionGeneration: options.ownerSessionGeneration,
+          ownerSessionId: options.ownerSessionId,
           batchId: options.batchId
         };
         this.records.set(record.id, record);
@@ -68214,7 +68754,8 @@ var init_subagent_manager = __esm({
             id: current.id,
             runId: current.runId,
             durationMs: Math.max(0, Date.now() - current.blockedAt),
-            ownerSessionGeneration: current.ownerSessionGeneration
+            ownerSessionGeneration: current.ownerSessionGeneration,
+            ownerSessionId: current.ownerSessionId
           });
           savePersistedSubagentRecord(cwd, current);
         };
@@ -68599,16 +69140,16 @@ async function importLiveRunSidebar() {
   }
   return _cachedLiveRunSidebar;
 }
-async function installLiveSidebar(ctx, runId, state, deps) {
+async function installLiveSidebar(ctx, runId, state2, deps) {
   const uiConfig = loadConfig(ctx.cwd).config.ui;
   const autoOpen = uiConfig?.autoOpenDashboard === true;
   const foregroundAutoOpen = uiConfig?.autoOpenDashboardForForegroundRuns ?? DEFAULT_UI.autoOpenDashboardForForegroundRuns;
   if (!ctx.hasUI || !autoOpen || !foregroundAutoOpen || (uiConfig?.dashboardPlacement ?? DEFAULT_UI.dashboardPlacement) !== "right") {
     return false;
   }
-  if (state.liveSidebarRunId === runId) return true;
-  state.liveSidebarRunId = runId;
-  state.dashboardOpened = true;
+  if (state2.liveSidebarRunId === runId) return true;
+  state2.liveSidebarRunId = runId;
+  state2.dashboardOpened = true;
   const widgetPlacement = uiConfig?.widgetPlacement ?? DEFAULT_UI.widgetPlacement;
   setExtensionWidget(ctx, "pi-crew", void 0, { placement: widgetPlacement });
   setExtensionWidget(ctx, "pi-crew-active", void 0, { placement: widgetPlacement });
@@ -68644,7 +69185,7 @@ async function installLiveSidebar(ctx, runId, state, deps) {
         }
       }
     ).finally(() => {
-      if (state.liveSidebarRunId === runId) state.liveSidebarRunId = void 0;
+      if (state2.liveSidebarRunId === runId) state2.liveSidebarRunId = void 0;
       const c = deps.getCurrentCtx();
       if (!c) return;
       updateCrewWidget(
@@ -68661,12 +69202,12 @@ async function installLiveSidebar(ctx, runId, state, deps) {
     return false;
   }
 }
-function clearDashboardPowerbar(state, deps) {
+function clearDashboardPowerbar(state2, deps) {
   const c = deps.getCurrentCtx();
   if (c) stopCrewWidget(c, deps.widgetState, loadConfig(c.cwd).config.ui);
   clearPiCrewPowerbar(deps.pi.events);
   resetPowerbarDedupState();
-  state.dashboardOpened = false;
+  state2.dashboardOpened = false;
 }
 function registerPowerbarSegments(deps, uiConfig) {
   registerPiCrewPowerbarSegments(deps.pi.events, uiConfig);
@@ -68872,29 +69413,31 @@ function markDeadAsyncRunIfNeeded(run, now = Date.now(), quietMs = 3e4) {
     return failed;
   });
 }
-function startAsyncRunNotifier(ctx, state, intervalMs = 5e3, options = {}) {
-  if (state.interval) clearInterval(state.interval);
-  const generation = options.generation ?? (state.generation ?? 0) + 1;
-  state.generation = generation;
+function startAsyncRunNotifier(ctx, state2, intervalMs = 5e3, options = {}) {
+  if (state2.interval) clearInterval(state2.interval);
+  const generation = options.generation ?? (state2.generation ?? 0) + 1;
+  state2.generation = generation;
   const startedAtMs = Date.now();
-  const staleBeforeMs = state.lastStoppedAtMs ?? startedAtMs;
-  for (const run of listRuns(ctx.cwd)) {
+  const staleBeforeMs = state2.lastStoppedAtMs ?? startedAtMs;
+  const sid = extractSessionId(ctx);
+  const ownsRun = (run) => !sid || !run.ownerSessionId || run.ownerSessionId === sid;
+  for (const run of listRuns(ctx.cwd).filter(ownsRun)) {
     const updatedAtMs = timeMs(run.updatedAt) ?? 0;
-    if (isFinished2(run.status) && updatedAtMs < staleBeforeMs) state.seenFinishedRunIds.add(run.runId);
+    if (isFinished2(run.status) && updatedAtMs < staleBeforeMs) state2.seenFinishedRunIds.add(run.runId);
   }
   let cachedRuns;
-  state.interval = setInterval(() => {
+  state2.interval = setInterval(() => {
     try {
       if (options.isCurrent && !options.isCurrent(generation)) return;
       const nowMs3 = Date.now();
-      if (cachedRuns === void 0 || nowMs3 - (state.lastListRunsMs ?? 0) > LIST_RUNS_DEBOUNCE_MS) {
-        cachedRuns = listRuns(ctx.cwd).slice(0, 20);
-        state.lastListRunsMs = nowMs3;
+      if (cachedRuns === void 0 || nowMs3 - (state2.lastListRunsMs ?? 0) > LIST_RUNS_DEBOUNCE_MS) {
+        cachedRuns = listRuns(ctx.cwd).filter(ownsRun).slice(0, 20);
+        state2.lastListRunsMs = nowMs3;
       }
       for (const run of cachedRuns) {
         const current = markDeadAsyncRunIfNeeded(run) ?? run;
-        if (!isFinished2(current.status) || state.seenFinishedRunIds.has(current.runId)) continue;
-        state.seenFinishedRunIds.add(current.runId);
+        if (!isFinished2(current.status) || state2.seenFinishedRunIds.has(current.runId)) continue;
+        state2.seenFinishedRunIds.add(current.runId);
         if (current.workflow === "goal-turn" && current.team.startsWith("goal-")) continue;
         const level = current.status === "completed" ? "info" : current.status === "cancelled" ? "warning" : "error";
         ctx.ui.notify(`pi-crew run ${current.status}: ${current.runId} (${current.team}/${current.workflow ?? "none"})`, level);
@@ -68907,13 +69450,13 @@ function startAsyncRunNotifier(ctx, state, intervalMs = 5e3, options = {}) {
       logInternalError("async-notifier", error, `interval=${intervalMs}`);
     }
   }, intervalMs);
-  if (typeof state.interval.unref === "function") state.interval.unref();
+  if (typeof state2.interval.unref === "function") state2.interval.unref();
 }
-function stopAsyncRunNotifier(state) {
-  if (state.interval) clearInterval(state.interval);
-  state.interval = void 0;
-  state.generation = (state.generation ?? 0) + 1;
-  state.lastStoppedAtMs = Date.now();
+function stopAsyncRunNotifier(state2) {
+  if (state2.interval) clearInterval(state2.interval);
+  state2.interval = void 0;
+  state2.generation = (state2.generation ?? 0) + 1;
+  state2.lastStoppedAtMs = Date.now();
 }
 var LIST_RUNS_DEBOUNCE_MS;
 var init_async_notifier = __esm({
@@ -68925,6 +69468,7 @@ var init_async_notifier = __esm({
     init_event_log();
     init_state_store();
     init_internal_error();
+    init_session_utils();
     init_run_index();
     LIST_RUNS_DEBOUNCE_MS = 3e4;
   }
@@ -69137,11 +69681,15 @@ var init_delivery_coordinator = __esm({
       deps;
       ttlTimer;
       timerStarted = false;
+      /** The session id passed to the most recent activate(); used by flushQueuedResults
+       * to park deliveries owned by a different session (vector #12). */
+      activeSessionId;
       constructor(deps) {
         this.deps = deps;
       }
       activate(sessionId) {
         this.active = true;
+        this.activeSessionId = sessionId;
         this.flushQueuedResults();
       }
       deactivate() {
@@ -69154,7 +69702,7 @@ var init_delivery_coordinator = __esm({
       getPendingCount() {
         return this.pending.length;
       }
-      deliverResult(runId, result4) {
+      deliverResult(runId, result4, ownerSessionId) {
         if (this.active && this.deps.emit) {
           try {
             this.deps.emit("pi-crew:run-result", result4);
@@ -69168,10 +69716,11 @@ var init_delivery_coordinator = __esm({
             runId,
             payload: result4,
             timestamp: Date.now(),
-            type: "result"
+            type: "result",
+            ownerSessionId
           });
       }
-      deliverNotification(notification) {
+      deliverNotification(notification, ownerSessionId) {
         let delivered = false;
         if (this.active && this.deps.sendFollowUp) {
           try {
@@ -69195,10 +69744,11 @@ var init_delivery_coordinator = __esm({
             runId: notification.runId ?? "",
             payload: notification,
             timestamp: Date.now(),
-            type: "notification"
+            type: "notification",
+            ownerSessionId
           });
       }
-      deliverSteer(runId, message) {
+      deliverSteer(runId, message, ownerSessionId) {
         if (this.active && this.deps.sendWakeUp) {
           try {
             this.deps.sendWakeUp(message);
@@ -69212,7 +69762,8 @@ var init_delivery_coordinator = __esm({
             runId,
             payload: message,
             timestamp: Date.now(),
-            type: "steer"
+            type: "steer",
+            ownerSessionId
           });
       }
       flushQueuedResults() {
@@ -69223,6 +69774,10 @@ var init_delivery_coordinator = __esm({
         try {
           const retryLater = [];
           for (const delivery of batch) {
+            if (delivery.ownerSessionId && this.activeSessionId && delivery.ownerSessionId !== this.activeSessionId) {
+              retryLater.push(delivery);
+              continue;
+            }
             if (delivery.type === "steer" && delivery.generation !== void 0 && delivery.generation !== this.generation) {
               logInternalError("delivery-coordinator.flush.stale", void 0, `runId=${delivery.runId} type=${delivery.type}`);
               continue;
@@ -69357,7 +69912,7 @@ var init_overflow_recovery = __esm({
           default:
             break;
         }
-        const state = {
+        const state2 = {
           taskId,
           runId,
           phase,
@@ -69366,14 +69921,14 @@ var init_overflow_recovery = __esm({
           compactionCount,
           retryCount
         };
-        this.states.set(key, state);
+        this.states.set(key, state2);
         this.resetTimeout(key);
         if (this.states.size > MAX_TRACKED_STATES) {
           this.evictOldestTerminalState();
         }
         if (previousPhase !== phase && this.callbacks.onPhaseChange) {
           try {
-            this.callbacks.onPhaseChange(state, previousPhase);
+            this.callbacks.onPhaseChange(state2, previousPhase);
           } catch (error) {
             logInternalError("overflow-recovery.onPhaseChange", error, `taskId=${taskId}`);
           }
@@ -69382,13 +69937,13 @@ var init_overflow_recovery = __esm({
       }
       getState(taskId, runId) {
         if (runId) return this.states.get(this.keyFor(taskId, runId));
-        return [...this.states.values()].find((state) => state.taskId === taskId);
+        return [...this.states.values()].find((state2) => state2.taskId === taskId);
       }
       getPhase(taskId, runId) {
         return this.getState(taskId, runId)?.phase ?? "none";
       }
       removeTask(taskId, runId) {
-        const keys = runId ? [this.keyFor(taskId, runId)] : [...this.states.entries()].filter(([, state]) => state.taskId === taskId).map(([key]) => key);
+        const keys = runId ? [this.keyFor(taskId, runId)] : [...this.states.entries()].filter(([, state2]) => state2.taskId === taskId).map(([key]) => key);
         for (const key of keys) this.removeKey(key);
       }
       /**
@@ -69400,10 +69955,10 @@ var init_overflow_recovery = __esm({
       evictOldestTerminalState() {
         let oldestKey;
         let oldestTimestamp = Infinity;
-        for (const [key, state] of this.states) {
-          const isTerminal = state.phase === "recovered" || state.phase === "failed" || state.phase === "none";
-          if (isTerminal && state.lastEventAt < oldestTimestamp) {
-            oldestTimestamp = state.lastEventAt;
+        for (const [key, state2] of this.states) {
+          const isTerminal = state2.phase === "recovered" || state2.phase === "failed" || state2.phase === "none";
+          if (isTerminal && state2.lastEventAt < oldestTimestamp) {
+            oldestTimestamp = state2.lastEventAt;
             oldestKey = key;
           }
         }
@@ -69432,27 +69987,27 @@ var init_overflow_recovery = __esm({
         const timeoutMs = current?.phase === "recovered" || current?.phase === "failed" || current?.phase === "none" ? TERMINAL_STATE_TTL_MS : PHASE_TIMEOUT_MS;
         const timer = setTimeout(() => {
           this.timers.delete(key);
-          const state = this.states.get(key);
-          if (!state) return;
-          if (state.phase === "recovered" || state.phase === "failed" || state.phase === "none") {
+          const state2 = this.states.get(key);
+          if (!state2) return;
+          if (state2.phase === "recovered" || state2.phase === "failed" || state2.phase === "none") {
             this.states.delete(key);
             return;
           }
-          const previousPhase = state.phase;
-          state.phase = "failed";
-          state.lastEventAt = Date.now();
+          const previousPhase = state2.phase;
+          state2.phase = "failed";
+          state2.lastEventAt = Date.now();
           if (this.callbacks.onTimeout) {
             try {
-              this.callbacks.onTimeout(state);
+              this.callbacks.onTimeout(state2);
             } catch (error) {
-              logInternalError("overflow-recovery.onTimeout", error, `taskId=${state.taskId}`);
+              logInternalError("overflow-recovery.onTimeout", error, `taskId=${state2.taskId}`);
             }
           }
           if (this.callbacks.onPhaseChange) {
             try {
-              this.callbacks.onPhaseChange(state, previousPhase);
+              this.callbacks.onPhaseChange(state2, previousPhase);
             } catch (error) {
-              logInternalError("overflow-recovery.onPhaseChange-timeout", error, `taskId=${state.taskId}`);
+              logInternalError("overflow-recovery.onPhaseChange-timeout", error, `taskId=${state2.taskId}`);
             }
           }
         }, timeoutMs);
@@ -69473,10 +70028,10 @@ __export(lifecycle_exports, {
   startLifecycleWatchers: () => startLifecycleWatchers,
   stopLifecycleWatchers: () => stopLifecycleWatchers
 });
-function startLifecycleWatchers(ctx, state, deps) {
-  if (state.notifierStarted) return false;
+function startLifecycleWatchers(ctx, state2, deps) {
+  if (state2.notifierStarted) return false;
   const loadedConfig = loadConfig(ctx.cwd);
-  state.notifierStarted = true;
+  state2.notifierStarted = true;
   try {
     void Promise.resolve().then(() => (init_async_notifier(), async_notifier_exports)).then(({ startAsyncRunNotifier: startAsyncRunNotifier2 }) => {
       if (deps.isCleanedUp()) return;
@@ -69487,14 +70042,14 @@ function startLifecycleWatchers(ctx, state, deps) {
     });
     return true;
   } catch (error) {
-    state.notifierStarted = false;
+    state2.notifierStarted = false;
     logInternalError("register.startLifecycleWatchers", error);
     return false;
   }
 }
-function stopLifecycleWatchers(state, deps) {
-  if (!state.notifierStarted) return;
-  state.notifierStarted = false;
+function stopLifecycleWatchers(state2, deps) {
+  if (!state2.notifierStarted) return;
+  state2.notifierStarted = false;
   try {
     void Promise.resolve().then(() => (init_async_notifier(), async_notifier_exports)).then(({ stopAsyncRunNotifier: stopAsyncRunNotifier2 }) => {
       stopAsyncRunNotifier2(deps.notifierState);
@@ -69503,11 +70058,11 @@ function stopLifecycleWatchers(state, deps) {
     logInternalError("register.stopLifecycleWatchers", error);
   }
 }
-async function configureNotifications(ctx, state, deps) {
-  state.notificationRouter?.dispose();
-  state.notificationSink?.dispose();
-  state.notificationRouter = void 0;
-  state.notificationSink = void 0;
+async function configureNotifications(ctx, state2, deps) {
+  state2.notificationRouter?.dispose();
+  state2.notificationSink?.dispose();
+  state2.notificationRouter = void 0;
+  state2.notificationSink = void 0;
   const config = loadConfig(ctx.cwd).config;
   if (config.notifications?.enabled === false) return;
   const { NotificationRouter: NotificationRouter2 } = await Promise.resolve().then(() => (init_notification_router(), notification_router_exports));
@@ -69515,18 +70070,18 @@ async function configureNotifications(ctx, state, deps) {
   const { sendFollowUp: sendFollowUp2 } = await Promise.resolve().then(() => (init_subagent_helpers(), subagent_helpers_exports));
   const { updateCrewWidget: updateCrewWidget2 } = await Promise.resolve().then(() => (init_widget(), widget_exports));
   if (config.telemetry?.enabled !== false) {
-    state.notificationSink = createJsonlSink2(
+    state2.notificationSink = createJsonlSink2(
       projectCrewRoot(ctx.cwd),
       config.notifications?.sinkRetentionDays ?? DEFAULT_NOTIFICATIONS.sinkRetentionDays
     );
   }
-  state.notificationRouter = new NotificationRouter2(
+  state2.notificationRouter = new NotificationRouter2(
     {
       dedupWindowMs: config.notifications?.dedupWindowMs ?? DEFAULT_NOTIFICATIONS.dedupWindowMs,
       batchWindowMs: config.notifications?.batchWindowMs ?? DEFAULT_NOTIFICATIONS.batchWindowMs,
       quietHours: config.notifications?.quietHours,
       severityFilter: config.notifications?.severityFilter ?? [...DEFAULT_NOTIFICATIONS.severityFilter],
-      sink: (notification) => state.notificationSink?.write(notification)
+      sink: (notification) => state2.notificationSink?.write(notification)
     },
     (notification) => {
       deps.widgetState.notificationCount = (deps.widgetState.notificationCount ?? 0) + 1;
@@ -69557,20 +70112,20 @@ async function configureNotifications(ctx, state, deps) {
     }
   );
 }
-function disposeNotifications(state) {
-  state.notificationRouter?.dispose();
-  state.notificationRouter = void 0;
-  state.notificationSink?.dispose();
-  state.notificationSink = void 0;
-}
-async function configureDeliveryCoordinator(state, deps) {
-  state.deliveryCoordinator?.dispose();
-  state.deliveryCoordinator = void 0;
-  state.overflowTracker?.dispose();
-  state.overflowTracker = void 0;
+function disposeNotifications(state2) {
+  state2.notificationRouter?.dispose();
+  state2.notificationRouter = void 0;
+  state2.notificationSink?.dispose();
+  state2.notificationSink = void 0;
+}
+async function configureDeliveryCoordinator(state2, deps) {
+  state2.deliveryCoordinator?.dispose();
+  state2.deliveryCoordinator = void 0;
+  state2.overflowTracker?.dispose();
+  state2.overflowTracker = void 0;
   const { DeliveryCoordinator: DeliveryCoordinator2 } = await Promise.resolve().then(() => (init_delivery_coordinator(), delivery_coordinator_exports));
   const { OverflowRecoveryTracker: OverflowRecoveryTracker2 } = await Promise.resolve().then(() => (init_overflow_recovery(), overflow_recovery_exports));
-  state.deliveryCoordinator = new DeliveryCoordinator2({
+  state2.deliveryCoordinator = new DeliveryCoordinator2({
     emit: (event, data) => {
       deps.pi.events?.emit?.(event, data);
     },
@@ -69581,7 +70136,7 @@ async function configureDeliveryCoordinator(state, deps) {
       deps.sendAgentWakeUp(deps.pi, message);
     }
   });
-  state.overflowTracker = new OverflowRecoveryTracker2({
+  state2.overflowTracker = new OverflowRecoveryTracker2({
     onPhaseChange: (phaseState, previousPhase) => {
       if (deps.observabilityState.metricRegistry) {
         deps.observabilityState.metricRegistry.counter("crew.task.overflow_recovery_total", "Overflow recovery phase transitions").inc({
@@ -69608,11 +70163,11 @@ async function configureDeliveryCoordinator(state, deps) {
     }
   });
 }
-function disposeDeliveryCoordinator(state) {
-  state.deliveryCoordinator?.dispose();
-  state.deliveryCoordinator = void 0;
-  state.overflowTracker?.dispose();
-  state.overflowTracker = void 0;
+function disposeDeliveryCoordinator(state2) {
+  state2.deliveryCoordinator?.dispose();
+  state2.deliveryCoordinator = void 0;
+  state2.overflowTracker?.dispose();
+  state2.overflowTracker = void 0;
 }
 var init_lifecycle = __esm({
   "src/extension/registration/lifecycle.ts"() {
@@ -70589,21 +71144,21 @@ async function importOTLPExporter() {
   }
   return _cachedOTLPExporter;
 }
-async function configureObservability(ctx, state, deps) {
-  await disposeObservability(state, deps.isCleanedUp());
+async function configureObservability(ctx, state2, deps) {
+  await disposeObservability(state2, deps.isCleanedUp());
   const config = loadConfig(ctx.cwd).config;
   if (config.observability?.enabled === false) return;
   const { createMetricRegistry: createMetricRegistry2 } = await Promise.resolve().then(() => (init_metric_registry(), metric_registry_exports));
   const { wireEventToMetrics: wireEventToMetrics2 } = await Promise.resolve().then(() => (init_event_to_metric(), event_to_metric_exports));
   const { createMetricFileSink: createMetricFileSink2 } = await Promise.resolve().then(() => (init_metric_sink(), metric_sink_exports));
-  state.metricRegistry = createMetricRegistry2();
+  state2.metricRegistry = createMetricRegistry2();
   if (deps.pi.events) {
-    state.eventMetricSub = wireEventToMetrics2(deps.pi.events, state.metricRegistry);
+    state2.eventMetricSub = wireEventToMetrics2(deps.pi.events, state2.metricRegistry);
   }
   if (config.telemetry?.enabled !== false) {
-    state.metricSink = createMetricFileSink2({
+    state2.metricSink = createMetricFileSink2({
       crewRoot: projectCrewRoot(ctx.cwd),
-      registry: state.metricRegistry,
+      registry: state2.metricRegistry,
       retentionDays: config.observability?.metricRetentionDays ?? 7
     });
   }
@@ -70611,10 +71166,10 @@ async function configureObservability(ctx, state, deps) {
     const otlpEndpoint = config.otlp.endpoint;
     const otlpHeaders = config.otlp.headers;
     const otlpInterval = config.otlp.intervalMs;
-    const owningRegistry = state.metricRegistry;
+    const owningRegistry = state2.metricRegistry;
     void importOTLPExporter().then((Ctor) => {
-      if (deps.isCleanedUp() || state.metricRegistry !== owningRegistry || !owningRegistry) return;
-      state.otlpExporter = new Ctor(
+      if (deps.isCleanedUp() || state2.metricRegistry !== owningRegistry || !owningRegistry) return;
+      state2.otlpExporter = new Ctor(
         {
           endpoint: otlpEndpoint,
           headers: otlpHeaders,
@@ -70622,15 +71177,15 @@ async function configureObservability(ctx, state, deps) {
         },
         owningRegistry
       );
-      state.otlpExporter?.start();
+      state2.otlpExporter?.start();
     }).catch((error) => logInternalError("register.otlp-lazy-import", error));
   }
   const { HeartbeatWatcher: HeartbeatWatcher2 } = await Promise.resolve().then(() => (init_heartbeat_watcher(), heartbeat_watcher_exports));
-  state.heartbeatWatcher = new HeartbeatWatcher2({
+  state2.heartbeatWatcher = new HeartbeatWatcher2({
     cwd: ctx.cwd,
     pollIntervalMs: config.observability?.pollIntervalMs ?? 5e3,
     manifestCache: deps.getManifestCache(ctx.cwd),
-    registry: state.metricRegistry,
+    registry: state2.metricRegistry,
     router: {
       enqueue: (notification) => {
         deps.notifyOperator(notification);
@@ -70646,7 +71201,7 @@ async function configureObservability(ctx, state, deps) {
         attempts: 0,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
-      state.metricRegistry?.counter("crew.task.deadletter_total", "Deadletter triggers by reason").inc({ reason: "heartbeat-dead" });
+      state2.metricRegistry?.counter("crew.task.deadletter_total", "Deadletter triggers by reason").inc({ reason: "heartbeat-dead" });
       deps.pi.events?.emit?.("crew.task.deadletter", {
         runId: manifest.runId,
         taskId,
@@ -70654,12 +71209,12 @@ async function configureObservability(ctx, state, deps) {
       });
     }
   });
-  state.heartbeatWatcher.start();
+  state2.heartbeatWatcher.start();
   try {
     deps.pi.on?.("before_agent_start", () => {
       if (deps.isCleanedUp()) return;
       try {
-        deps.reconcileStaleRuns(ctx.cwd, deps.getManifestCache(ctx.cwd));
+        deps.reconcileStaleRuns(ctx.cwd, deps.getManifestCache(ctx.cwd), extractSessionId(ctx));
       } catch (error) {
         logInternalError("register.autoRepair.turnHook", error);
       }
@@ -70668,10 +71223,10 @@ async function configureObservability(ctx, state, deps) {
   }
   const autoRepairIntervalMs = config.reliability?.autoRepairIntervalMs ?? 3e5;
   if (autoRepairIntervalMs > 0) {
-    state.autoRepairTimer = setInterval(() => {
+    state2.autoRepairTimer = setInterval(() => {
       if (deps.isCleanedUp()) return;
       try {
-        const staleResults = deps.reconcileStaleRuns(ctx.cwd, deps.getManifestCache(ctx.cwd));
+        const staleResults = deps.reconcileStaleRuns(ctx.cwd, deps.getManifestCache(ctx.cwd), extractSessionId(ctx));
         if (Array.isArray(staleResults) && staleResults.length > 0) {
           for (const result4 of staleResults) {
             const repaired = result4.repaired;
@@ -70691,8 +71246,8 @@ async function configureObservability(ctx, state, deps) {
         logInternalError("register.autoRepair", error);
       }
     }, autoRepairIntervalMs);
-    state.autoRepairTimer.unref();
-    state.tempReconcileTimer = setInterval(() => {
+    state2.autoRepairTimer.unref();
+    state2.tempReconcileTimer = setInterval(() => {
       if (deps.isCleanedUp()) return;
       try {
         deps.reconcileOrphanedTempWorkspaces(Date.now(), {
@@ -70722,14 +71277,15 @@ async function configureObservability(ctx, state, deps) {
         logInternalError("register.tempAutoRepair", error);
       }
     }, autoRepairIntervalMs * 5);
-    state.tempReconcileTimer.unref();
+    state2.tempReconcileTimer.unref();
   }
   if (config.reliability?.autoRecover === true) {
     const cwdSnapshot = ctx.cwd;
     const cacheSnapshot = deps.getManifestCache(cwdSnapshot);
     void deps.importCrashRecovery().then(({ detectInterruptedRuns: detectInterruptedRuns2 }) => {
       if (deps.isCleanedUp()) return;
-      for (const plan of detectInterruptedRuns2(cwdSnapshot, cacheSnapshot)) {
+      const sid = extractSessionId(ctx);
+      for (const plan of detectInterruptedRuns2(cwdSnapshot, cacheSnapshot, 3e5, sid)) {
         deps.notifyOperator({
           id: `recovery_prompt_${plan.runId}`,
           severity: "warning",
@@ -70742,25 +71298,25 @@ async function configureObservability(ctx, state, deps) {
     }).catch((error) => logInternalError("register.crash-recovery-lazy-import", error));
   }
 }
-async function disposeObservability(state, _isCleanedUp) {
-  state.heartbeatWatcher?.dispose();
-  state.heartbeatWatcher = void 0;
-  if (state.autoRepairTimer) {
-    clearInterval(state.autoRepairTimer);
-    state.autoRepairTimer = void 0;
+async function disposeObservability(state2, _isCleanedUp) {
+  state2.heartbeatWatcher?.dispose();
+  state2.heartbeatWatcher = void 0;
+  if (state2.autoRepairTimer) {
+    clearInterval(state2.autoRepairTimer);
+    state2.autoRepairTimer = void 0;
   }
-  if (state.tempReconcileTimer) {
-    clearInterval(state.tempReconcileTimer);
-    state.tempReconcileTimer = void 0;
+  if (state2.tempReconcileTimer) {
+    clearInterval(state2.tempReconcileTimer);
+    state2.tempReconcileTimer = void 0;
   }
-  state.metricSink?.dispose();
-  state.metricSink = void 0;
-  state.eventMetricSub?.dispose();
-  state.eventMetricSub = void 0;
-  await state.otlpExporter?.dispose();
-  state.otlpExporter = void 0;
-  state.metricRegistry?.dispose();
-  state.metricRegistry = void 0;
+  state2.metricSink?.dispose();
+  state2.metricSink = void 0;
+  state2.eventMetricSub?.dispose();
+  state2.eventMetricSub = void 0;
+  await state2.otlpExporter?.dispose();
+  state2.otlpExporter = void 0;
+  state2.metricRegistry?.dispose();
+  state2.metricRegistry = void 0;
 }
 var _cachedOTLPExporter;
 var init_observability = __esm({
@@ -70769,6 +71325,7 @@ var init_observability = __esm({
     init_config();
     init_internal_error();
     init_paths();
+    init_session_utils();
   }
 });
 
@@ -74346,7 +74903,10 @@ function buildRegistrationContext(pi) {
     globalStore: globalThis,
     runtimeCleanupStoreKey: RUNTIME_CLEANUP_STORE_KEY,
     captureSessionGeneration: () => ctx.sessionGeneration,
-    isOwnerSessionCurrent: (gen) => !ctx.cleanedUp && (gen === void 0 || gen === ctx.sessionGeneration),
+    isOwnerSessionCurrent: (gen, oid) => {
+      const currentSid = ctx.currentCtx?.sessionManager?.getSessionId?.();
+      return !ctx.cleanedUp && (oid === void 0 || oid === currentSid) && (gen === void 0 || gen === ctx.sessionGeneration);
+    },
     isContextCurrent: (c, gen) => !ctx.cleanedUp && ctx.currentCtx === c && ctx.sessionGeneration === gen,
     telemetryEnabled: () => loadConfig(ctx.currentCtx?.cwd ?? process.cwd()).config.telemetry?.enabled !== false,
     notifyOperator: void 0,
@@ -74358,7 +74918,7 @@ function buildRegistrationContext(pi) {
     configureObservability: () => void 0,
     configureDeliveryCoordinator: () => void 0,
     importCrashRecovery: void 0,
-    purgeStaleActiveRunIndexSyncIfLoaded: () => void 0,
+    purgeStaleActiveRunIndexSyncIfLoaded: (_currentSessionId) => void 0,
     startForegroundRun: void 0,
     abortForegroundRun: () => false,
     openLiveSidebar: () => void 0,
@@ -74405,10 +74965,10 @@ async function importCrashRecovery() {
   }
   return _cachedCrashRecovery;
 }
-function purgeStaleActiveRunIndexSyncIfLoaded() {
+function purgeStaleActiveRunIndexSyncIfLoaded(currentSessionId) {
   if (!_cachedCrashRecovery) return;
   try {
-    _cachedCrashRecovery.purgeStaleActiveRunIndex();
+    _cachedCrashRecovery.purgeStaleActiveRunIndex(3e5, Date.now(), currentSessionId);
   } catch (error) {
     logInternalError("register.cleanupRuntime.purgeStale", error);
   }
@@ -74761,7 +75321,7 @@ async function configureObservabilityImpl(pi, ctx, extCtx) {
       getManifestCache: ctx.getManifestCache,
       notifyOperator: ctx.notifyOperator,
       isCleanedUp: () => ctx.cleanedUp,
-      reconcileStaleRuns: (cwd, cache3) => reconcileAllStaleRuns(cwd, cache3),
+      reconcileStaleRuns: (cwd, cache3, currentSessionId) => reconcileAllStaleRuns(cwd, cache3, void 0, currentSessionId),
       reconcileOrphanedTempWorkspaces: (now, opts) => reconcileOrphanedTempWorkspaces(now, opts),
       cleanupOrphanTempDirs,
       cleanupLegacyOrphanTempDirs,
@@ -74805,9 +75365,9 @@ import * as fsp3 from "node:fs/promises";
 import * as net2 from "node:net";
 
 // src/runtime/broker/crew-broker-tokens.ts
-import { randomUUID as randomUUID8, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
+import { randomUUID as randomUUID9, timingSafeEqual as timingSafeEqual3 } from "node:crypto";
 function newBrokerToken() {
-  return randomUUID8();
+  return randomUUID9();
 }
 var BrokerTokenRegistry = class _BrokerTokenRegistry {
   map = /* @__PURE__ */ new Map();
@@ -76096,7 +76656,10 @@ 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();
 init_orphan_worker_registry();
 init_crash_recovery();
 init_scheduler();
@@ -76312,9 +76875,12 @@ function registerCrewAutocomplete(ctx) {
 // src/extension/session-summary.ts
 init_crew_agent_records();
 init_process_status();
+init_session_utils();
 init_run_index();
 function notifyActiveRuns(ctx) {
+  const sid = extractSessionId(ctx);
   const active = listRuns(ctx.cwd).filter((run) => {
+    if (sid && run.ownerSessionId && run.ownerSessionId !== sid) return false;
     if (run.status !== "queued" && run.status !== "planning" && run.status !== "running") return false;
     const agents = readCrewAgents(run);
     return isDisplayActiveRun(run, agents);
@@ -76379,6 +76945,20 @@ function installSessionLifecycleHandlers(pi, ctx) {
   installSessionShutdownHandler(pi, ctx);
   installSessionStartHandler(pi, ctx);
   installSessionBeforeSwitchHandler(pi, ctx);
+  installModelTrackingHandlers(pi);
+}
+function installModelTrackingHandlers(pi) {
+  pi.on("model_select", (event) => {
+    noteSessionModel(event.model);
+  });
+  pi.on("thinking_level_select", (event) => {
+    noteSessionThinking(event.level);
+  });
+  pi.on("after_provider_response", (event) => {
+    const model = currentSessionModel();
+    const provider = model ? providerOfModelRef(model) : void 0;
+    if (provider) noteProviderResponse(provider, event.status, event.headers);
+  });
 }
 function installSessionShutdownHandler(pi, ctx) {
   pi.on("session_shutdown", (event) => {
@@ -76408,6 +76988,7 @@ function installSessionBeforeSwitchHandler(pi, ctx) {
     ctx.lifecycleState.deliveryCoordinator?.deactivate();
     resetPowerbarDedupState();
     stopAsyncRunNotifier(ctx.notifierState);
+    clearProviderQuotaCache();
     ctx.stopSessionBoundSubagents();
   });
 }
@@ -76428,6 +77009,8 @@ function installSessionStartHandler(pi, ctx) {
     ctx.sessionGeneration++;
     const ownerGeneration = ctx.sessionGeneration;
     ctx.currentCtx = extensionCtx;
+    noteSessionModel(extensionCtx.model, "session_start");
+    noteSessionThinking(extensionCtx.thinkingLevel);
     if (!ctx.crewAutocompleteRegistered) {
       ctx.crewAutocompleteRegistered = true;
       registerCrewAutocomplete(extensionCtx);
@@ -76537,7 +77120,7 @@ async function runDeferredSessionCleanup(pi, ctx, ownerGeneration, currentSessio
     logInternalError("register.sessionStart.orphanWorkers", error);
   }
   try {
-    const { purged } = purgeStaleActiveRunIndexFn();
+    const { purged } = purgeStaleActiveRunIndexFn(3e5, Date.now(), currentSessionId);
     if (purged.length > 0) {
       ctx.notifyOperator({
         id: `active_index_purge`,
@@ -76551,7 +77134,7 @@ async function runDeferredSessionCleanup(pi, ctx, ownerGeneration, currentSessio
     logInternalError("register.sessionStart.globalIndexPurge", error);
   }
   try {
-    const staleResults = reconcileAllStaleRuns(extensionCtx.cwd, ctx.getManifestCache(extensionCtx.cwd)) ?? [];
+    const staleResults = reconcileAllStaleRuns(extensionCtx.cwd, ctx.getManifestCache(extensionCtx.cwd), Date.now(), currentSessionId) ?? [];
     if (staleResults.length > 0) {
       ctx.notifyOperator({
         id: "stale_reconcile",
@@ -76671,6 +77254,9 @@ function setupCrewScheduler(pi, ctx, extensionCtx, sessionId) {
   });
   return crewScheduler;
 }
+function filterManifestsForHealthNotifications(manifests, currentSessionId) {
+  return manifests.filter((run) => !run.ownerSessionId || run.ownerSessionId === currentSessionId);
+}
 function setupRenderLoop(pi, ctx, extensionCtx, loadedConfig) {
   ctx.disposeRenderSchedulerSubscriptions();
   ctx.renderScheduler?.dispose();
@@ -76764,11 +77350,8 @@ function setupRenderLoop(pi, ctx, extensionCtx, loadedConfig) {
       ctx.widgetState.notificationCount ?? 0,
       manifests
     );
-    const currentSessionGen = ctx.sessionGeneration;
-    const currentSessionId = ctx.currentCtx ? ctx.currentCtx.sessionId : void 0;
-    const sessionManifests = manifests.filter(
-      (run) => !run.ownerSessionId || run.ownerSessionId === currentSessionId || run.ownerSessionGeneration === currentSessionGen
-    );
+    const currentSessionId = ctx.currentCtx?.sessionManager?.getSessionId();
+    const sessionManifests = filterManifestsForHealthNotifications(manifests, currentSessionId);
     const now = Date.now();
     for (const run of sessionManifests) {
       if (run.status !== "running") continue;
@@ -76998,6 +77581,7 @@ init_powerbar_publisher();
 init_widget();
 init_internal_error();
 init_paths();
+init_session_utils();
 init_async_notifier();
 init_team_tool2();
 init_lifecycle();
@@ -77021,6 +77605,7 @@ function buildCleanupSessionResourcesOnly(ctx) {
   return () => {
     if (ctx.cleanedUp) return;
     ctx.cleanedUp = true;
+    const sid = extractSessionId(ctx.currentCtx);
     if (ctx.preloadTimer) {
       clearTimeout(ctx.preloadTimer);
       ctx.preloadTimer = void 0;
@@ -77032,7 +77617,7 @@ function buildCleanupSessionResourcesOnly(ctx) {
     ctx.stopSessionBoundSubagents();
     ctx.crewScheduler?.stop();
     stopAsyncRunNotifier(ctx.notifierState);
-    ctx.purgeStaleActiveRunIndexSyncIfLoaded();
+    ctx.purgeStaleActiveRunIndexSyncIfLoaded(sid);
     stopCrewWidget(ctx.currentCtx, ctx.widgetState, ctx.currentCtx ? loadConfig(ctx.currentCtx.cwd).config.ui : void 0);
     clearPiCrewPowerbar(ctx.pi.events);
     disposePowerbarCoalescer();
@@ -77064,6 +77649,7 @@ function buildCleanupRuntime(ctx) {
   return () => {
     if (ctx.cleanedUp) return;
     ctx.cleanedUp = true;
+    const sid = extractSessionId(ctx.currentCtx);
     if (ctx.preloadTimer) {
       clearTimeout(ctx.preloadTimer);
       ctx.preloadTimer = void 0;
@@ -77078,7 +77664,7 @@ function buildCleanupRuntime(ctx) {
     stopAllWatchdogs();
     ctx.crewScheduler?.stop();
     stopAsyncRunNotifier(ctx.notifierState);
-    ctx.purgeStaleActiveRunIndexSyncIfLoaded();
+    ctx.purgeStaleActiveRunIndexSyncIfLoaded(sid);
     stopCrewWidget(ctx.currentCtx, ctx.widgetState, ctx.currentCtx ? loadConfig(ctx.currentCtx.cwd).config.ui : void 0);
     clearPiCrewPowerbar(ctx.pi.events);
     disposePowerbarCoalescer();
@@ -77155,7 +77741,7 @@ function createCompletionCoalescer(pi, ctx) {
     const f = ctx.subagentManager.getRecord(c.agentId);
     const p = ctx.currentCtx ? readPersistedSubagentRecord(ctx.currentCtx.cwd, c.agentId) : void 0;
     if (f?.resultConsumed || p?.resultConsumed) return false;
-    if (!ctx.isOwnerSessionCurrent(f?.ownerSessionGeneration ?? c.ownerGen)) return false;
+    if (!ctx.isOwnerSessionCurrent(f?.ownerSessionGeneration ?? c.ownerGen, f?.ownerSessionId)) return false;
     return true;
   };
   const flush = () => {
@@ -77263,7 +77849,7 @@ function onTerminalStatus(pi, ctx, record, coalescer) {
     });
   }
   if (!record.background) return;
-  if (!ctx.isOwnerSessionCurrent(record.ownerSessionGeneration)) return;
+  if (!ctx.isOwnerSessionCurrent(record.ownerSessionGeneration, record.ownerSessionId)) return;
   if (record.status !== "completed" && record.status !== "failed" && record.status !== "cancelled" && record.status !== "blocked" && record.status !== "error")
     return;
   const agentId = record.id;
@@ -77279,7 +77865,7 @@ function onTerminalStatus(pi, ctx, record, coalescer) {
       const fresh = ctx.subagentManager.getRecord(agentId);
       const persisted = ctx.currentCtx ? readPersistedSubagentRecord(ctx.currentCtx.cwd, agentId) : void 0;
       if (fresh?.resultConsumed || persisted?.resultConsumed) return;
-      if (!ctx.isOwnerSessionCurrent(fresh?.ownerSessionGeneration ?? ownerGen)) return;
+      if (!ctx.isOwnerSessionCurrent(fresh?.ownerSessionGeneration ?? ownerGen, fresh?.ownerSessionId)) return;
       const member = {
         id: agentId,
         description: agentDescription,
@@ -77314,7 +77900,8 @@ function onTerminalStatus(pi, ctx, record, coalescer) {
 }
 function onInternalEvent(pi, ctx, event, payload) {
   const ownerGeneration = typeof payload?.ownerSessionGeneration === "number" ? payload.ownerSessionGeneration : void 0;
-  if (ownerGeneration !== void 0 && !ctx.isOwnerSessionCurrent(ownerGeneration)) return;
+  const ownerSessionId = typeof payload?.ownerSessionId === "string" ? payload.ownerSessionId : void 0;
+  if (ownerGeneration !== void 0 && !ctx.isOwnerSessionCurrent(ownerGeneration, ownerSessionId)) return;
   if (event === "subagent.stuck-blocked") {
     const p = payload;
     const id = typeof p.id === "string" ? p.id : "unknown";
@@ -77428,6 +78015,7 @@ function registerSubagentTools(pi, subagentManager, options = {}) {
       spawnOptions.ownerSessionGeneration = options.ownerSessionGeneration?.();
       if (!spawnOptions.prompt.trim()) return subagentToolResult(t("agent.requiresPrompt"), {}, true);
       const ctxWithSession = withSessionId(ctx);
+      spawnOptions.ownerSessionId = ctxWithSession.sessionId;
       const runner = async (currentOptions, childSignal) => handleTeamTool6(
         {
           action: "run",
@@ -77549,6 +78137,10 @@ function registerSubagentTools(pi, subagentManager, options = {}) {
       const inMemory = subagentManager.getRecord(p.agent_id);
       const record = inMemory ?? readPersistedSubagentRecord(ctx.cwd, p.agent_id);
       if (!record) return subagentToolResult(t("result.notFound", { id: p.agent_id }), {}, true);
+      const currentSessionId = withSessionId(ctx).sessionId;
+      if (record.ownerSessionId && record.ownerSessionId !== currentSessionId) {
+        return subagentToolResult("Agent belongs to another session.", {}, true);
+      }
       let current = refreshPersistedSubagentRecord(ctx, record);
       if (inMemory && current !== inMemory) Object.assign(inMemory, current);
       if (!inMemory && !current.runId && (current.status === "running" || current.status === "queued")) {
@@ -77599,9 +78191,11 @@ function registerSubagentTools(pi, subagentManager, options = {}) {
       }
       const output = readSubagentRunResult(ctx, current);
       if (current.status !== "running" && current.status !== "queued" && current.status !== "blocked") {
-        current.resultConsumed = true;
-        if (inMemory) inMemory.resultConsumed = true;
-        savePersistedSubagentRecord(ctx.cwd, current);
+        if (!current.ownerSessionId || current.ownerSessionId === currentSessionId) {
+          current.resultConsumed = true;
+          if (inMemory) inMemory.resultConsumed = true;
+          savePersistedSubagentRecord(ctx.cwd, current);
+        }
       }
       const text = [
         p.verbose ? formatSubagentRecord(current) : void 0,