pi-crew 0.9.59 → 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
   };
@@ -13024,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));
@@ -13954,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;
@@ -14925,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) {
@@ -17843,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);
@@ -17903,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 {
@@ -20969,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 {
@@ -20989,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);
   }
@@ -21622,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;
@@ -21925,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;
@@ -22045,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;
@@ -22094,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}`);
       }
     }
@@ -22245,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));
@@ -22308,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 [];
   }
@@ -22486,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);
 }
@@ -22539,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) {
@@ -22588,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;
@@ -22596,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++;
@@ -22607,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,
@@ -22682,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);
@@ -22697,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} -->
@@ -22741,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;
@@ -23641,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"),
@@ -23657,7 +24386,7 @@ function readTextTail(filePath, maxBytes = 64e3) {
       truncated: stat2.size > bytesToRead
     };
   } finally {
-    fs34.closeSync(fd);
+    fs35.closeSync(fd);
   }
 }
 function compactDuration(ms) {
@@ -23696,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";
   }
@@ -23749,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);
@@ -23787,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 };
@@ -23922,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) {
@@ -23965,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;
         }
@@ -23999,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"
@@ -24026,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 {
@@ -24045,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 = [];
@@ -24152,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;
@@ -24184,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;
@@ -24192,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 {
@@ -24201,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;
@@ -24211,7 +24940,7 @@ function writeForegroundInterruptRequest(manifest, reason = "User requested fore
               } catch {
               }
               if (!alive) {
-                fs37.rmSync(lockDir, {
+                fs38.rmSync(lockDir, {
                   recursive: true,
                   force: true
                 });
@@ -24228,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;
@@ -24238,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
                 });
@@ -24256,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 = [];
@@ -24277,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, {
@@ -24320,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");
 }
@@ -24338,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;
 }
@@ -24349,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 {
@@ -25145,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";
@@ -32567,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);
@@ -32581,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);
@@ -32592,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;
 }
@@ -32863,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;
@@ -32891,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
     });
@@ -33229,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);
@@ -36966,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 [
@@ -37150,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();
@@ -41175,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();
@@ -41218,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;
         }
       }
@@ -41251,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).
@@ -41306,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");
@@ -41399,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);
@@ -43971,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;
       }
     }
   };
@@ -45452,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) {
@@ -45463,75 +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,
       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;
-    state.model.workspaceId = workspaceId;
+    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);
   }
 }
@@ -45751,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) {
@@ -45774,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,
@@ -52684,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) {
@@ -52729,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;
@@ -52867,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,
@@ -53035,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,
@@ -53045,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), "");
@@ -53117,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);
@@ -55028,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
@@ -55071,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",
@@ -55197,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;
@@ -56725,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) {
@@ -57049,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,
@@ -57234,6 +57719,7 @@ async function dispatchBatch(ctx, decision2) {
       promise: rawPromise,
       wrapped
     });
+    for (const id of unitTaskIds) ctx.dispatchedTaskIds.add(id);
   }
 }
 async function mergeUnitResult(ctx) {
@@ -57594,6 +58080,7 @@ async function executeTeamRunCore(input, manifest, workflow) {
     queueIndex,
     wfMachine,
     pendingUnits,
+    dispatchedTaskIds: /* @__PURE__ */ new Set(),
     runController,
     runtimeKind,
     adaptivePlanInjected,
@@ -59720,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;
         }
       }
@@ -60626,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}`);
       }
@@ -61226,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
@@ -61436,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,
@@ -61502,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,
@@ -61551,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();
@@ -61959,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,
@@ -62206,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();
@@ -63237,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`),
@@ -63815,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;
@@ -65747,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;
       }
@@ -65800,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;
@@ -65841,7 +66334,7 @@ var init_mascot = __esm({
               }
             }
           }
-          state.phase += 3;
+          state2.phase += 3;
           return false;
         }
         for (let row = 0; row < ARMIN_DISPLAY_HEIGHT; row++) {
@@ -65852,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;
       }
@@ -68647,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 });
@@ -68692,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(
@@ -68709,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);
@@ -68920,31 +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;
+  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) {
+      if (cachedRuns === void 0 || nowMs3 - (state2.lastListRunsMs ?? 0) > LIST_RUNS_DEBOUNCE_MS) {
         cachedRuns = listRuns(ctx.cwd).filter(ownsRun).slice(0, 20);
-        state.lastListRunsMs = nowMs3;
+        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);
@@ -68957,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({
@@ -69419,7 +69912,7 @@ var init_overflow_recovery = __esm({
           default:
             break;
         }
-        const state = {
+        const state2 = {
           taskId,
           runId,
           phase,
@@ -69428,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}`);
           }
@@ -69444,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);
       }
       /**
@@ -69462,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;
           }
         }
@@ -69494,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);
@@ -69535,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;
@@ -69549,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);
@@ -69565,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));
@@ -69577,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;
@@ -69619,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);
     },
@@ -69643,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({
@@ -69670,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"() {
@@ -70651,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
     });
   }
@@ -70673,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,
@@ -70684,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);
@@ -70708,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,
@@ -70716,7 +71209,7 @@ async function configureObservability(ctx, state, deps) {
       });
     }
   });
-  state.heartbeatWatcher.start();
+  state2.heartbeatWatcher.start();
   try {
     deps.pi.on?.("before_agent_start", () => {
       if (deps.isCleanedUp()) return;
@@ -70730,7 +71223,7 @@ 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), extractSessionId(ctx));
@@ -70753,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(), {
@@ -70784,7 +71277,7 @@ 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;
@@ -70805,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({
@@ -76163,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();
@@ -76449,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) => {
@@ -76478,6 +76988,7 @@ function installSessionBeforeSwitchHandler(pi, ctx) {
     ctx.lifecycleState.deliveryCoordinator?.deactivate();
     resetPowerbarDedupState();
     stopAsyncRunNotifier(ctx.notifierState);
+    clearProviderQuotaCache();
     ctx.stopSessionBoundSubagents();
   });
 }
@@ -76498,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);