pi-crew 0.9.26 → 0.9.28

package/dist/index.mjs

@@ -8693,6 +8693,7 @@ __export(atomic_write_exports, {
   atomicWriteJsonAsync: () => atomicWriteJsonAsync,
   atomicWriteJsonCoalesced: () => atomicWriteJsonCoalesced,
   flushPendingAtomicWrites: () => flushPendingAtomicWrites,
+  invalidateSymlinkSafeCache: () => invalidateSymlinkSafeCache,
   isSymlinkSafePath: () => isSymlinkSafePath,
   readJsonFile: () => readJsonFile,
   renameWithRetry: () => renameWithRetry,
@@ -8774,6 +8775,32 @@ function isSymlinkSafePath(filePath) {
     return false;
   }
 }
+function invalidateSymlinkSafeCache(dir) {
+  if (dir) symlinkSafeCache.delete(dir);
+  else symlinkSafeCache.clear();
+}
+function isTargetNotSymlink(filePath) {
+  try {
+    if (fs2.lstatSync(filePath).isSymbolicLink()) return false;
+  } catch {
+  }
+  return true;
+}
+function isSymlinkSafeDirCached(filePath) {
+  const now = Date.now();
+  const dir = path2.dirname(filePath);
+  if (!isTargetNotSymlink(filePath)) return false;
+  const hit = symlinkSafeCache.get(dir);
+  if (hit && now - hit.at < SYMLINK_SAFE_TTL_MS) return hit.safe;
+  const verdict = isSymlinkSafePath(path2.join(dir, ".symlink-safe-check"));
+  symlinkSafeCache.set(dir, { safe: verdict, at: now });
+  while (symlinkSafeCache.size > SYMLINK_SAFE_MAX_ENTRIES) {
+    const oldest = symlinkSafeCache.keys().next().value;
+    if (oldest === void 0) break;
+    symlinkSafeCache.delete(oldest);
+  }
+  return verdict;
+}
 function sleep2(ms) {
   return new Promise((resolve21) => setTimeout(resolve21, ms));
 }
@@ -8889,8 +8916,19 @@ async function renameWithRetryAsync(tempPath, filePath, retries = 8, rename = (s
   }
   throw lastError;
 }
-function atomicWriteFile(filePath, content, expectedHash) {
-  if (!isSymlinkSafePath(filePath)) throw new Error(`Refusing to write: target is a symlink or inside untrusted directory: ${filePath}`);
+function normalizeOptions(arg) {
+  if (typeof arg === "string") return { expectedHash: arg, durability: "full" };
+  if (arg && typeof arg === "object") {
+    const o = arg;
+    const durability = o.durability === "best-effort" ? "best-effort" : "full";
+    return { expectedHash: o.expectedHash, durability };
+  }
+  return { durability: "full" };
+}
+function atomicWriteFile(filePath, content, options) {
+  const { durability } = normalizeOptions(options);
+  if (!isSymlinkSafeDirCached(filePath))
+    throw new Error(`Refusing to write: target is a symlink or inside untrusted directory: ${filePath}`);
   const canonicalize = (p) => {
     try {
       const r = fs2.realpathSync.native(p);
@@ -8925,14 +8963,14 @@ function atomicWriteFile(filePath, content, expectedHash) {
       throw new Error(`Refusing to write: opened path is not a regular file: ${tempPath}`);
     }
     fs2.writeSync(fd, content, void 0, "utf-8");
-    fs2.fsyncSync(fd);
+    if (durability === "full") fs2.fsyncSync(fd);
     fs2.closeSync(fd);
     try {
-      if (!isSymlinkSafePath(filePath)) {
+      if (!isSymlinkSafeDirCached(filePath)) {
         throw new Error(`Refusing to rename: target became a symlink or inside untrusted directory: ${filePath}`);
       }
       renameWithLinkSync(tempPath, filePath);
-      if (process.platform !== "win32") {
+      if (durability === "full" && process.platform !== "win32") {
         try {
           const dirFd = fs2.openSync(path2.dirname(filePath), "r");
           fs2.fsyncSync(dirFd);
@@ -8963,11 +9001,13 @@ function atomicWriteFile(filePath, content, expectedHash) {
     }
   }
 }
-async function atomicWriteFileAsync(filePath, content) {
+async function atomicWriteFileAsync(filePath, content, options) {
+  const { durability } = normalizeOptions(options);
   if (isWorkerAtomicWriterEnabled()) {
     return atomicWriteFileViaWorker(filePath, content);
   }
-  if (!isSymlinkSafePath(filePath)) throw new Error(`Refusing to write: target is a symlink or inside untrusted directory: ${filePath}`);
+  if (!isSymlinkSafeDirCached(filePath))
+    throw new Error(`Refusing to write: target is a symlink or inside untrusted directory: ${filePath}`);
   await fs2.promises.mkdir(path2.dirname(filePath), { recursive: true });
   const tempPath = `${filePath}.${crypto.randomUUID()}.tmp`;
   try {
@@ -8979,33 +9019,12 @@ async function atomicWriteFileAsync(filePath, content) {
       throw new Error(`Refusing to write: opened path is not a regular file: ${tempPath}`);
     }
     await fd.writeFile(content, "utf-8");
+    if (durability === "full") await fd.sync();
     await fd.close();
-    try {
-      if (!isSymlinkSafePath(filePath)) {
-        try {
-          await fs2.promises.rm(tempPath, { force: true });
-        } catch {
-        }
-        throw new Error(`Refusing to rename: target became a symlink or inside untrusted directory: ${filePath}`);
-      }
-      await renameWithLinkAsync(tempPath, filePath);
-    } catch (renameError) {
-      let matches = false;
-      try {
-        const existing = await fs2.promises.readFile(filePath, "utf-8");
-        matches = existing === content;
-      } catch {
-      }
-      if (matches) {
-        try {
-          await fs2.promises.rm(tempPath, { force: true });
-        } catch (cleanupError) {
-          logInternalError("atomic-write.cleanupAsync", cleanupError, `tempPath=${tempPath}`);
-        }
-        return;
-      }
-      throw renameError;
+    if (!isSymlinkSafeDirCached(filePath)) {
+      throw new Error(`Refusing to rename: target became a symlink or inside untrusted directory: ${filePath}`);
     }
+    await renameWithLinkAsync(tempPath, filePath);
   } catch (error) {
     try {
       await fs2.promises.rm(tempPath, { force: true });
@@ -9015,15 +9034,15 @@ async function atomicWriteFileAsync(filePath, content) {
     throw error;
   }
 }
-function atomicWriteJson(filePath, value) {
+function atomicWriteJson(filePath, value, options) {
   atomicWriteFile(filePath, `${JSON.stringify(value, null, 2)}
-`);
+`, options);
 }
-async function atomicWriteJsonAsync(filePath, value) {
+async function atomicWriteJsonAsync(filePath, value, options) {
   await atomicWriteFileAsync(filePath, `${JSON.stringify(value, null, 2)}
-`);
+`, options);
 }
-function atomicWriteJsonCoalesced(filePath, value, coalesceMs = DEFAULT_ATOMIC_COALESCE_MS) {
+function atomicWriteJsonCoalesced(filePath, value, coalesceMs = DEFAULT_ATOMIC_COALESCE_MS, options) {
   const content = `${JSON.stringify(value, null, 2)}
 `;
   const previous = pendingAtomicWrites.get(filePath);
@@ -9031,12 +9050,14 @@ function atomicWriteJsonCoalesced(filePath, value, coalesceMs = DEFAULT_ATOMIC_C
   const timer = setTimeout(() => flushOnePendingAtomicWrite(filePath), coalesceMs);
   timer.unref();
   const generation = ++writeGeneration;
+  const normalized = normalizeOptions(options);
   pendingAtomicWrites.set(filePath, {
     content,
     timer,
     coalesceMs,
     retryCount: 0,
-    generation
+    generation,
+    durability: normalized.durability
   });
 }
 function flushOnePendingAtomicWrite(filePath) {
@@ -9045,7 +9066,7 @@ function flushOnePendingAtomicWrite(filePath) {
   const savedGeneration = entry.generation;
   clearTimeout(entry.timer);
   try {
-    atomicWriteFile(filePath, entry.content);
+    atomicWriteFile(filePath, entry.content, { durability: entry.durability });
     if (pendingAtomicWrites.get(filePath)?.generation === savedGeneration) {
       pendingAtomicWrites.delete(filePath);
     }
@@ -9090,7 +9111,7 @@ function readJsonFile(filePath) {
     }
   }
 }
-var RETRYABLE_RENAME_CODES, RETRYABLE_LINK_CODES, __test__renameWithRetry, __test__renameWithRetryAsync, MAX_FLUSH_RETRIES, pendingAtomicWrites, DEFAULT_ATOMIC_COALESCE_MS, writeGeneration, flushInProgress;
+var RETRYABLE_RENAME_CODES, RETRYABLE_LINK_CODES, SYMLINK_SAFE_TTL_MS, SYMLINK_SAFE_MAX_ENTRIES, symlinkSafeCache, __test__renameWithRetry, __test__renameWithRetryAsync, MAX_FLUSH_RETRIES, pendingAtomicWrites, DEFAULT_ATOMIC_COALESCE_MS, writeGeneration, flushInProgress;
 var init_atomic_write = __esm({
   "src/state/atomic-write.ts"() {
     "use strict";
@@ -9099,6 +9120,9 @@ var init_atomic_write = __esm({
     init_worker_atomic_writer();
     RETRYABLE_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES"]);
     RETRYABLE_LINK_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOENT"]);
+    SYMLINK_SAFE_TTL_MS = 3e4;
+    SYMLINK_SAFE_MAX_ENTRIES = 128;
+    symlinkSafeCache = /* @__PURE__ */ new Map();
     __test__renameWithRetry = renameWithRetry;
     __test__renameWithRetryAsync = renameWithRetryAsync;
     MAX_FLUSH_RETRIES = 5;
@@ -9120,6 +9144,7 @@ var init_defaults = __esm({
     DEFAULT_CHILD_PI = {
       postExitStdioGuardMs: 3e3,
       finalDrainMs: 5e3,
+      finalDrainQuietMs: 800,
       hardKillMs: 3e3,
       // Child workers can spend more than a few seconds in provider calls or long-running tools without emitting stdout.
       // Keep this as a coarse stuck-worker guard rather than a short per-message latency budget.
@@ -9325,14 +9350,10 @@ function readLockToken(filePath) {
   }
 }
 function timingSafeTokenMatch(a, b) {
-  const bufA = Buffer.from(String(a));
-  const bufB = Buffer.from(String(b));
-  const len = Math.max(bufA.length, bufB.length);
-  const safeA = Buffer.alloc(len);
-  const safeB = Buffer.alloc(len);
-  bufA.copy(safeA);
-  bufB.copy(safeB);
-  return timingSafeEqual(safeA, safeB);
+  if (a.length !== b.length) return false;
+  const bufA = Buffer.from(a);
+  const bufB = Buffer.from(b);
+  return timingSafeEqual(bufA, bufB);
 }
 function releaseLock(filePath, token) {
   let isSymlink2 = false;
@@ -11703,9 +11724,6 @@ function resetEventLogMode() {
   asyncQueues.clear();
 }
 async function appendEventAsync(eventsPath, event) {
-  if (!TERMINAL_EVENT_TYPES.has(event.type)) {
-    return appendEventBuffered(eventsPath, event);
-  }
   const queueKey = eventsPath;
   const prev = asyncQueues.get(queueKey) ?? Promise.resolve();
   const next = prev.then(async () => {
@@ -12014,12 +12032,14 @@ function appendEventInsideLock(eventsPath, event) {
   if (!skippedDueToSize) {
     fs8.appendFileSync(eventsPath, `${JSON.stringify(redactSecrets(fullEvent))}
 `, "utf-8");
-    const fd = fs8.openSync(eventsPath, "r+");
-    try {
-      fs8.fsyncSync(fd);
-    } catch {
-    } finally {
-      fs8.closeSync(fd);
+    if (isTerminal) {
+      const fd = fs8.openSync(eventsPath, "r+");
+      try {
+        fs8.fsyncSync(fd);
+      } catch {
+      } finally {
+        fs8.closeSync(fd);
+      }
     }
     persistSequence(eventsPath, seq);
     try {
@@ -12212,6 +12232,20 @@ var init_event_log = __esm({
       }
       asyncQueues.clear();
     });
+    process.on("beforeExit", async () => {
+      if (bufferedQueues.size > 0) {
+        try {
+          await flushEventLogBuffer();
+        } catch {
+        }
+      }
+      if (asyncQueues.size > 0) {
+        try {
+          await drainAsyncQueues();
+        } catch {
+        }
+      }
+    });
     process.on("SIGTERM", () => setImmediate(() => flushEventLogBuffer()));
     process.on("SIGINT", () => setImmediate(() => flushEventLogBuffer()));
     process.on("uncaughtException", (error) => {
@@ -12514,7 +12548,7 @@ function resolveRealContainedPath(baseDir, targetPath2) {
         if (process.platform === "darwin") {
           const resolvedSymlink = resolvedAccumulated;
           const knownDarwinSymlinks = ["/var", "/tmp", "/etc", "/private/var", "/private/tmp", "/private/etc"];
-          if (knownDarwinSymlinks.includes(resolvedSymlink)) continue;
+          if (knownDarwinSymlinks.some((s) => resolvedSymlink === s || resolvedSymlink.startsWith(s + "/"))) continue;
         }
         throw new Error("Refusing to resolve: target path ancestor is a symlink: " + resolvedAccumulated);
       }
@@ -13155,6 +13189,9 @@ function statManifestWithWindowsRetry(manifestPath) {
   }
   return fs12.statSync(manifestPath);
 }
+function genOf(stateRoot) {
+  return manifestCacheGeneration.get(stateRoot) ?? 0;
+}
 function __test__setManifestCache(stateRoot, entry) {
   setManifestCache(stateRoot, entry);
 }
@@ -13164,7 +13201,7 @@ function __test__getManifestCacheEntry(stateRoot) {
 function setManifestCache(stateRoot, entry) {
   if (manifestCache.has(stateRoot)) manifestCache.delete(stateRoot);
   entry.cachedAt = Date.now();
-  entry.generation = manifestCacheGeneration;
+  entry.generation = genOf(stateRoot);
   const now = Date.now();
   for (const [key, val] of manifestCache.entries()) {
     if (val.cachedAt && now - val.cachedAt > MANIFEST_CACHE_TTL_MS) {
@@ -13191,7 +13228,7 @@ function useProjectState(cwd) {
 }
 function invalidateRunCache(stateRoot) {
   manifestCache.delete(stateRoot);
-  manifestCacheGeneration++;
+  manifestCacheGeneration.set(stateRoot, genOf(stateRoot) + 1);
 }
 function scopeBaseRoot(cwd) {
   return useProjectState(cwd) ? projectCrewRoot(cwd) : userCrewRoot();
@@ -13332,13 +13369,24 @@ function saveRunManifest(manifest) {
   const manifestPath = path10.join(manifest.stateRoot, "manifest.json");
   atomicWriteJson(manifestPath, manifest);
   const manifestStat = fs12.statSync(manifestPath);
+  let tasks = [];
+  let tasksMtimeMs = 0;
+  let tasksSize = 0;
+  try {
+    const tasksPath = path10.join(manifest.stateRoot, "tasks.json");
+    const tasksStat = fs12.statSync(tasksPath);
+    tasks = JSON.parse(fs12.readFileSync(tasksPath, "utf-8"));
+    tasksMtimeMs = tasksStat.mtimeMs;
+    tasksSize = tasksStat.size;
+  } catch {
+  }
   setManifestCache(manifest.stateRoot, {
     manifest,
-    tasks: [],
+    tasks,
     manifestMtimeMs: manifestStat.mtimeMs,
     manifestSize: manifestStat.size,
-    tasksMtimeMs: 0,
-    tasksSize: 0
+    tasksMtimeMs,
+    tasksSize
   });
 }
 async function saveRunManifestAsync(manifest) {
@@ -13506,7 +13554,7 @@ function loadRunManifestById(cwd, runId) {
     tasksStat = void 0;
   }
   const tasksMtimeMs = tasksStat?.mtimeMs ?? 0;
-  if (cached && cached.manifestMtimeMs === manifestStat.mtimeMs && cached.manifestSize === manifestStat.size && cached.tasksMtimeMs === tasksMtimeMs && cached.tasksSize === (tasksStat?.size ?? 0) && cached.generation === manifestCacheGeneration) {
+  if (cached && cached.manifestMtimeMs === manifestStat.mtimeMs && cached.manifestSize === manifestStat.size && cached.tasksMtimeMs === tasksMtimeMs && cached.tasksSize === (tasksStat?.size ?? 0) && cached.generation === genOf(stateRoot)) {
     if (!cached.cachedAt || Date.now() - cached.cachedAt > MANIFEST_CACHE_TTL_MS) {
       manifestCache.delete(stateRoot);
     } else if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
@@ -13569,7 +13617,7 @@ async function loadRunManifestByIdAsync(cwd, runId) {
     tasksStat = void 0;
   }
   const tasksMtimeMs = tasksStat?.mtimeMs ?? 0;
-  if (cached && cached.manifestMtimeMs === manifestStat.mtimeMs && cached.manifestSize === manifestStat.size && cached.tasksMtimeMs === tasksMtimeMs && cached.tasksSize === (tasksStat?.size ?? 0) && cached.generation === manifestCacheGeneration) {
+  if (cached && cached.manifestMtimeMs === manifestStat.mtimeMs && cached.manifestSize === manifestStat.size && cached.tasksMtimeMs === tasksMtimeMs && cached.tasksSize === (tasksStat?.size ?? 0) && cached.generation === genOf(stateRoot)) {
     if (!cached.cachedAt || Date.now() - cached.cachedAt > MANIFEST_CACHE_TTL_MS) {
       manifestCache.delete(stateRoot);
     } else if (!validateRunManifestPaths(cwd, runId, cached.manifest, stateRoot, tasksPath)) {
@@ -13629,7 +13677,7 @@ var init_state_store = __esm({
     init_contracts();
     init_event_log();
     init_locks();
-    manifestCacheGeneration = 0;
+    manifestCacheGeneration = /* @__PURE__ */ new Map();
     MANIFEST_CACHE_TTL_MS = 15 * 1e3;
     LOAD_MANIFEST_RETRY_LIMIT = 5;
     manifestCache = /* @__PURE__ */ new Map();
@@ -13950,18 +13998,20 @@ function upsertCrewAgent(manifest, record) {
 }
 function writeCrewAgentStatus(manifest, record) {
   ensureAgentStateDir(manifest, record.taskId);
-  atomicWriteJson(agentStatusPath(manifest, record.taskId), redactSecrets(record));
+  atomicWriteJson(agentStatusPath(manifest, record.taskId), redactSecrets(record), { durability: "full" });
 }
 function saveCrewAgentsCoalesced(manifest, records) {
   const filePath = agentsPath(manifest);
   fs14.mkdirSync(manifest.stateRoot, { recursive: true });
-  atomicWriteJsonCoalesced(filePath, redactSecrets(records), AGENT_COALESCE_MS);
+  atomicWriteJsonCoalesced(filePath, redactSecrets(records), AGENT_COALESCE_MS, { durability: "best-effort" });
   asyncAgentReaderCache.delete(filePath);
   for (const record of records) writeCrewAgentStatusCoalesced(manifest, record);
 }
 function writeCrewAgentStatusCoalesced(manifest, record) {
   ensureAgentStateDir(manifest, record.taskId);
-  atomicWriteJsonCoalesced(agentStatusPath(manifest, record.taskId), redactSecrets(record), AGENT_COALESCE_MS);
+  atomicWriteJsonCoalesced(agentStatusPath(manifest, record.taskId), redactSecrets(record), AGENT_COALESCE_MS, {
+    durability: "best-effort"
+  });
 }
 function readCrewAgentStatus(manifest, taskOrAgentId) {
   try {
@@ -15549,12 +15599,12 @@ function getProcessStartTime2(pid) {
   } catch {
     return void 0;
   }
-  const platform = process.platform;
-  if (platform === "linux") {
+  const platform2 = process.platform;
+  if (platform2 === "linux") {
     return getProcessStartTimeLinux(pid);
-  } else if (platform === "darwin") {
+  } else if (platform2 === "darwin") {
     return getProcessStartTimeMacOS(pid);
-  } else if (platform === "win32") {
+  } else if (platform2 === "win32") {
     return getProcessStartTimeWindows(pid);
   }
   return void 0;
@@ -16440,7 +16490,9 @@ function buildPiWorkerArgs(input) {
       PI_TEAMS_INHERIT_SKILLS: input.agent.inheritSkills ? "1" : "0",
       PI_TEAMS_DEPTH: String(parentDepth + 1),
       PI_TEAMS_MAX_DEPTH: String(maxDepth),
-      PI_TEAMS_ROLE: input.agent.name
+      PI_TEAMS_ROLE: input.agent.name,
+      // maxTokens cap for background workers — prompt-runtime reads this to cap API output
+      ...input.agent.maxTokens ? { PI_CREW_MAX_OUTPUT: String(input.agent.maxTokens) } : {}
     },
     tempDir
   };
@@ -18663,6 +18715,7 @@ ${JSON.stringify({ type: "message_end", usage: { input: 10, output: 5, cost: 1e-
     skillPaths: input.skillPaths,
     role: input.role
   });
+  if (input.steeringFile) built.env.PI_CREW_STEERING_FILE = input.steeringFile;
   const spawnSpec = getPiSpawnCommand(built.args);
   try {
     return await new Promise((resolve21) => {
@@ -18714,6 +18767,7 @@ ${JSON.stringify({ type: "message_end", usage: { input: 10, output: 5, cost: 1e-
       const finalDrainMs = input.finalDrainMs ?? FINAL_DRAIN_MS;
       const hardKillMs = input.hardKillMs ?? HARD_KILL_MS;
       let finalDrainArmed = false;
+      let lastStdoutActivityMonotonicMs = performance.now();
       let finalDrainFiredMonotonicMs;
       const spawnMonotonicMs = performance.now();
       let finalAssistantEventMonotonicMs;
@@ -18872,10 +18926,59 @@ ${JSON.stringify({ type: "message_end", usage: { input: 10, output: 5, cost: 1e-
             completeOperation(eventOpId);
             throw err2;
           }
+          lastStdoutActivityMonotonicMs = performance.now();
           input.onJsonEvent?.(event);
           if (!isFinalAssistantEvent(event) || childExited || settled || finalDrainTimer) return;
           finalAssistantEventMonotonicMs = performance.now();
           finalDrainArmed = true;
+          const quietMs = input.finalDrainQuietMs ?? DEFAULT_CHILD_PI.finalDrainQuietMs;
+          if (quietMs < (input.finalDrainMs ?? DEFAULT_CHILD_PI.finalDrainMs)) {
+            const pollHandle = setInterval(() => {
+              if (settled || childExited) {
+                clearInterval(pollHandle);
+                pollHandle.unref();
+                return;
+              }
+              const sinceLast = performance.now() - lastStdoutActivityMonotonicMs;
+              if (sinceLast >= quietMs) {
+                clearInterval(pollHandle);
+                pollHandle.unref();
+                forcedFinalDrain = true;
+                finalDrainFiredMonotonicMs = performance.now();
+                input.onLifecycleEvent?.({
+                  type: "final_drain",
+                  pid: child.pid,
+                  ts: (/* @__PURE__ */ new Date()).toISOString(),
+                  reason: "stdout-quiet"
+                });
+                try {
+                  child.kill(process.platform === "win32" ? void 0 : "SIGTERM");
+                } catch (error) {
+                  logInternalError("child-pi.quiet-drain-term", error, `pid=${child.pid}`);
+                }
+                hardKillTimer = setTimeout(() => {
+                  if (settled || childExited) return;
+                  try {
+                    hardKilled = true;
+                    input.onLifecycleEvent?.({
+                      type: "hard_kill",
+                      pid: child.pid,
+                      ts: (/* @__PURE__ */ new Date()).toISOString()
+                    });
+                    child.kill(process.platform === "win32" ? void 0 : "SIGKILL");
+                  } catch (error) {
+                    logInternalError("child-pi.quiet-drain-hard-kill", error, `pid=${child.pid}`);
+                  }
+                }, hardKillMs);
+                hardKillTimer.unref();
+                if (finalDrainTimer) {
+                  clearTimeout(finalDrainTimer);
+                  finalDrainTimer = void 0;
+                }
+              }
+            }, 200);
+            pollHandle.unref();
+          }
           finalDrainTimer = setTimeout(() => {
             if (settled || childExited) return;
             forcedFinalDrain = true;
@@ -19199,6 +19302,15 @@ var init_child_pi = __esm({
     MAX_COMPACT_CONTENT_CHARS = DEFAULT_CHILD_PI.maxCompactContentChars;
     activeChildProcesses = /* @__PURE__ */ new Map();
     childHardKillTimers = /* @__PURE__ */ new Map();
+    setInterval(() => {
+      for (const [pid, child] of activeChildProcesses) {
+        try {
+          process.kill(pid, 0);
+        } catch {
+          activeChildProcesses.delete(pid);
+        }
+      }
+    }, 6e4).unref();
     BASE_ALLOWLIST = [
       "PATH",
       "HOME",
@@ -19239,22 +19351,29 @@ var init_child_pi = __esm({
       "PI_TEAMS_INHERIT_SKILLS",
       "PI_TEAMS_PI_BIN",
       "PI_TEAMS_MOCK_CHILD_PI",
-      "PI_CREW_ALLOW_MOCK"
+      "PI_CREW_ALLOW_MOCK",
+      "PI_CREW_MAX_OUTPUT",
+      "PI_CREW_STEERING_FILE"
     ];
-    ChildPiLineObserver = class {
+    ChildPiLineObserver = class _ChildPiLineObserver {
       buffer = "";
       input;
-      /** RAW (uncapped) assistant-text fragments, accumulated in arrival order.
-       *  Mirrors {@link parsePiJsonOutput}'s textEvents/finalText extraction but
-       *  operates on the RAW event stream instead of the 16K-compacted transcript.
-       *  This is the source of the AUTHORITATIVE result.txt; the transcript stays
-       *  compacted (memory bound). */
+      /** F9: bounded ring buffer for RAW assistant-text fragments. Consumers
+       * (getRawFinalText) only read the last element, but the legacy implementation
+       * accumulated every fragment unconditionally, which let a verbose/long-running
+       * worker grow this array linearly with output. We retain the last 2 entries:
+       * the consumer needs the last; we keep the second-to-last only as a defensive
+       * fence against a race where a final event arrives just after the consumer
+       * read (the previous "last" is still the most-recent pre-final text in that
+       * window). 2 is well below any plausible consumer's "tail-only" need while
+       * bounding memory. */
+      static MAX_RAW_TEXT_EVENTS = 2;
       rawTextEvents = [];
-      /** #7 hardening: bounded digest of intermediate findings. When a worker spends
-       *  its entire budget on tool calls (never emits a final assistant text),
-       *  getRawFinalText() returns undefined but this digest captures the last
-       *  display lines (tool results, stdout fragments) before budget exhaustion.
-       *  Capped at MAX_INTERMEDIATE_DIGEST_LINES so result artifacts stay bounded. */
+      /** F9: bounded ring buffer for intermediate findings. The downstream digest
+       * (getIntermediateFindings) slices the last 20, but the array previously grew
+       * to 1000s of entries. We keep MAX_INTERMEDIATE_DIGEST_LINES + headroom so
+       * the public API behaviour is preserved (still returns "last 20 lines"). */
+      static MAX_INTERMEDIATE_FINDINGS = 32;
       intermediateFindings = [];
       constructor(input) {
         this.input = input;
@@ -19298,9 +19417,13 @@ var init_child_pi = __esm({
           const rawTexts = extractText(rawParsed);
           if (rawTexts.length > 0) {
             this.rawTextEvents.push(...rawTexts);
+            const rawOverflow = this.rawTextEvents.length - _ChildPiLineObserver.MAX_RAW_TEXT_EVENTS;
+            if (rawOverflow > 0) this.rawTextEvents.splice(0, rawOverflow);
             const last = rawTexts[rawTexts.length - 1];
             if (last.trim().length > 0) {
               this.intermediateFindings.push(last.trim());
+              const findingsOverflow = this.intermediateFindings.length - _ChildPiLineObserver.MAX_INTERMEDIATE_FINDINGS;
+              if (findingsOverflow > 0) this.intermediateFindings.splice(0, findingsOverflow);
             }
           }
         } catch {
@@ -19321,6 +19444,8 @@ var init_child_pi = __esm({
             logInternalError("child-pi.on-stdout-line", error, `line=${compact.displayLine}`);
           }
           this.intermediateFindings.push(compact.displayLine.trim());
+          const findingsOverflow = this.intermediateFindings.length - _ChildPiLineObserver.MAX_INTERMEDIATE_FINDINGS;
+          if (findingsOverflow > 0) this.intermediateFindings.splice(0, findingsOverflow);
         }
       }
     };
@@ -19970,15 +20095,56 @@ function parseDynamicWorkflowFile(filePath, source) {
     return void 0;
   }
 }
+function workflowDirStamp(cwd) {
+  const dirs = [
+    path26.join(packageRoot(), "workflows"),
+    path26.join(userPiRoot(), "workflows"),
+    path26.join(projectCrewRoot(cwd), "workflows")
+  ];
+  let out = "";
+  for (const d of dirs) {
+    try {
+      const st = fs30.statSync(d);
+      out += `${st.mtimeMs}|`;
+    } catch {
+      out += "0|";
+    }
+  }
+  return out;
+}
+function invalidateWorkflowDiscoveryCache(cwd) {
+  if (cwd) {
+    workflowCache.delete(cwd);
+  } else {
+    workflowCache.clear();
+  }
+}
 function discoverWorkflows(cwd) {
   if (!cwd || typeof cwd !== "string") {
     return { builtin: [], user: [], project: [] };
   }
-  return {
+  const now = Date.now();
+  const stamp = workflowDirStamp(cwd);
+  const cached = workflowCache.get(cwd);
+  if (cached && cached.expiresAt > now && cached.dirStamp === stamp) {
+    return cached.result;
+  }
+  const result4 = {
     builtin: readWorkflowDir(path26.join(packageRoot(), "workflows"), "builtin"),
     user: readWorkflowDir(path26.join(userPiRoot(), "workflows"), "user"),
     project: readWorkflowDir(path26.join(projectCrewRoot(cwd), "workflows"), "project")
   };
+  workflowCache.set(cwd, {
+    result: result4,
+    expiresAt: now + WORKFLOW_DISCOVERY_TTL_MS,
+    dirStamp: stamp
+  });
+  while (workflowCache.size > WORKFLOW_DISCOVERY_MAX_ENTRIES) {
+    const oldest = workflowCache.keys().next().value;
+    if (oldest === void 0) break;
+    workflowCache.delete(oldest);
+  }
+  return result4;
 }
 function allWorkflows(discovery) {
   if (!discovery) return [];
@@ -19988,7 +20154,7 @@ function allWorkflows(discovery) {
   }
   return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
-var STEP_CONFIG_KEYS, parseOptionalInteger, parseOptionalBoolean, parseTopology;
+var STEP_CONFIG_KEYS, parseOptionalInteger, parseOptionalBoolean, parseTopology, WORKFLOW_DISCOVERY_TTL_MS, WORKFLOW_DISCOVERY_MAX_ENTRIES, workflowCache;
 var init_discover_workflows = __esm({
   "src/workflows/discover-workflows.ts"() {
     "use strict";
@@ -20033,6 +20199,9 @@ var init_discover_workflows = __esm({
       }
       return void 0;
     };
+    WORKFLOW_DISCOVERY_TTL_MS = 5e3;
+    WORKFLOW_DISCOVERY_MAX_ENTRIES = 32;
+    workflowCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -21993,6 +22162,10 @@ function parseAgentFile(filePath, source) {
         const n = Number.parseInt(frontmatter.maxTurns, 10);
         return Number.isFinite(n) && n > 0 ? n : void 0;
       })(),
+      maxTokens: (() => {
+        const n = Number.parseInt(frontmatter.maxTokens, 10);
+        return Number.isFinite(n) && n > 0 ? n : void 0;
+      })(),
       effort: frontmatter.effort === "low" || frontmatter.effort === "medium" || frontmatter.effort === "high" ? frontmatter.effort : void 0,
       disabled: frontmatter.disabled === "true" || frontmatter.enabled === "false",
       routing: triggers || useWhen || avoidWhen || cost || category ? { triggers, useWhen, avoidWhen, cost, category } : void 0
@@ -22165,7 +22338,7 @@ var init_discover_agents = __esm({
     MAX_SECURITY_LOG_ENTRIES = 1e3;
     securityEventLog = [];
     warnedForkAgents = /* @__PURE__ */ new Set();
-    DISCOVERY_CACHE_TTL_MS = 500;
+    DISCOVERY_CACHE_TTL_MS = 5e3;
     discoveryCache = /* @__PURE__ */ new Map();
     DISCOVERY_CACHE_MAX_ENTRIES = 32;
     dynamicAgents = /* @__PURE__ */ new Map();
@@ -22362,7 +22535,8 @@ var init_git = __esm({
 var discover_teams_exports = {};
 __export(discover_teams_exports, {
   allTeams: () => allTeams,
-  discoverTeams: () => discoverTeams
+  discoverTeams: () => discoverTeams,
+  invalidateTeamDiscoveryCache: () => invalidateTeamDiscoveryCache
 });
 import * as fs34 from "node:fs";
 import * as path29 from "node:path";
@@ -22446,12 +22620,48 @@ function readTeamDir(dir, source) {
   if (!fs34.existsSync(dir)) return [];
   return fs34.readdirSync(dir).filter((entry) => entry.endsWith(".team.md")).map((entry) => parseTeamFile(path29.join(dir, entry), source)).filter((team) => team !== void 0).sort((a, b) => a.name.localeCompare(b.name));
 }
+function teamDirStamp(cwd) {
+  const dirs = [path29.join(packageRoot(), "teams"), path29.join(userPiRoot(), "teams"), path29.join(projectCrewRoot(cwd), "teams")];
+  let out = "";
+  for (const d of dirs) {
+    try {
+      out += `${fs34.statSync(d).mtimeMs}|`;
+    } catch {
+      out += "0|";
+    }
+  }
+  return out;
+}
+function invalidateTeamDiscoveryCache(cwd) {
+  if (cwd) {
+    teamCache.delete(cwd);
+  } else {
+    teamCache.clear();
+  }
+}
 function discoverTeams(cwd) {
-  return {
+  const now = Date.now();
+  const stamp = teamDirStamp(cwd);
+  const cached = teamCache.get(cwd);
+  if (cached && cached.expiresAt > now && cached.dirStamp === stamp) {
+    return cached.result;
+  }
+  const result4 = {
     builtin: readTeamDir(path29.join(packageRoot(), "teams"), "builtin"),
     user: readTeamDir(path29.join(userPiRoot(), "teams"), "user"),
     project: readTeamDir(path29.join(projectCrewRoot(cwd), "teams"), "project")
   };
+  teamCache.set(cwd, {
+    result: result4,
+    expiresAt: now + TEAM_DISCOVERY_TTL_MS,
+    dirStamp: stamp
+  });
+  while (teamCache.size > TEAM_DISCOVERY_MAX_ENTRIES) {
+    const oldest = teamCache.keys().next().value;
+    if (oldest === void 0) break;
+    teamCache.delete(oldest);
+  }
+  return result4;
 }
 function allTeams(discovery) {
   if (!discovery) return [];
@@ -22461,12 +22671,16 @@ function allTeams(discovery) {
   }
   return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
 }
+var TEAM_DISCOVERY_TTL_MS, TEAM_DISCOVERY_MAX_ENTRIES, teamCache;
 var init_discover_teams = __esm({
   "src/teams/discover-teams.ts"() {
     "use strict";
     init_frontmatter();
     init_git();
     init_paths();
+    TEAM_DISCOVERY_TTL_MS = 5e3;
+    TEAM_DISCOVERY_MAX_ENTRIES = 32;
+    teamCache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -23615,7 +23829,7 @@ function readDeliveryState(manifest) {
     return { messages: {}, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
 }
-function writeDeliveryState(manifest, state) {
+function writeDeliveryState(manifest, state, options) {
   ensureRunMailbox(manifest);
   const MAX_DELIVERY_MESSAGES = 1e4;
   if (Object.keys(state.messages).length > MAX_DELIVERY_MESSAGES) {
@@ -23627,7 +23841,9 @@ function writeDeliveryState(manifest, state) {
     state.messages = Object.fromEntries(trimmed);
   }
   atomicWriteFile(deliveryFile(manifest, true), `${JSON.stringify(redactSecrets(state), null, 2)}
-`);
+`, {
+    durability: options?.durability ?? "best-effort"
+  });
 }
 function appendMailboxMessage(manifest, message) {
   if (message.taskId) ensureTaskMailbox(manifest, message.taskId);
@@ -23666,7 +23882,7 @@ function appendMailboxMessage(manifest, message) {
     const delivery = readDeliveryState(manifest);
     delivery.messages[complete.id] = complete.status;
     delivery.updatedAt = createdAt;
-    writeDeliveryState(manifest, delivery);
+    writeDeliveryState(manifest, delivery, { durability: "full" });
   });
   return complete;
 }
@@ -23710,7 +23926,7 @@ function acknowledgeMailboxMessage(manifest, messageId) {
     if (!delivery.messages[messageId]) throw new Error(`Mailbox message '${messageId}' not found.`);
     delivery.messages[messageId] = "acknowledged";
     delivery.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    writeDeliveryState(manifest, delivery);
+    writeDeliveryState(manifest, delivery, { durability: "full" });
     return delivery;
   });
 }
@@ -24164,6 +24380,11 @@ var init_intent_policy = __esm({
 import * as crypto3 from "node:crypto";
 import * as fs38 from "node:fs";
 import * as path33 from "node:path";
+function invalidateResourceCaches() {
+  invalidateAgentDiscoveryCache();
+  invalidateTeamDiscoveryCache();
+  invalidateWorkflowDiscoveryCache();
+}
 function result2(text, status = "ok", isError = false) {
   return toolResult(text, { action: "management", status }, isError);
 }
@@ -24461,6 +24682,7 @@ ${content}`);
       true
     );
   }
+  invalidateResourceCaches();
   return result2(`Created ${params.resource} '${name}' at ${filePath}.`);
 }
 function handleUpdate(params, ctx) {
@@ -24565,6 +24787,7 @@ function handleUpdate(params, ctx) {
     );
   }
   const updatedRefs = params.updateReferences ? updateReferencesForRename(ctx, params.resource, current2.name, nextName, source, false) : [];
+  invalidateResourceCaches();
   return result2(
     [
       `Updated ${params.resource} at ${nextPath}. Backup: ${backupPath}.`,
@@ -24603,6 +24826,7 @@ ${refs.map((ref2) => `- ${ref2}`).join("\n")}` : ""}`
       true
     );
   }
+  invalidateResourceCaches();
   return result2(`Deleted ${params.resource} at ${resolved.resource.filePath}. Backup: ${backupPath}.`);
 }
 var init_management = __esm({
@@ -24658,18 +24882,18 @@ function initializeProject(cwd, options = {}) {
   const teamsDir = path34.join(crewRoot, "teams");
   const workflowsDir = path34.join(crewRoot, "workflows");
   const configScope = options.configScope ?? "global";
-  const configPath2 = configScope === "project" ? path34.join(projectPiRoot(cwd), "pi-crew.json") : configScope === "global" ? configPath() : "";
+  const configPath3 = configScope === "project" ? path34.join(projectPiRoot(cwd), "pi-crew.json") : configScope === "global" ? configPath() : "";
   ensureDir(agentsDir, createdDirs);
   ensureDir(teamsDir, createdDirs);
   ensureDir(workflowsDir, createdDirs);
   ensureDir(path34.join(crewRoot, "imports"), createdDirs);
   let configCreated = false;
   let configSkipped = false;
-  if (configPath2) {
-    if (configScope === "project") ensureDir(path34.dirname(configPath2), createdDirs);
-    else fs39.mkdirSync(path34.dirname(configPath2), { recursive: true });
-    if (!fs39.existsSync(configPath2) || options.overwrite === true) {
-      fs39.writeFileSync(configPath2, `${JSON.stringify(DEFAULT_PI_CREW_CONFIG, null, 2)}
+  if (configPath3) {
+    if (configScope === "project") ensureDir(path34.dirname(configPath3), createdDirs);
+    else fs39.mkdirSync(path34.dirname(configPath3), { recursive: true });
+    if (!fs39.existsSync(configPath3) || options.overwrite === true) {
+      fs39.writeFileSync(configPath3, `${JSON.stringify(DEFAULT_PI_CREW_CONFIG, null, 2)}
 `, "utf-8");
       configCreated = true;
     } else {
@@ -24708,7 +24932,7 @@ ${missing.join("\n")}
     skippedFiles,
     gitignorePath,
     gitignoreUpdated,
-    configPath: configPath2,
+    configPath: configPath3,
     configScope,
     configCreated,
     configSkipped
@@ -44086,7 +44310,7 @@ var init_crew_hooks = __esm({
 });
 
 // src/runtime/skill-effectiveness.ts
-import { existsSync as existsSync38, mkdirSync as mkdirSync26, readFileSync as readFileSync40, writeFileSync as writeFileSync18 } from "fs";
+import { existsSync as existsSync38, mkdirSync as mkdirSync26, readFileSync as readFileSync41, writeFileSync as writeFileSync18 } from "fs";
 import { dirname as dirname24, join as join43 } from "path";
 function getSkillMetricsPath(cwd, runId) {
   return join43(projectCrewRoot(cwd), `state/runs/${runId}/skill-metrics.jsonl`);
@@ -44149,7 +44373,7 @@ function getSkillActivations(cwd, runId) {
   if (!existsSync38(path81)) {
     return [];
   }
-  const content = readFileSync40(path81, "utf-8");
+  const content = readFileSync41(path81, "utf-8");
   if (!content.trim()) {
     return [];
   }
@@ -47311,7 +47535,7 @@ var init_explain = __esm({
 });
 
 // src/runtime/goal-state-store.ts
-import { closeSync as closeSync13, existsSync as existsSync45, mkdirSync as mkdirSync29, openSync as openSync13, readdirSync as readdirSync23, readFileSync as readFileSync46, statSync as statSync29, unlinkSync as unlinkSync9 } from "node:fs";
+import { closeSync as closeSync13, existsSync as existsSync45, mkdirSync as mkdirSync29, openSync as openSync13, readdirSync as readdirSync23, readFileSync as readFileSync47, statSync as statSync31, unlinkSync as unlinkSync9 } from "node:fs";
 import { dirname as dirname26 } from "node:path";
 function resolveGoalsRoot(cwd) {
   const crewRoot = projectCrewRoot(cwd) ?? userCrewRoot();
@@ -47345,7 +47569,7 @@ var init_goal_state_store = __esm({
         const path81 = goalFilePath(this.cwd, goalId);
         try {
           if (!existsSync45(path81)) return void 0;
-          const raw = readFileSync46(path81, "utf-8");
+          const raw = readFileSync47(path81, "utf-8");
           const parsed = JSON.parse(raw);
           if (!parsed || typeof parsed !== "object" || typeof parsed.goalId !== "string") return void 0;
           return parsed;
@@ -47442,7 +47666,7 @@ var init_goal_state_store = __esm({
           const code = error.code;
           if (code !== "EEXIST") return false;
           try {
-            const stat2 = statSync29(lockPath2);
+            const stat2 = statSync31(lockPath2);
             if (Date.now() - stat2.mtimeMs > 5e3) {
               unlinkSync9(lockPath2);
               const fd = openSync13(lockPath2, "wx");
@@ -47533,7 +47757,7 @@ var init_verification_integrity = __esm({
 
 // src/runtime/workspace-lock.ts
 import { createHash as createHash7 } from "node:crypto";
-import { closeSync as closeSync14, existsSync as existsSync46, mkdirSync as mkdirSync30, openSync as openSync14, readdirSync as readdirSync24, readFileSync as readFileSync48, statSync as statSync31, unlinkSync as unlinkSync10, writeFileSync as writeFileSync23 } from "node:fs";
+import { closeSync as closeSync14, existsSync as existsSync46, mkdirSync as mkdirSync30, openSync as openSync14, readdirSync as readdirSync24, readFileSync as readFileSync49, statSync as statSync33, unlinkSync as unlinkSync10, writeFileSync as writeFileSync23 } from "node:fs";
 import * as path51 from "node:path";
 function workspaceLockPath(cwd) {
   const absCwd = path51.resolve(cwd);
@@ -47545,7 +47769,7 @@ function workspaceLockPath(cwd) {
 function readLock(lockPath2) {
   if (!existsSync46(lockPath2)) return void 0;
   try {
-    const parsed = JSON.parse(readFileSync48(lockPath2, "utf-8"));
+    const parsed = JSON.parse(readFileSync49(lockPath2, "utf-8"));
     if (!parsed || typeof parsed !== "object") return void 0;
     return parsed;
   } catch {
@@ -47584,7 +47808,7 @@ var init_workspace_lock = __esm({
     DEFAULT_HEARTBEAT_STALE_MS = 6e4;
     defaultStartTimeResolver = (pid) => {
       try {
-        const stat2 = readFileSync48(`/proc/${pid}/stat`, "utf-8");
+        const stat2 = readFileSync49(`/proc/${pid}/stat`, "utf-8");
         const lastParen = stat2.lastIndexOf(")");
         if (lastParen === -1) return void 0;
         const fieldsAfterComm = stat2.slice(lastParen + 1).trim().split(/\s+/);
@@ -51508,7 +51732,7 @@ var init_tool_progress_formatter = __esm({
 });
 
 // src/extension/registration/team-tool.ts
-import { statSync as statSync34 } from "node:fs";
+import { statSync as statSync36 } from "node:fs";
 import { Text as Text4 } from "@earendil-works/pi-tui";
 async function handleTeamTool(params, ctx) {
   if (!_cachedHandleTeamTool) {
@@ -51521,7 +51745,7 @@ function resolveCwdOverride(baseCwd, override) {
   if (!override) return { ok: true, cwd: baseCwd };
   try {
     const resolved = resolveRealContainedPath(baseCwd, override);
-    const stat2 = statSync34(resolved);
+    const stat2 = statSync36(resolved);
     if (!stat2.isDirectory())
       return {
         ok: false,
@@ -52795,7 +53019,7 @@ var init_status = __esm({
 });
 
 // src/extension/team-tool/workflow-manage.ts
-import { existsSync as existsSync58, readFileSync as readFileSync57, rmSync as rmSync16, writeFileSync as writeFileSync26 } from "node:fs";
+import { existsSync as existsSync58, readFileSync as readFileSync58, rmSync as rmSync16, writeFileSync as writeFileSync26 } from "node:fs";
 import { dirname as dirname33, join as join59 } from "node:path";
 function allowedWorkflowDirs(cwd) {
   return [join59(projectCrewRoot(cwd), "workflows"), join59(userPiRoot(), "workflows"), join59(packageRoot(), "workflows")];
@@ -52867,7 +53091,7 @@ function handleWorkflowGet(params, ctx) {
   let source = "(static workflow \u2014 no script source)";
   if (isDynamic && wf.filePath && existsSync58(wf.filePath)) {
     try {
-      source = readFileSync57(wf.filePath, "utf-8").slice(0, 8e3);
+      source = readFileSync58(wf.filePath, "utf-8").slice(0, 8e3);
     } catch (error) {
       logInternalError("workflow-manage.get", error, `filePath=${wf.filePath}`);
     }
@@ -54413,7 +54637,7 @@ function asError(error) {
   return error instanceof Error ? error : new Error(String(error));
 }
 function globToRegex(pattern) {
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
   return new RegExp(`^${escaped}$`, "i");
 }
 function isRetryable(error, policy) {
@@ -56385,6 +56609,10 @@ function readKnowledge(cwd, query) {
       knowledgeCache.delete(p);
       return "";
     }
+    if (stat2.isSymbolicLink) {
+      logInternalError("knowledge-injection.symlink", new Error(`Refusing to read symlink: ${p}`));
+      return "";
+    }
     const cacheKey2 = `${stat2.mtimeMs}:${stat2.size}`;
     if (!query || !query.goal && !query.taskText) {
       const cached = knowledgeCache.get(p);
@@ -56434,8 +56662,8 @@ Full file: ${p} -->`
 }
 function tryStat(p) {
   try {
-    const s = fs77.statSync(p);
-    return { mtimeMs: s.mtimeMs, size: s.size };
+    const s = fs77.lstatSync(p);
+    return { mtimeMs: s.mtimeMs, size: s.size, isSymbolicLink: s.isSymbolicLink() };
   } catch {
     return void 0;
   }
@@ -56466,6 +56694,7 @@ var KNOWLEDGE_FILENAME, MAX_SESSION_LOG_BYTES, CONVENTION_HEADERS, STOPWORDS, kn
 var init_knowledge_injection = __esm({
   "src/extension/knowledge-injection.ts"() {
     "use strict";
+    init_internal_error();
     init_paths();
     KNOWLEDGE_FILENAME = "knowledge.md";
     MAX_SESSION_LOG_BYTES = 5e3;
@@ -57087,32 +57316,12 @@ function persistSingleTaskUpdate(manifest, fallbackTasks, updated, checkpointPha
         try {
           currentMtime = fs80.statSync(manifest.tasksPath).mtimeMs;
         } catch {
-          currentMtime = 0;
+          return fallbackTasks;
         }
         if (currentMtime !== baseMtime) {
           baseMtime = currentMtime;
           continue;
         }
-        let recheckMtime;
-        try {
-          recheckMtime = fs80.statSync(manifest.tasksPath).mtimeMs;
-        } catch {
-          return fallbackTasks;
-        }
-        if (recheckMtime !== baseMtime) {
-          baseMtime = recheckMtime;
-          continue;
-        }
-        let preWriteMtime;
-        try {
-          preWriteMtime = fs80.statSync(manifest.tasksPath).mtimeMs;
-        } catch {
-          preWriteMtime = 0;
-        }
-        if (preWriteMtime !== baseMtime) {
-          baseMtime = preWriteMtime;
-          continue;
-        }
         break;
       }
       if (merged === void 0) {
@@ -57934,6 +58143,7 @@ async function runTeamTask(input) {
           runId: manifest.runId,
           agentId: task.id,
           artifactsRoot: manifest.artifactsRoot,
+          steeringFile: `${manifest.artifactsRoot}/steering/${task.id}.jsonl`,
           onSpawn: (pid) => {
             try {
               ({ task, tasks } = checkpointTask(manifest, tasks, task, "child-spawned", pid));
@@ -59593,8 +59803,7 @@ function checkPerTaskBudget(tasks, budgetTotal, budgetWarning, budgetAbort, fair
   const totalUsed = (usage?.input ?? 0) + (usage?.output ?? 0) + (usage?.cacheWrite ?? 0);
   const abort = totalUsed >= budgetAbort * budgetTotal;
   const warning = !abort && totalUsed >= budgetWarning * budgetTotal;
-  const remainingBudget = Math.max(0, budgetTotal - totalUsed);
-  const fairShareThreshold = remainingBudget * fairShareFraction;
+  const fairShareThreshold = budgetTotal * fairShareFraction;
   const fairShareViolators = [];
   for (const task of tasks) {
     if (!task.usage) continue;
@@ -60031,6 +60240,8 @@ async function executeTeamRun(input) {
     cleanupUsage();
     await flushEventLogBuffer();
     return result4;
+  } finally {
+    await flushEventLogBuffer();
   }
 }
 async function executeTeamRunCore(input, manifest, workflow) {
@@ -60906,122 +61117,126 @@ var init_pipeline_runner = __esm({
         const stages = [];
         let previousResults = [];
         const startTime = Date.now();
-        await appendEventAsync(eventsPath, {
-          type: "pipeline:started",
-          runId,
-          message: `Pipeline '${workflow.name}' started`,
-          data: { stages: workflow.stages.map((s) => s.name) }
-        });
-        for (let i2 = 0; i2 < workflow.stages.length; i2++) {
-          const stage = workflow.stages[i2];
-          const stageStartTime = Date.now();
-          const effectiveStopOnError = stage.stopOnError ?? workflow.stopOnError ?? this.stopOnError;
+        try {
           await appendEventAsync(eventsPath, {
-            type: "pipeline:stage_started",
+            type: "pipeline:started",
             runId,
-            message: `Stage '${stage.name}' started`,
-            data: { stageIndex: i2, stageName: stage.name }
+            message: `Pipeline '${workflow.name}' started`,
+            data: { stages: workflow.stages.map((s) => s.name) }
           });
-          try {
-            const stageContext = {
-              stageIndex: i2,
-              stageName: stage.name,
-              previousResults,
-              totalStages: workflow.stages.length,
-              runId
-            };
-            const inputs = this.resolveInputs(stage.inputs, previousResults, context);
-            const results = await this.executeStageInternal(stage, inputs, stageContext, executeStage);
-            const duration = Date.now() - stageStartTime;
-            stages.push({
-              name: stage.name,
-              status: "completed",
-              results,
-              duration,
-              fanOutItems: Array.isArray(inputs) ? inputs.length : void 0
-            });
-            previousResults = results;
+          for (let i2 = 0; i2 < workflow.stages.length; i2++) {
+            const stage = workflow.stages[i2];
+            const stageStartTime = Date.now();
+            const effectiveStopOnError = stage.stopOnError ?? workflow.stopOnError ?? this.stopOnError;
             await appendEventAsync(eventsPath, {
-              type: "pipeline:stage_completed",
+              type: "pipeline:stage_started",
               runId,
-              message: `Stage '${stage.name}' completed`,
-              data: {
+              message: `Stage '${stage.name}' started`,
+              data: { stageIndex: i2, stageName: stage.name }
+            });
+            try {
+              const stageContext = {
                 stageIndex: i2,
                 stageName: stage.name,
-                duration,
-                resultCount: results.length
-              }
-            });
-          } catch (error) {
-            const duration = Date.now() - stageStartTime;
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (effectiveStopOnError) {
-              stages.push({
-                name: stage.name,
-                status: "failed",
-                results: [],
-                error: errorMessage,
-                duration
-              });
-              await appendEventAsync(eventsPath, {
-                type: "pipeline:stage_failed",
-                runId,
-                message: `Stage '${stage.name}' failed: ${errorMessage}`,
-                data: {
-                  stageIndex: i2,
-                  stageName: stage.name,
-                  duration,
-                  error: errorMessage
-                }
-              });
-              await appendEventAsync(eventsPath, {
-                type: "pipeline:failed",
-                runId,
-                message: `Pipeline '${workflow.name}' failed at stage '${stage.name}'`,
-                data: { failedStage: stage.name, error: errorMessage }
-              });
-              return {
-                stages,
-                totalDuration: Date.now() - startTime,
-                finalResults: previousResults,
-                status: "failed"
+                previousResults,
+                totalStages: workflow.stages.length,
+                runId
               };
-            } else {
+              const inputs = this.resolveInputs(stage.inputs, previousResults, context);
+              const results = await this.executeStageInternal(stage, inputs, stageContext, executeStage);
+              const duration = Date.now() - stageStartTime;
               stages.push({
                 name: stage.name,
-                status: "failed",
-                results: [],
-                error: errorMessage,
-                duration
+                status: "completed",
+                results,
+                duration,
+                fanOutItems: Array.isArray(inputs) ? inputs.length : void 0
               });
+              previousResults = results;
               await appendEventAsync(eventsPath, {
-                type: "pipeline:stage_skipped",
+                type: "pipeline:stage_completed",
                 runId,
-                message: `Stage '${stage.name}' skipped due to error`,
+                message: `Stage '${stage.name}' completed`,
                 data: {
                   stageIndex: i2,
                   stageName: stage.name,
                   duration,
-                  error: errorMessage
+                  resultCount: results.length
                 }
               });
+            } catch (error) {
+              const duration = Date.now() - stageStartTime;
+              const errorMessage = error instanceof Error ? error.message : String(error);
+              if (effectiveStopOnError) {
+                stages.push({
+                  name: stage.name,
+                  status: "failed",
+                  results: [],
+                  error: errorMessage,
+                  duration
+                });
+                await appendEventAsync(eventsPath, {
+                  type: "pipeline:stage_failed",
+                  runId,
+                  message: `Stage '${stage.name}' failed: ${errorMessage}`,
+                  data: {
+                    stageIndex: i2,
+                    stageName: stage.name,
+                    duration,
+                    error: errorMessage
+                  }
+                });
+                await appendEventAsync(eventsPath, {
+                  type: "pipeline:failed",
+                  runId,
+                  message: `Pipeline '${workflow.name}' failed at stage '${stage.name}'`,
+                  data: { failedStage: stage.name, error: errorMessage }
+                });
+                return {
+                  stages,
+                  totalDuration: Date.now() - startTime,
+                  finalResults: previousResults,
+                  status: "failed"
+                };
+              } else {
+                stages.push({
+                  name: stage.name,
+                  status: "failed",
+                  results: [],
+                  error: errorMessage,
+                  duration
+                });
+                await appendEventAsync(eventsPath, {
+                  type: "pipeline:stage_skipped",
+                  runId,
+                  message: `Stage '${stage.name}' skipped due to error`,
+                  data: {
+                    stageIndex: i2,
+                    stageName: stage.name,
+                    duration,
+                    error: errorMessage
+                  }
+                });
+              }
             }
           }
+          await appendEventAsync(eventsPath, {
+            type: "pipeline:completed",
+            runId,
+            message: `Pipeline '${workflow.name}' completed`,
+            data: {
+              stages: stages.map((s) => ({ name: s.name, status: s.status }))
+            }
+          });
+          return {
+            stages,
+            totalDuration: Date.now() - startTime,
+            finalResults: previousResults,
+            status: stages.some((s) => s.status === "failed") ? "partial" : "completed"
+          };
+        } finally {
+          await flushEventLogBuffer();
         }
-        await appendEventAsync(eventsPath, {
-          type: "pipeline:completed",
-          runId,
-          message: `Pipeline '${workflow.name}' completed`,
-          data: {
-            stages: stages.map((s) => ({ name: s.name, status: s.status }))
-          }
-        });
-        return {
-          stages,
-          totalDuration: Date.now() - startTime,
-          finalResults: previousResults,
-          status: stages.some((s) => s.status === "failed") ? "partial" : "completed"
-        };
       }
       /**
        * Execute a single stage, handling fan-out for array inputs.
@@ -68717,7 +68932,7 @@ var init_deterministic_ast = __esm({
 });
 
 // src/runtime/dwf-state-store.ts
-import { existsSync as existsSync70, mkdirSync as mkdirSync42, readFileSync as readFileSync67, unlinkSync as unlinkSync11 } from "node:fs";
+import { existsSync as existsSync70, mkdirSync as mkdirSync42, readFileSync as readFileSync68, unlinkSync as unlinkSync11 } from "node:fs";
 import { dirname as dirname37 } from "node:path";
 var DwfStore;
 var init_dwf_state_store = __esm({
@@ -68738,7 +68953,7 @@ var init_dwf_state_store = __esm({
         const path81 = this.path;
         try {
           if (!existsSync70(path81)) return void 0;
-          const raw = readFileSync67(path81, "utf-8");
+          const raw = readFileSync68(path81, "utf-8");
           const parsed = JSON.parse(raw);
           if (!parsed || typeof parsed !== "object" || typeof parsed.runId !== "string") return void 0;
           return parsed;
@@ -69560,7 +69775,7 @@ var dynamic_workflow_runner_exports = {};
 __export(dynamic_workflow_runner_exports, {
   runDynamicWorkflow: () => runDynamicWorkflow
 });
-import { readFileSync as readFileSync68 } from "node:fs";
+import { readFileSync as readFileSync69 } from "node:fs";
 import { join as join71 } from "node:path";
 function assertStructuredCloneable(value, name) {
   try {
@@ -69585,7 +69800,7 @@ function resolveScriptPath(workflow, cwd) {
   );
 }
 async function loadWorkflowModule(scriptPath) {
-  const scriptSource = readFileSync68(scriptPath, "utf-8");
+  const scriptSource = readFileSync69(scriptPath, "utf-8");
   if (isDeterminismCheckEnabled()) {
     assertDeterministicScript(scriptSource);
   }
@@ -69708,7 +69923,7 @@ async function runDynamicWorkflow(input) {
 }
 function readFinalArtifact(artifactPath) {
   try {
-    return readFileSync68(artifactPath, "utf-8");
+    return readFileSync69(artifactPath, "utf-8");
   } catch (error) {
     logInternalError("dynamic-workflow-runner.readFinal", error, `artifactPath=${artifactPath}`);
     return `(failed to read final artifact ${artifactPath})`;
@@ -70991,6 +71206,15 @@ function handleSteer(params, ctx) {
   }
   task.pendingSteers.push(message);
   saveRunTasks(loaded.manifest, loaded.tasks);
+  try {
+    const steeringDir = `${loaded.manifest.artifactsRoot}/steering`;
+    fs91.mkdirSync(steeringDir, { recursive: true });
+    fs91.appendFileSync(
+      `${steeringDir}/${taskId}.jsonl`,
+      JSON.stringify({ type: "steer", message, ts: (/* @__PURE__ */ new Date()).toISOString() }) + "\n"
+    );
+  } catch {
+  }
   appendEvent(loaded.manifest.eventsPath, {
     type: "task.steer_queued",
     runId,
@@ -75827,7 +76051,7 @@ function teamCommandContext(ctx) {
 }
 async function openTeamSettingsOverlay(ctx) {
   if (!ctx.hasUI) return;
-  const [{ updateConfig: updateConfig2, parseConfig: parseConfig2 }, { asCrewTheme: asCrewTheme2 }, { createSettingsOverlay: createSettingsOverlay2 }] = await Promise.all([
+  const [{ updateConfig: updateConfig2, parseConfig: parseConfig2 }, { asCrewTheme: asCrewTheme3 }, { createSettingsOverlay: createSettingsOverlay2 }] = await Promise.all([
     Promise.resolve().then(() => (init_config(), config_exports)),
     Promise.resolve().then(() => (init_theme_adapter(), theme_adapter_exports)),
     Promise.resolve().then(() => (init_settings_overlay(), settings_overlay_exports))
@@ -75836,7 +76060,7 @@ async function openTeamSettingsOverlay(ctx) {
   const config = loaded.config;
   await ctx.ui.custom(
     (_tui, _theme, _keybindings, done) => {
-      const theme = asCrewTheme2(_theme);
+      const theme = asCrewTheme3(_theme);
       const { overlay } = createSettingsOverlay2(
         config,
         theme,
@@ -79776,7 +80000,7 @@ init_orphan_worker_registry();
 init_peer_dep();
 
 // src/runtime/per-write-validator.ts
-import { readFileSync as readFileSync17 } from "node:fs";
+import { readFileSync as readFileSync18 } from "node:fs";
 import { extname as pathExtname } from "node:path";
 function validateJson(content, _filePath) {
   if (content.trim() === "") return { ok: true };
@@ -79820,7 +80044,7 @@ function validateWrittenFile(filePath) {
   if (!validator) return null;
   let content;
   try {
-    content = readFileSync17(filePath, "utf-8");
+    content = readFileSync18(filePath, "utf-8");
   } catch {
     return null;
   }
@@ -81478,6 +81702,1145 @@ function registerCrewShortcuts(pi) {
 }
 var CREW_SHORTCUT_KEYS = CREW_SHORTCUTS.map((s) => s.key);
 
+// src/extension/crew-vibes/config.ts
+import { existsSync as existsSync76, mkdirSync as mkdirSync45, readFileSync as readFileSync75, writeFileSync as writeFileSync33 } from "node:fs";
+import { dirname as dirname39, join as join76 } from "node:path";
+
+// src/extension/crew-vibes/font-detect.ts
+import { existsSync as existsSync75, readFileSync as readFileSync74 } from "node:fs";
+import { homedir as homedir11, platform } from "node:os";
+import { join as join75 } from "node:path";
+function fontPath() {
+  const os16 = platform();
+  const home = homedir11();
+  if (os16 === "darwin") return join75(home, "Library", "Fonts", "crew-vibes.ttf");
+  if (os16 === "linux") return join75(home, ".local", "share", "fonts", "crew-vibes.ttf");
+  if (os16 === "win32") {
+    const local = process.env.LOCALAPPDATA ?? join75(home, "AppData", "Local");
+    return join75(local, "Microsoft", "Windows", "Fonts", "crew-vibes.ttf");
+  }
+  return "";
+}
+var _hasFontFile = null;
+function hasCrewFontFile() {
+  if (_hasFontFile !== null) return _hasFontFile;
+  const p = fontPath();
+  _hasFontFile = p !== "" && existsSync75(p);
+  return _hasFontFile;
+}
+function isWebTerminal() {
+  if (process.env.GOTTY || process.env.WEBTERM) return true;
+  if (process.env.TERM === "dumb") return true;
+  try {
+    let pid = process.pid;
+    for (let i2 = 0; i2 < 6 && pid > 1; i2++) {
+      const cgroup = readFileSync74(`/proc/${pid}/cgroup`, "utf8");
+      if (cgroup.includes("gotty") || cgroup.includes("wetty")) return true;
+      const match = cgroup.match(/\d+:.*:(.*)/);
+      const status = readFileSync74(`/proc/${pid}/status`, "utf8");
+      const ppid = status.match(/^PPid:\s+(\d+)/m);
+      pid = ppid ? Number.parseInt(ppid[1], 10) : 1;
+    }
+  } catch {
+  }
+  return false;
+}
+
+// src/extension/crew-vibes/config.ts
+var SPEED_STATUS_ID = "pi-crew-speed";
+var CAPACITY_STATUS_ID = "pi-crew-bar";
+var PROVIDER_STATUS_ID = "pi-crew-bar";
+function resolveHome() {
+  return process.env.PI_TEAMS_HOME?.trim() || process.env.HOME || process.env.USERPROFILE || "";
+}
+function configPath2() {
+  return join76(resolveHome(), ".pi", "agent", "pi-crew-vibes.json");
+}
+var DEFAULT_CONFIG2 = {
+  enabled: true,
+  speed: {
+    enabled: true,
+    footer: false,
+    indicator: true,
+    label: "tok/s",
+    renderIntervalMs: 250,
+    slidingWindowMs: 1e3,
+    minReliableDurationMs: 1e3,
+    maxDisplayTokS: 500,
+    defaultIntervalMs: 167,
+    minIntervalMs: 50,
+    maxIntervalMs: 250,
+    scale: 6e3
+  },
+  capacity: {
+    enabled: true,
+    tokenDisplay: "tokens",
+    showLabel: true,
+    refreshIntervalMs: 2e3,
+    labels: ["Orbit", "Cruise", "Warp", "Black Hole", "Supernova", "Big Bang"],
+    icons: ["\uE710", "\uE711", "\uE712", "\uE713", "\uE714", "\uE715"],
+    providerUsage: true,
+    providerRefreshMs: 3e5
+  }
+};
+var FALLBACK_CAPACITY_ICONS = [
+  "\u25CB ",
+  // ○ empty circle (lean)
+  "\u25D4 ",
+  // ◔ circle with dot (chonking)
+  "\u25D1 ",
+  // ◑ circle half filled (chonky)
+  "\u25CF ",
+  // ● filled circle (big chonk)
+  "\u2B24 ",
+  // ⬤ large filled circle (mega chonk)
+  "\u2B22 "
+  // ⬢ filled hexagon (oh lawd)
+];
+function capacityIcons() {
+  if (isWebTerminal()) return FALLBACK_CAPACITY_ICONS;
+  return hasCrewFontFile() ? DEFAULT_CONFIG2.capacity.icons : FALLBACK_CAPACITY_ICONS;
+}
+function asRecord10(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function boolFrom(raw, fallback2) {
+  return typeof raw === "boolean" ? raw : fallback2;
+}
+function stringFrom(raw, fallback2) {
+  return typeof raw === "string" ? raw : fallback2;
+}
+function positiveFrom(raw, fallback2) {
+  return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? raw : fallback2;
+}
+function sextet(raw, fallback2) {
+  if (Array.isArray(raw) && raw.length === 6 && raw.every((entry) => typeof entry === "string")) {
+    return raw;
+  }
+  return fallback2;
+}
+function tokenDisplayFrom(raw, fallback2) {
+  return raw === "off" || raw === "tokens" || raw === "percentage" ? raw : fallback2;
+}
+function normalizeSpeed(raw) {
+  const input = asRecord10(raw);
+  const speed = {
+    enabled: boolFrom(input.enabled, DEFAULT_CONFIG2.speed.enabled),
+    footer: boolFrom(input.footer, DEFAULT_CONFIG2.speed.footer),
+    indicator: boolFrom(input.indicator, DEFAULT_CONFIG2.speed.indicator),
+    label: stringFrom(input.label, DEFAULT_CONFIG2.speed.label),
+    renderIntervalMs: positiveFrom(input.renderIntervalMs, DEFAULT_CONFIG2.speed.renderIntervalMs),
+    slidingWindowMs: positiveFrom(input.slidingWindowMs, DEFAULT_CONFIG2.speed.slidingWindowMs),
+    minReliableDurationMs: positiveFrom(input.minReliableDurationMs, DEFAULT_CONFIG2.speed.minReliableDurationMs),
+    maxDisplayTokS: positiveFrom(input.maxDisplayTokS, DEFAULT_CONFIG2.speed.maxDisplayTokS),
+    defaultIntervalMs: positiveFrom(input.defaultIntervalMs, DEFAULT_CONFIG2.speed.defaultIntervalMs),
+    minIntervalMs: positiveFrom(input.minIntervalMs, DEFAULT_CONFIG2.speed.minIntervalMs),
+    maxIntervalMs: positiveFrom(input.maxIntervalMs, DEFAULT_CONFIG2.speed.maxIntervalMs),
+    scale: positiveFrom(input.scale, DEFAULT_CONFIG2.speed.scale)
+  };
+  if (speed.minIntervalMs > speed.maxIntervalMs) {
+    speed.minIntervalMs = DEFAULT_CONFIG2.speed.minIntervalMs;
+    speed.maxIntervalMs = DEFAULT_CONFIG2.speed.maxIntervalMs;
+  }
+  return speed;
+}
+function normalizeCapacity(raw) {
+  const input = asRecord10(raw);
+  return {
+    enabled: boolFrom(input.enabled, DEFAULT_CONFIG2.capacity.enabled),
+    tokenDisplay: tokenDisplayFrom(input.tokenDisplay, DEFAULT_CONFIG2.capacity.tokenDisplay),
+    showLabel: boolFrom(input.showLabel, DEFAULT_CONFIG2.capacity.showLabel),
+    refreshIntervalMs: positiveFrom(input.refreshIntervalMs, DEFAULT_CONFIG2.capacity.refreshIntervalMs),
+    labels: sextet(input.labels, DEFAULT_CONFIG2.capacity.labels),
+    icons: sextet(input.icons, DEFAULT_CONFIG2.capacity.icons),
+    providerUsage: boolFrom(input.providerUsage, DEFAULT_CONFIG2.capacity.providerUsage),
+    providerRefreshMs: positiveFrom(input.providerRefreshMs, DEFAULT_CONFIG2.capacity.providerRefreshMs)
+  };
+}
+function normalizeConfig(raw) {
+  const input = asRecord10(raw);
+  return {
+    enabled: boolFrom(input.enabled, DEFAULT_CONFIG2.enabled),
+    speed: normalizeSpeed(input.speed),
+    capacity: normalizeCapacity(input.capacity)
+  };
+}
+function loadConfig2() {
+  try {
+    const path81 = configPath2();
+    if (!existsSync76(path81)) return normalizeConfig(void 0);
+    return normalizeConfig(JSON.parse(readFileSync75(path81, "utf8")));
+  } catch {
+    return normalizeConfig(void 0);
+  }
+}
+function saveConfig(config) {
+  const path81 = configPath2();
+  mkdirSync45(dirname39(path81), { recursive: true });
+  writeFileSync33(path81, `${JSON.stringify(normalizeConfig(config), null, 2)}
+`);
+}
+
+// src/extension/crew-vibes/provider-usage.ts
+import { readFileSync as readFileSync76 } from "node:fs";
+import { homedir as homedir12 } from "node:os";
+import { join as join77 } from "node:path";
+function withTimeout(ms, fn) {
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), ms);
+  return fn(controller.signal).finally(() => clearTimeout(timeoutId));
+}
+function piAuthPath() {
+  return join77(homedir12(), ".pi", "agent", "auth.json");
+}
+function loadAnthropicToken() {
+  const envToken = process.env.ANTHROPIC_OAUTH_TOKEN?.trim();
+  if (envToken) return envToken;
+  try {
+    const data2 = JSON.parse(readFileSync76(piAuthPath(), "utf8"));
+    const token = data2.anthropic?.access;
+    return typeof token === "string" && token.length > 0 ? token : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function loadZaiToken() {
+  const envKey = process.env.ZAI_API_KEY?.trim() || process.env.Z_AI_API_KEY?.trim();
+  if (envKey) return envKey;
+  try {
+    const data2 = JSON.parse(readFileSync76(piAuthPath(), "utf8"));
+    const key = data2["z-ai"]?.access || data2["z-ai"]?.key || data2.zai?.access || data2.zai?.key;
+    return typeof key === "string" && key.length > 0 ? key : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function loadMinimaxToken() {
+  const envKey = process.env.MINIMAX_API_KEY?.trim();
+  if (envKey) return envKey;
+  try {
+    const data2 = JSON.parse(readFileSync76(piAuthPath(), "utf8"));
+    const key = data2.minimax?.key;
+    return typeof key === "string" && key.length > 0 ? key : void 0;
+  } catch {
+    return void 0;
+  }
+}
+var COPILOT_TOKEN_KEYS = ["oauth_token", "user_token", "github_token", "token"];
+function tokenFromHostEntry(entry) {
+  if (!entry) return void 0;
+  for (const key of COPILOT_TOKEN_KEYS) {
+    const value = entry[key];
+    if (typeof value === "string" && value.length > 0) return value;
+  }
+  return void 0;
+}
+function loadLegacyCopilotToken() {
+  const configHome = process.env.XDG_CONFIG_HOME?.trim() || join77(homedir12(), ".config");
+  const candidates = [join77(configHome, "github-copilot", "hosts.json"), join77(homedir12(), ".github-copilot", "hosts.json")];
+  for (const hostsPath of candidates) {
+    try {
+      const data2 = JSON.parse(readFileSync76(hostsPath, "utf8"));
+      if (!data2 || typeof data2 !== "object") continue;
+      const normalized = {};
+      for (const [host, entry] of Object.entries(data2)) {
+        normalized[host.toLowerCase()] = entry;
+      }
+      const preferred = tokenFromHostEntry(normalized["github.com"]) ?? tokenFromHostEntry(normalized["api.github.com"]);
+      if (preferred) return preferred;
+      for (const entry of Object.values(normalized)) {
+        const token = tokenFromHostEntry(entry);
+        if (token) return token;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+function loadCopilotToken() {
+  const envToken = (process.env.COPILOT_GITHUB_TOKEN || process.env.GH_TOKEN || process.env.GITHUB_TOKEN || "").trim();
+  if (envToken) return envToken;
+  try {
+    const data2 = JSON.parse(readFileSync76(piAuthPath(), "utf8"));
+    const piToken = data2["github-copilot"]?.refresh || data2["github-copilot"]?.access;
+    if (typeof piToken === "string" && piToken.length > 0) return piToken;
+  } catch {
+  }
+  return loadLegacyCopilotToken();
+}
+async function fetchAnthropicUsage(token) {
+  const data2 = await withTimeout(1e4, async (signal) => {
+    const res = await fetch("https://api.anthropic.com/api/oauth/usage", {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "anthropic-beta": "oauth-2025-04-20"
+      },
+      signal
+    });
+    if (!res.ok) throw new Error(`anthropic usage HTTP ${res.status}`);
+    return await res.json();
+  });
+  return {
+    fiveHourPercent: data2.five_hour?.utilization ?? 0,
+    weeklyPercent: data2.seven_day?.utilization ?? 0,
+    fiveHourResetAt: data2.five_hour?.resets_at ?? null,
+    weeklyResetAt: data2.seven_day?.resets_at ?? null
+  };
+}
+async function fetchCopilotMonthlyPercent(token) {
+  const data2 = await withTimeout(1e4, async (signal) => {
+    const res = await fetch("https://api.github.com/copilot_internal/user", {
+      headers: {
+        Authorization: `token ${token}`,
+        "Editor-Version": "vscode/1.96.2",
+        "User-Agent": "GitHubCopilotChat/0.26.7",
+        "X-Github-Api-Version": "2025-04-01",
+        Accept: "application/json"
+      },
+      signal
+    });
+    if (!res.ok) throw new Error(`copilot user HTTP ${res.status}`);
+    return await res.json();
+  });
+  const percentRemaining = data2.quota_snapshots?.premium_interactions?.percent_remaining;
+  if (typeof percentRemaining !== "number") return void 0;
+  return Math.max(0, 100 - percentRemaining);
+}
+async function fetchZaiUsage(token) {
+  const data2 = await withTimeout(1e4, async (signal) => {
+    const res = await fetch("https://api.z.ai/api/monitor/usage/quota/limit", {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json"
+      },
+      signal
+    });
+    if (!res.ok) throw new Error(`z.ai usage HTTP ${res.status}`);
+    return await res.json();
+  });
+  if (!data2.success || data2.code !== 200) throw new Error(data2.msg || "z.ai API error");
+  const limits = data2.data?.limits ?? [];
+  let tokensPercent = 0;
+  let monthlyPercent = 0;
+  let tokensResetAt = null;
+  let monthlyResetAt = null;
+  for (const limit of limits) {
+    const pct = limit.percentage ?? 0;
+    const resetIso = typeof limit.nextResetTime === "number" ? new Date(limit.nextResetTime).toISOString() : typeof limit.nextResetTime === "string" ? limit.nextResetTime : null;
+    if (limit.type === "TOKENS_LIMIT") {
+      tokensPercent = pct;
+      tokensResetAt = resetIso;
+    } else if (limit.type === "TIME_LIMIT") {
+      monthlyPercent = pct;
+      monthlyResetAt = resetIso;
+    }
+  }
+  return {
+    providerName: "z.ai",
+    fiveHourPercent: tokensPercent,
+    fiveHourResetAt: tokensResetAt,
+    weeklyPercent: monthlyPercent,
+    weeklyResetAt: monthlyResetAt
+  };
+}
+var cachedUsage = null;
+var cachedAt = 0;
+function clearProviderUsageCache() {
+  cachedUsage = null;
+  cachedAt = 0;
+}
+async function fetchMinimaxUsage(token) {
+  const data2 = await withTimeout(1e4, async (signal) => {
+    const res = await fetch("https://www.minimax.io/v1/token_plan/remains", {
+      headers: { Authorization: `Bearer ${token}`, Accept: "application/json" },
+      signal
+    });
+    if (!res.ok) throw new Error(`minimax usage HTTP ${res.status}`);
+    return await res.json();
+  });
+  if (data2.base_resp?.status_code !== 0) throw new Error(data2.base_resp?.status_msg || "minimax API error");
+  const models = data2.model_remains ?? [];
+  const general = models.find((m) => m.model_name === "general") ?? models[0];
+  if (!general) throw new Error("minimax: no model data");
+  const intervalUsed = 100 - (general.current_interval_remaining_percent ?? 100);
+  const weeklyUsed = 100 - (general.current_weekly_remaining_percent ?? 100);
+  const intervalReset = typeof general.end_time === "number" ? new Date(general.end_time).toISOString() : null;
+  const weeklyReset = typeof general.weekly_end_time === "number" ? new Date(general.weekly_end_time).toISOString() : null;
+  return {
+    providerName: "Minimax",
+    fiveHourPercent: intervalUsed,
+    fiveHourResetAt: intervalReset,
+    weeklyPercent: weeklyUsed,
+    weeklyResetAt: weeklyReset
+  };
+}
+var QUOTA_PROVIDERS = /* @__PURE__ */ new Set(["anthropic", "minimax", "minimax-cn", "zai", "github-copilot"]);
+async function fetchForProvider(provider) {
+  switch (provider) {
+    case "anthropic": {
+      const token = loadAnthropicToken();
+      if (!token) return null;
+      const base = await fetchAnthropicUsage(token);
+      return { providerName: "Claude", ...base };
+    }
+    case "minimax":
+    case "minimax-cn": {
+      const token = loadMinimaxToken();
+      if (!token) return null;
+      return await fetchMinimaxUsage(token);
+    }
+    case "zai": {
+      const token = loadZaiToken();
+      if (!token) return null;
+      const usage = await fetchZaiUsage(token);
+      usage.providerName = "z.ai";
+      return usage;
+    }
+    case "github-copilot": {
+      const token = loadCopilotToken();
+      if (!token) return null;
+      const pct = await fetchCopilotMonthlyPercent(token);
+      if (pct === void 0) return null;
+      return {
+        providerName: "Copilot",
+        fiveHourPercent: 0,
+        fiveHourResetAt: null,
+        weeklyPercent: pct,
+        weeklyResetAt: null,
+        copilotMonthlyPercent: pct
+      };
+    }
+    default:
+      return null;
+  }
+}
+async function fetchProviderUsage(maxAgeMs = 3e5, provider) {
+  if (!provider || !QUOTA_PROVIDERS.has(provider)) {
+    cachedUsage = null;
+    return null;
+  }
+  if (cachedUsage !== null && Date.now() - cachedAt < maxAgeMs) {
+    return cachedUsage;
+  }
+  try {
+    const usage = await fetchForProvider(provider);
+    if (usage) {
+      cachedUsage = usage;
+      cachedAt = Date.now();
+    }
+    return usage;
+  } catch {
+    return null;
+  }
+}
+
+// src/extension/crew-vibes/figures.ts
+var BRAILLE_FRAMES = [
+  "\u280B ",
+  // ⠋
+  "\u2819 ",
+  // ⠙
+  "\u2839 ",
+  // ⠹
+  "\u2838 ",
+  // ⠸
+  "\u283C ",
+  // ⠼
+  "\u2834 ",
+  // ⠴
+  "\u2826 ",
+  // ⠦
+  "\u2827 ",
+  // ⠧
+  "\u2807 ",
+  // ⠇
+  "\u280F "
+  // ⠏
+];
+var PUA_CREW_FRAMES = [
+  "\uE700 ",
+  "\uE701 ",
+  "\uE702 ",
+  "\uE703 ",
+  "\uE704 ",
+  "\uE705 ",
+  "\uE706 ",
+  "\uE707 ",
+  "\uE708 ",
+  "\uE709 ",
+  "\uE70A ",
+  "\uE70B ",
+  "\uE70C ",
+  "\uE70D ",
+  "\uE70E ",
+  "\uE70F "
+];
+function crewFrames(style = "pua") {
+  if (style === "pua" && isWebTerminal()) return BRAILLE_FRAMES;
+  return style === "pua" ? PUA_CREW_FRAMES : BRAILLE_FRAMES;
+}
+function intervalForSpeed(config, speed) {
+  if (speed === null || !Number.isFinite(speed) || speed <= 0) return config.defaultIntervalMs;
+  return Math.max(config.minIntervalMs, Math.min(config.maxIntervalMs, Math.round(config.scale / speed)));
+}
+function capacityIndex(percent, levels = 6) {
+  if (percent === null || percent === void 0 || !Number.isFinite(percent)) return 0;
+  return Math.max(0, Math.min(levels - 1, Math.floor(Math.max(0, Math.min(100, percent)) / 100 * levels)));
+}
+function isDangerStage(index, levels) {
+  return index >= Math.max(0, levels - 2);
+}
+
+// src/extension/crew-vibes/render.ts
+function formatCount(value) {
+  if (value < 1e3) return value.toString();
+  if (value < 1e4) return `${(value / 1e3).toFixed(1)}k`;
+  if (value < 1e6) return `${Math.round(value / 1e3)}k`;
+  if (value < 1e7) return `${(value / 1e6).toFixed(1)}M`;
+  return `${Math.round(value / 1e6)}M`;
+}
+function asCrewTheme2(theme) {
+  if (theme && typeof theme === "object" && typeof theme.fg === "function") {
+    return theme;
+  }
+  return void 0;
+}
+function getCapacityUsage(ctx) {
+  const fn = ctx.getContextUsage;
+  const usage = typeof fn === "function" ? fn.call(ctx) : null;
+  return {
+    tokens: typeof usage?.tokens === "number" && Number.isFinite(usage.tokens) ? usage.tokens : null,
+    percent: typeof usage?.percent === "number" && Number.isFinite(usage.percent) ? usage.percent : null
+  };
+}
+function formatSpeed(config, speed) {
+  return speed === null ? `-- ${config.label}` : `${speed.toFixed(1)} ${config.label}`;
+}
+function renderSpeedFooter(theme, config, speed) {
+  const value = speed === null ? "--" : speed.toFixed(1);
+  const valueTone = speed === null ? "dim" : "accent";
+  const styled = theme ? `${theme.fg(valueTone, value)} ${theme.fg("dim", config.label)}` : `${value} ${config.label}`;
+  return styled;
+}
+function renderWorkingMessage(theme, config, speed) {
+  const left = "Working";
+  const speedText = theme ? `${theme.fg(speed === null ? "dim" : "accent", speed === null ? "--" : speed.toFixed(1))} ${theme.fg("dim", config.label)}` : `${speed === null ? "--" : speed.toFixed(1)} ${config.label}`;
+  return theme ? `${theme.fg("muted", left)}  ${speedText}` : `${left}  ${speedText}`;
+}
+function crewIndicatorFrames(theme) {
+  const frames = crewFrames();
+  if (!theme) return [...frames];
+  return frames.map((frame) => theme.fg("accent", frame));
+}
+function formatCapacityPrefix(config, usage) {
+  const display = config.tokenDisplay;
+  if (display === "off") return "";
+  if (display === "percentage") {
+    return `${usage.percent === null ? "?" : Math.round(Math.max(0, Math.min(999, usage.percent)))}% `;
+  }
+  return `${usage.tokens === null ? "?" : formatCount(usage.tokens)} `;
+}
+function colorStage(theme, index, levels, text) {
+  if (!theme || text.length === 0) return text;
+  return theme.fg(isDangerStage(index, levels) ? "error" : "success", text);
+}
+function renderCapacity(theme, config, usage) {
+  const icons = capacityIcons();
+  const levels = icons.length;
+  const index = capacityIndex(usage.percent, levels);
+  const icon = icons[index] ?? icons[0];
+  const label = config.labels[index] ?? config.labels[0];
+  const prefix = theme ? theme.fg("muted", formatCapacityPrefix(config, usage)) : formatCapacityPrefix(config, usage);
+  const coloredIcon = colorStage(theme, index, levels, icon);
+  const afterIcon = config.showLabel ? `  ${colorStage(theme, index, levels, label)}` : " ";
+  return `${prefix}${coloredIcon}${afterIcon}`;
+}
+function setSpeedStatus(ctx, config, text) {
+  if (!ctx?.hasUI) return;
+  if (!config.enabled || !config.speed.enabled || !config.speed.footer) {
+    ctx.ui.setStatus(SPEED_STATUS_ID, void 0);
+    return;
+  }
+  ctx.ui.setStatus(SPEED_STATUS_ID, text);
+}
+function setCapacityStatus(ctx, config, text) {
+  if (!ctx?.hasUI) return;
+  if (!config.enabled || !config.capacity.enabled) {
+    ctx.ui.setStatus(CAPACITY_STATUS_ID, void 0);
+    return;
+  }
+  ctx.ui.setStatus(CAPACITY_STATUS_ID, text);
+}
+function clearVibesStatus(ctx) {
+  if (!ctx?.hasUI) return;
+  ctx.ui.setStatus(SPEED_STATUS_ID, void 0);
+  ctx.ui.setStatus(CAPACITY_STATUS_ID, void 0);
+  ctx.ui.setStatus(PROVIDER_STATUS_ID, void 0);
+  if (ctx.ui.setWorkingIndicator) ctx.ui.setWorkingIndicator();
+  if (ctx.ui.setWorkingMessage) ctx.ui.setWorkingMessage();
+}
+function formatResetTimer(resetAt) {
+  if (!resetAt) return null;
+  const diffMs = new Date(resetAt).getTime() - Date.now();
+  if (diffMs < 0) return null;
+  const mins = Math.floor(diffMs / 6e4);
+  if (mins < 60) return `${mins}m`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 48) {
+    const remMins = mins % 60;
+    return remMins > 0 ? `${hours}h${remMins}m` : `${hours}h`;
+  }
+  const days = Math.floor(hours / 24);
+  const remHours = hours % 24;
+  return remHours > 0 ? `${days}d${remHours}h` : `${days}d`;
+}
+function renderBar(percent, width = 8) {
+  const clamped = Math.max(0, Math.min(100, percent));
+  const filled = Math.round(clamped / 100 * width);
+  return `${"\u2501".repeat(filled)}${"\u2504".repeat(width - filled)}`;
+}
+function renderProviderUsage(theme, usage) {
+  if (!usage) return void 0;
+  const parts = [];
+  if (usage.providerName) {
+    const nameText = usage.providerName;
+    parts.push(theme ? theme.fg("muted", nameText) : nameText);
+  }
+  const fiveHourBar = renderBar(usage.fiveHourPercent);
+  const fiveHourRounded = Math.round(usage.fiveHourPercent);
+  const fiveHourReset = formatResetTimer(usage.fiveHourResetAt);
+  const fiveHourText = `5h ${fiveHourBar} ${fiveHourRounded}%${fiveHourReset ? " " + fiveHourReset : ""}`;
+  const fiveHourColor = usage.fiveHourPercent >= 80 ? "error" : "accent";
+  parts.push(theme ? theme.fg(fiveHourColor, fiveHourText) : fiveHourText);
+  const weeklyBar = renderBar(usage.weeklyPercent);
+  const weeklyRounded = Math.round(usage.weeklyPercent);
+  const weeklyReset = formatResetTimer(usage.weeklyResetAt);
+  const weeklyText = `Wk ${weeklyBar} ${weeklyRounded}%${weeklyReset ? " " + weeklyReset : ""}`;
+  parts.push(theme ? theme.fg("dim", weeklyText) : weeklyText);
+  if (typeof usage.copilotMonthlyPercent === "number" && Number.isFinite(usage.copilotMonthlyPercent)) {
+    const monthlyRounded = Math.round(usage.copilotMonthlyPercent);
+    const monthlyText = `Mo: ${monthlyRounded}%`;
+    parts.push(theme ? theme.fg("dim", monthlyText) : monthlyText);
+  }
+  return parts.join(" ");
+}
+
+// src/extension/crew-vibes/speed.ts
+var COMPACTION_THRESHOLD = 5e3;
+function estimateTokensFromDelta(text) {
+  if (!text) return 0;
+  const matches = text.match(/\w+|[^\s\w]/g);
+  return matches ? matches.length : 0;
+}
+var TokenSpeedEngine = class {
+  _isStreaming = false;
+  _tokenCount = 0;
+  _startTime = 0;
+  _endTime = 0;
+  _events = [];
+  _windowStartIndex = 0;
+  _lastStableTokS = 0;
+  _lastUsageOutput = 0;
+  _config;
+  constructor(config) {
+    this._config = config;
+  }
+  updateConfig(config) {
+    this._config = config;
+  }
+  get isStreaming() {
+    return this._isStreaming;
+  }
+  get tokenCount() {
+    return this._tokenCount;
+  }
+  get elapsedMs() {
+    if (this._startTime === 0) return 0;
+    return this._isStreaming ? Date.now() - this._startTime : this._endTime - this._startTime;
+  }
+  get avgTokS() {
+    const elapsedSec = this.elapsedMs / 1e3;
+    if (elapsedSec <= 0) return 0;
+    return this._tokenCount / elapsedSec;
+  }
+  sanitizeTokS(value, durationMs = this.elapsedMs) {
+    if (value === null || !Number.isFinite(value) || value <= 0) return null;
+    if (durationMs < this._config.minReliableDurationMs) return null;
+    if (value > this._config.maxDisplayTokS) return null;
+    return value;
+  }
+  get tokS() {
+    const candidate = this.rawTokS;
+    const stable = this.sanitizeTokS(candidate);
+    if (stable !== null) this._lastStableTokS = stable;
+    return this._lastStableTokS;
+  }
+  get rawTokS() {
+    if (this.elapsedMs < this._config.slidingWindowMs) return this.avgTokS;
+    if (!this._isStreaming) return this.avgTokS;
+    const now = Date.now();
+    const windowStart = now - this._config.slidingWindowMs;
+    while (this._windowStartIndex < this._events.length && this._events[this._windowStartIndex].time < windowStart) {
+      this._windowStartIndex++;
+    }
+    if (this._windowStartIndex >= this._events.length) return this.avgTokS;
+    let windowTokenCount = 0;
+    for (let i2 = this._windowStartIndex; i2 < this._events.length; i2++) {
+      windowTokenCount += this._events[i2].tokens;
+    }
+    if (windowTokenCount === 0) return this.avgTokS;
+    const windowDuration = (now - this._events[this._windowStartIndex].time) / 1e3;
+    if (windowDuration <= 0) return 0;
+    return windowTokenCount / windowDuration;
+  }
+  start() {
+    this._tokenCount = 0;
+    this._isStreaming = true;
+    this._startTime = Date.now();
+    this._endTime = this._startTime;
+    this._events = [];
+    this._windowStartIndex = 0;
+    this._lastStableTokS = 0;
+    this._lastUsageOutput = 0;
+  }
+  stop() {
+    this._isStreaming = false;
+    this._endTime = Date.now();
+    this._events = [];
+    this._windowStartIndex = 0;
+  }
+  recordDelta(delta, usageOutput) {
+    if (!this._isStreaming) return;
+    if (usageOutput !== void 0 && usageOutput > 0) {
+      const increment = usageOutput - this._lastUsageOutput;
+      this._lastUsageOutput = usageOutput;
+      this.recordTokens(Math.max(0, increment));
+      return;
+    }
+    this.recordTokens(estimateTokensFromDelta(delta));
+  }
+  reconcileTotal(tokens) {
+    if (tokens > 0) this._tokenCount = tokens;
+  }
+  recordTokens(tokens) {
+    if (!this._isStreaming || tokens <= 0) return;
+    this._tokenCount += tokens;
+    this._events.push({ time: Date.now(), tokens });
+    if (this._windowStartIndex >= COMPACTION_THRESHOLD) this.compact();
+  }
+  compact() {
+    if (this._windowStartIndex === 0) return;
+    this._events = this._events.slice(this._windowStartIndex);
+    this._windowStartIndex = 0;
+  }
+};
+function isSuccessfulStop(stopReason) {
+  return stopReason !== "error" && stopReason !== "aborted";
+}
+var SpeedTracker = class {
+  engine;
+  lastStableTokS = null;
+  sessionOutputTokens = 0;
+  sessionDurationMs = 0;
+  constructor(config) {
+    this.engine = new TokenSpeedEngine(config);
+  }
+  updateConfig(config) {
+    this.engine.updateConfig(config);
+  }
+  get isStreaming() {
+    return this.engine.isStreaming;
+  }
+  get lastTokS() {
+    return this.lastStableTokS;
+  }
+  resetSession() {
+    this.sessionOutputTokens = 0;
+    this.sessionDurationMs = 0;
+  }
+  startMessage() {
+    this.engine.start();
+  }
+  recordDelta(delta, usageOutput) {
+    this.engine.recordDelta(delta, usageOutput);
+  }
+  stopMessage() {
+    if (this.engine.isStreaming) this.engine.stop();
+  }
+  liveTokS() {
+    const speed = this.engine.tokS;
+    return speed > 0 ? speed : this.lastStableTokS;
+  }
+  sessionAvgTokS() {
+    return this.sessionDurationMs > 0 ? this.sessionOutputTokens / (this.sessionDurationMs / 1e3) : null;
+  }
+  finishMessage(outputTokens, stopReason) {
+    if (!this.engine.isStreaming) return null;
+    this.engine.reconcileTotal(outputTokens);
+    const durationMs = this.engine.elapsedMs;
+    const tokens = this.engine.tokenCount;
+    const rawAvgTokS = durationMs > 0 ? tokens / (durationMs / 1e3) : null;
+    const tokS = this.engine.sanitizeTokS(rawAvgTokS, durationMs);
+    this.lastStableTokS = tokS;
+    this.engine.stop();
+    if (tokS !== null && isSuccessfulStop(stopReason)) {
+      this.sessionOutputTokens += tokens;
+      this.sessionDurationMs += durationMs;
+    }
+    return { outputTokens: tokens, durationMs, tokS };
+  }
+};
+var SpeedAnimator = class {
+  from = null;
+  target = null;
+  startedAt = 0;
+  durationMs;
+  constructor(durationMs) {
+    this.durationMs = durationMs;
+  }
+  updateDuration(durationMs) {
+    this.durationMs = durationMs;
+  }
+  reset(value = null, now = Date.now()) {
+    this.from = value;
+    this.target = value;
+    this.startedAt = now;
+  }
+  setTarget(target, now = Date.now()) {
+    if (target === null) {
+      this.reset(null, now);
+      return null;
+    }
+    const current2 = this.value(now);
+    if (current2 === null) {
+      this.reset(target, now);
+      return target;
+    }
+    if (this.target !== null && Math.abs(target - this.target) < 0.05) return current2;
+    this.from = current2;
+    this.target = target;
+    this.startedAt = now;
+    return current2;
+  }
+  value(now = Date.now()) {
+    if (this.target === null) return null;
+    if (this.from === null || this.durationMs <= 0) return this.target;
+    const progress = Math.max(0, Math.min(1, (now - this.startedAt) / this.durationMs));
+    if (progress >= 1) {
+      this.from = this.target;
+      return this.target;
+    }
+    return this.from + (this.target - this.from) * progress;
+  }
+  isAnimating(now = Date.now()) {
+    return this.target !== null && this.from !== null && Math.abs(this.target - this.from) >= 0.05 && now - this.startedAt < this.durationMs;
+  }
+};
+
+// src/extension/crew-vibes/index.ts
+function isAssistantMessage(message) {
+  return typeof message === "object" && message !== null && message.role === "assistant";
+}
+function assistantUsageOutput(message) {
+  const usage = message.usage;
+  const output = usage?.output;
+  return typeof output === "number" && Number.isFinite(output) ? output : void 0;
+}
+function assistantStopReason(message) {
+  const reason = message.stopReason;
+  return typeof reason === "string" ? reason : void 0;
+}
+function assistantEventType(event) {
+  return typeof event.type === "string" ? event.type : void 0;
+}
+function registerCrewVibes(pi) {
+  let config = loadConfig2();
+  let lastRenderedAt = 0;
+  let currentIntervalMs = 0;
+  const speedTracker = new SpeedTracker(config.speed);
+  const footerAnimator = new SpeedAnimator(config.speed.renderIntervalMs);
+  let liveTimer;
+  let footerTimer;
+  let capacityTimer;
+  let providerTimer;
+  let lastProviderText;
+  let currentProvider;
+  function visibleLen(text) {
+    return text.replace(/\x1b\[[0-9;]*m/g, "").length;
+  }
+  function spreadLine(left, right) {
+    const cols = process.stdout.columns || 120;
+    const padding = Math.max(2, cols - visibleLen(left) - visibleLen(right));
+    return left + "\xA0".repeat(padding) + right;
+  }
+  function themeOf(ctx) {
+    return asCrewTheme2(ctx.hasUI ? ctx.ui.theme : void 0);
+  }
+  function publishCapacity(ctx) {
+    if (!ctx?.hasUI) return;
+    if (!config.enabled || !config.capacity.enabled) {
+      setCapacityStatus(ctx, config, void 0);
+      return;
+    }
+    const capText = renderCapacity(themeOf(ctx), config.capacity, getCapacityUsage(ctx));
+    const combined = lastProviderText ? spreadLine(capText, lastProviderText) : capText;
+    setCapacityStatus(ctx, config, combined);
+  }
+  function publishSpeedFooter(ctx, speed = footerAnimator.value()) {
+    if (!config.enabled || !config.speed.enabled || !config.speed.footer) {
+      setSpeedStatus(ctx, config, void 0);
+      return;
+    }
+    setSpeedStatus(ctx, config, renderSpeedFooter(themeOf(ctx), config.speed, speed));
+  }
+  function applyIndicator(ctx, speed, force = false) {
+    if (!ctx.hasUI || !ctx.ui.setWorkingIndicator) return;
+    if (!config.enabled || !config.speed.enabled || !config.speed.indicator) {
+      ctx.ui.setWorkingIndicator();
+      return;
+    }
+    const next = intervalForSpeed(config.speed, speed);
+    if (!force && Math.abs(next - currentIntervalMs) < 10) return;
+    ctx.ui.setWorkingIndicator({
+      frames: crewIndicatorFrames(themeOf(ctx)),
+      intervalMs: next
+    });
+    currentIntervalMs = next;
+  }
+  function renderWorking(ctx, speed) {
+    if (!config.enabled || !config.speed.enabled || !ctx.hasUI) return;
+    ctx.ui.setWorkingMessage(renderWorkingMessage(themeOf(ctx), config.speed, speed));
+  }
+  function stopLiveTimer() {
+    if (!liveTimer) return;
+    clearInterval(liveTimer);
+    liveTimer = void 0;
+  }
+  function stopFooterTimer() {
+    if (!footerTimer) return;
+    clearInterval(footerTimer);
+    footerTimer = void 0;
+  }
+  function stopCapacityTimer() {
+    if (!capacityTimer) return;
+    clearInterval(capacityTimer);
+    capacityTimer = void 0;
+  }
+  function stopProviderTimer() {
+    if (!providerTimer) return;
+    clearInterval(providerTimer);
+    providerTimer = void 0;
+  }
+  function startLiveTimer(ctx) {
+    if (liveTimer || !ctx.hasUI) return;
+    liveTimer = setInterval(() => {
+      if (!config.enabled || !config.speed.enabled || !speedTracker.isStreaming) {
+        stopLiveTimer();
+        return;
+      }
+      const speed = speedTracker.liveTokS();
+      applyIndicator(ctx, speed);
+      renderWorking(ctx, speed);
+    }, config.speed.renderIntervalMs);
+    liveTimer.unref?.();
+  }
+  function startFooterTimer(ctx) {
+    if (footerTimer || !ctx.hasUI) return;
+    footerTimer = setInterval(() => {
+      if (!config.enabled || !config.speed.enabled) {
+        stopFooterTimer();
+        return;
+      }
+      publishSpeedFooter(ctx);
+      if (!footerAnimator.isAnimating()) stopFooterTimer();
+    }, config.speed.renderIntervalMs);
+    footerTimer.unref?.();
+  }
+  function startCapacityTimer(ctx) {
+    if (capacityTimer) return;
+    const interval = Math.max(250, config.capacity.refreshIntervalMs);
+    capacityTimer = setInterval(() => publishCapacity(ctx), interval);
+    capacityTimer.unref?.();
+  }
+  function startProviderTimer(ctx) {
+    if (providerTimer) return;
+    if (!config.capacity.providerUsage) return;
+    const interval = Math.max(1e4, config.capacity.providerRefreshMs);
+    async function tick() {
+      if (!config.enabled || !config.capacity.providerUsage) {
+        stopProviderTimer();
+        return;
+      }
+      try {
+        const usage = await fetchProviderUsage(config.capacity.providerRefreshMs, currentProvider);
+        lastProviderText = renderProviderUsage(themeOf(ctx), usage);
+        publishCapacity(ctx);
+      } catch {
+        lastProviderText = void 0;
+        publishCapacity(ctx);
+      }
+    }
+    tick();
+    providerTimer = setInterval(tick, interval);
+    providerTimer.unref?.();
+  }
+  function resetWorking(ctx) {
+    applyIndicator(ctx, null, true);
+    renderWorking(ctx, speedTracker.lastTokS);
+  }
+  function applyConfig(ctx) {
+    saveConfig(config);
+    speedTracker.updateConfig(config.speed);
+    footerAnimator.updateDuration(config.speed.renderIntervalMs);
+    if (!config.enabled) {
+      stopLiveTimer();
+      stopFooterTimer();
+      stopCapacityTimer();
+      stopProviderTimer();
+      clearVibesStatus(ctx);
+      return;
+    }
+    publishCapacity(ctx);
+    publishSpeedFooter(ctx);
+    if (config.capacity.providerUsage) startProviderTimer(ctx);
+  }
+  pi.on("session_start", (_event, ctx) => {
+    stopLiveTimer();
+    stopFooterTimer();
+    stopCapacityTimer();
+    stopProviderTimer();
+    config = loadConfig2();
+    speedTracker.updateConfig(config.speed);
+    footerAnimator.updateDuration(config.speed.renderIntervalMs);
+    speedTracker.resetSession();
+    footerAnimator.reset(null);
+    clearProviderUsageCache();
+    currentProvider = ctx.model?.provider;
+    if (!config.enabled) {
+      clearVibesStatus(ctx);
+      return;
+    }
+    publishCapacity(ctx);
+    publishSpeedFooter(ctx);
+    startCapacityTimer(ctx);
+    startProviderTimer(ctx);
+    applyIndicator(ctx, null, true);
+  });
+  pi.on("agent_start", (_event, ctx) => {
+    if (!config.enabled) return;
+    resetWorking(ctx);
+  });
+  pi.on("turn_start", (_event, ctx) => {
+    if (!config.enabled) return;
+    resetWorking(ctx);
+  });
+  pi.on("message_start", (event, ctx) => {
+    if (!config.enabled || !config.speed.enabled || !isAssistantMessage(event.message)) return;
+    speedTracker.startMessage();
+    footerAnimator.reset(speedTracker.lastTokS);
+    startLiveTimer(ctx);
+    lastRenderedAt = 0;
+  });
+  pi.on("message_update", (event, ctx) => {
+    if (!config.enabled || !config.speed.enabled || !isAssistantMessage(event.message) || !speedTracker.isStreaming) return;
+    const ev = event.assistantMessageEvent;
+    const type = assistantEventType(ev);
+    if (type === "text_delta" || type === "thinking_delta") {
+      const delta = ev.delta ?? "";
+      speedTracker.recordDelta(delta, assistantUsageOutput(event.message));
+    }
+    if (type === "start") resetWorking(ctx);
+    const now = Date.now();
+    if (now - lastRenderedAt < config.speed.renderIntervalMs && type !== "done") return;
+    lastRenderedAt = now;
+    const speed = speedTracker.liveTokS();
+    applyIndicator(ctx, speed);
+    renderWorking(ctx, speed);
+  });
+  pi.on("message_end", (event, ctx) => {
+    if (!isAssistantMessage(event.message)) return;
+    publishCapacity(ctx);
+    if (!config.enabled || !config.speed.enabled || !speedTracker.isStreaming) return;
+    const completed = speedTracker.finishMessage(assistantUsageOutput(event.message) ?? 0, assistantStopReason(event.message));
+    if (!completed) return;
+    footerAnimator.setTarget(speedTracker.sessionAvgTokS());
+    publishSpeedFooter(ctx);
+    startFooterTimer(ctx);
+    applyIndicator(ctx, speedTracker.lastTokS);
+  });
+  pi.on("turn_end", () => {
+    speedTracker.stopMessage();
+    stopLiveTimer();
+  });
+  pi.on("agent_end", (_event, ctx) => {
+    speedTracker.stopMessage();
+    stopLiveTimer();
+    if (ctx && config.enabled && ctx.hasUI) {
+      applyIndicator(ctx, speedTracker.lastTokS);
+      ctx.ui.setWorkingMessage();
+    }
+  });
+  pi.on("model_select", (event, ctx) => {
+    currentProvider = event.model?.provider;
+    clearProviderUsageCache();
+    publishCapacity(ctx);
+  });
+  pi.on("session_compact", (_event, ctx) => publishCapacity(ctx));
+  pi.on("session_tree", (_event, ctx) => publishCapacity(ctx));
+  pi.on("session_shutdown", (_event, ctx) => {
+    stopLiveTimer();
+    stopFooterTimer();
+    stopCapacityTimer();
+    stopProviderTimer();
+    clearVibesStatus(ctx);
+  });
+  async function handleCommand(args, ctx) {
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    const [first, second] = tokens;
+    const mutate = (next) => {
+      config = next;
+      applyConfig(ctx);
+    };
+    if (!first) {
+      const speed = speedTracker.liveTokS();
+      const usage = getCapacityUsage(ctx);
+      const stage = config.capacity.icons.length ? config.capacity.labels[Math.max(
+        0,
+        Math.min(
+          config.capacity.labels.length - 1,
+          Math.floor((usage.percent ?? 0) / 100 * config.capacity.labels.length)
+        )
+      )] : "?";
+      ctx.ui.notify(
+        `crew-vibes: ${config.enabled ? "on" : "off"} \xB7 speed ${config.speed.enabled ? "on" : "off"} (${formatSpeed(config.speed, speed)}) \xB7 capacity ${config.capacity.enabled ? "on" : "off"} (${stage})`,
+        "info"
+      );
+      return;
+    }
+    if (first === "on" || first === "off") {
+      mutate({ ...config, enabled: first === "on" });
+      ctx.ui.notify(`crew-vibes ${first === "on" ? "enabled" : "disabled"}`, "info");
+      return;
+    }
+    if (first === "speed" && (second === "on" || second === "off")) {
+      mutate({ ...config, speed: { ...config.speed, enabled: second === "on" } });
+      ctx.ui.notify(`crew-vibes speed ${second === "on" ? "enabled" : "disabled"}`, "info");
+      return;
+    }
+    if (first === "capacity" && (second === "on" || second === "off")) {
+      mutate({ ...config, capacity: { ...config.capacity, enabled: second === "on" } });
+      ctx.ui.notify(`crew-vibes capacity ${second === "on" ? "enabled" : "disabled"}`, "info");
+      return;
+    }
+    ctx.ui.notify("Usage: /team-vibes [on|off|speed on|off|capacity on|off]", "error");
+  }
+  pi.registerCommand("team-vibes", {
+    description: "Toggle crew-vibes speed + context meters (on/off, speed, capacity)",
+    handler: handleCommand
+  });
+}
+
 // src/extension/cross-extension-rpc.ts
 init_safe_paths();
 
@@ -83617,6 +84980,11 @@ Subagent may need manual intervention.`
   registerContextStatusInjection(pi, {
     enabled: loadConfig(process.cwd()).config.reliability?.ambientStatusInjection !== false
   });
+  try {
+    registerCrewVibes(pi);
+  } catch (err2) {
+    console.warn("[pi-crew] crew-vibes initialization failed:", err2 instanceof Error ? err2.message : err2);
+  }
 }
 
 // index.bundle.ts