pi-crew 0.9.64 → 0.9.66

package/dist/index.mjs

@@ -10934,11 +10934,15 @@ function updateConfig(patch, options = {}) {
       for (const unset of options.unsetPaths) unsetPath(raw, unset);
       merged = parseConfig(raw);
     }
+    const normalizedCurrent = parseConfig(current);
+    if (JSON.stringify(merged) === JSON.stringify(normalizedCurrent)) {
+      return { path: filePath, config: merged, written: false };
+    }
     fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
     atomicWriteFile(filePath, `${JSON.stringify(merged, null, 2)}
 `);
     invalidateConfigCache();
-    return { path: filePath, config: merged };
+    return { path: filePath, config: merged, written: true };
   });
 }
 function updateAutonomousConfig(patch) {
@@ -10953,11 +10957,15 @@ function updateAutonomousConfig(patch) {
       throw new Error(`Could not update pi-crew config: ${message}`);
     }
     const currentAutonomous = current.autonomous && typeof current.autonomous === "object" && !Array.isArray(current.autonomous) ? current.autonomous : {};
-    current.autonomous = { ...currentAutonomous, ...patch };
+    const next = { ...current, autonomous: { ...currentAutonomous, ...patch } };
+    if (JSON.stringify(next) === JSON.stringify(current)) {
+      return { path: filePath, config: parseConfig(current), written: false };
+    }
+    current.autonomous = next.autonomous;
     atomicWriteFile(filePath, `${JSON.stringify(current, null, 2)}
 `);
     invalidateConfigCache();
-    return { path: filePath, config: parseConfig(current) };
+    return { path: filePath, config: parseConfig(current), written: true };
   });
 }
 var CONFIG_CACHE_TTL_MS, configCache, configCacheTtlMsOverride, KNOWN_TOP_LEVEL_KEYS, LIMIT_CEILINGS, DANGEROUS_OBJECT_KEYS;
@@ -11513,10 +11521,16 @@ function discoverProviderExtensions(settingsPath2) {
   const npmBase = path9.join(baseDir, "npm", "node_modules");
   for (const spec of settings.packages ?? []) {
     if (typeof spec !== "string") continue;
-    if (!spec.startsWith("npm:")) continue;
-    const pkgName = spec.slice(4);
-    const pkgDir = path9.join(npmBase, pkgName);
+    let pkgDir;
+    if (spec.startsWith("npm:")) {
+      pkgDir = path9.join(npmBase, spec.slice(4));
+    } else if (spec.startsWith("./") || spec.startsWith("../") || path9.isAbsolute(spec)) {
+      pkgDir = path9.resolve(baseDir, spec);
+    } else {
+      continue;
+    }
     if (!fs9.existsSync(pkgDir)) continue;
+    if (path9.resolve(pkgDir) === path9.resolve(packageRoot())) continue;
     const entryPath = resolvePackageEntry(pkgDir);
     if (entryPath) out.push({ spec, entryPath });
   }
@@ -12442,6 +12456,8 @@ function parseTeamFile(filePath, source) {
       defaultWorkflow: frontmatter.defaultWorkflow || frontmatter.workflow || void 0,
       workspaceMode: frontmatter.workspaceMode?.trim() === "worktree" ? "worktree" : "single",
       maxConcurrency: frontmatter.maxConcurrency ? Number.parseInt(frontmatter.maxConcurrency, 10) : void 0,
+      // observability defaults ON ("luôn hoạt động"); explicit `observability: false` disables.
+      observability: frontmatter.observability === void 0 ? true : frontmatter.observability !== "false",
       routing: triggers || useWhen || avoidWhen || cost || category ? { triggers, useWhen, avoidWhen, cost, category } : void 0
     };
   } catch {
@@ -22404,7 +22420,18 @@ var init_model_fallback = __esm({
       /context[_ ]?length[_ ]?exceeded/i,
       /safety/i,
       /is[_ ]?overloaded/i,
-      /\b408\b/
+      /\b408\b/,
+      //
+      // EPIPE / broken-pipe. In the child-pi worker path this typically means
+      // the child `pi` process exited (crash or early exit) while the parent
+      // was still writing to its stdin — spawning a fresh child on the next
+      // model in the fallback chain usually recovers. In the network path it
+      // is a transient pipe close. Both are retryable on a different model.
+      // See docs/failure-mode-inventory.md EPIPE gap; NON_RETRYABLE patterns
+      // (auth/billing) are checked first, so an auth error mentioning EPIPE
+      // stays non-retryable.
+      /epipe/i,
+      /broken pipe/i
     ];
     NON_RETRYABLE_MODEL_FAILURE_PATTERNS = [
       /auth(?:entication)?/i,
@@ -23842,10 +23869,12 @@ var init_team_tool_schema = __esm({
         })
       ),
       budgetTotal: Type.Optional(
+        // Empty-string unset marker accepted (Tier-9: models emit "" when unset).
         // 0 accepted as "unset/disabled" (models emit 0 for off); still rejects 1-999
         // as the MISCONFIGURATION GUARD against typo'd silent-abort configs.
         Type.Union(
           [
+            Type.Literal(""),
             Type.Literal(0),
             Type.Number({
               minimum: 1e3
@@ -35626,23 +35655,46 @@ function parseIntervalMs(s) {
   }
   return ms;
 }
+function cronFieldMatches(value, field, min, max, names) {
+  let normalized = field.trim().toUpperCase();
+  if (names) {
+    for (const name of Object.keys(names).sort((a, b) => b.length - a.length)) {
+      normalized = normalized.split(name).join(String(names[name]));
+    }
+  }
+  if (min === 0 && max === 6) normalized = normalized.replace(/\b7\b/g, "0");
+  const matched = /* @__PURE__ */ new Set();
+  for (const rawPart of normalized.split(",")) {
+    const part = rawPart.trim();
+    if (part === "") return false;
+    const stepMatch = part.match(/^(.*)\/(\d+)$/);
+    const step = stepMatch ? Number.parseInt(stepMatch[2], 10) : 1;
+    if (!Number.isFinite(step) || step < 1) return false;
+    const rangeStr = stepMatch ? stepMatch[1] : part;
+    let lo;
+    let hi;
+    if (rangeStr === "*") {
+      lo = min;
+      hi = max;
+    } else if (/^\d+$/.test(rangeStr)) {
+      lo = Number.parseInt(rangeStr, 10);
+      hi = stepMatch ? max : lo;
+    } else {
+      const rm = rangeStr.match(/^(\d+)-(\d+)$/);
+      if (!rm) return false;
+      lo = Number.parseInt(rm[1], 10);
+      hi = Number.parseInt(rm[2], 10);
+    }
+    for (let v = lo; v <= hi; v += step) {
+      if (v >= min && v <= max) matched.add(v);
+    }
+  }
+  return matched.has(value);
+}
 function nextCronDate(spec, from) {
   const parts = spec.split(/\s+/);
   if (parts.length < 5) return { error: "Invalid cron expression" };
   const [minStr, hourStr, domStr, monthStr, dowStr] = parts;
-  function matchField(value, str, min, max) {
-    if (str === "*") return true;
-    const n = parseInt(str, 10);
-    if (!Number.isNaN(n) && n >= min && n <= max && n === value) return true;
-    if (/^\d+-\d+$/.test(str)) {
-      const [a, b] = str.split("-").map(Number);
-      return value >= a && value <= b;
-    }
-    if (str.includes(",")) {
-      return str.split(",").some((part) => matchField(value, part.trim(), min, max));
-    }
-    return false;
-  }
   let cursor = new Date(from.getTime());
   cursor.setSeconds(0, 0);
   cursor = new Date(cursor.getTime() + 6e4);
@@ -35653,7 +35705,7 @@ function nextCronDate(spec, from) {
     const dom = cursor.getUTCDate();
     const month = cursor.getUTCMonth() + 1;
     const dow = cursor.getUTCDay();
-    if (matchField(min, minStr, 0, 59) && matchField(hour, hourStr, 0, 23) && matchField(dom, domStr, 1, 31) && matchField(month, monthStr, 1, 12) && matchField(dow, dowStr, 0, 6)) {
+    if (cronFieldMatches(min, minStr, 0, 59) && cronFieldMatches(hour, hourStr, 0, 23) && cronFieldMatches(dom, domStr, 1, 31) && cronFieldMatches(month, monthStr, 1, 12, CRON_MONTH_NAMES) && cronFieldMatches(dow, dowStr, 0, 6, CRON_DOW_NAMES)) {
       return cursor;
     }
     cursor = new Date(cursor.getTime() + 6e4);
@@ -35731,7 +35783,7 @@ function humanizeSchedule(spec) {
   }
   return "unknown schedule";
 }
-var CrewScheduler;
+var CrewScheduler, CRON_DOW_NAMES, CRON_MONTH_NAMES;
 var init_scheduler = __esm({
   "src/runtime/scheduling/scheduler.ts"() {
     "use strict";
@@ -35886,6 +35938,21 @@ var init_scheduler = __esm({
         throw new Error(`Invalid schedule "${s}". Use "5m", "+10m", ISO timestamp, or cron expression.`);
       }
     };
+    CRON_DOW_NAMES = { SUN: 0, MON: 1, TUE: 2, WED: 3, THU: 4, FRI: 5, SAT: 6 };
+    CRON_MONTH_NAMES = {
+      JAN: 1,
+      FEB: 2,
+      MAR: 3,
+      APR: 4,
+      MAY: 5,
+      JUN: 6,
+      JUL: 7,
+      AUG: 8,
+      SEP: 9,
+      OCT: 10,
+      NOV: 11,
+      DEC: 12
+    };
   }
 });
 
@@ -36511,8 +36578,13 @@ var cancel_exports = {};
 __export(cancel_exports, {
   abortOwned: () => abortOwned,
   handleCancel: () => handleCancel,
-  handleRetry: () => handleRetry
+  handleRetry: () => handleRetry,
+  retryShortCircuitsCompleted: () => retryShortCircuitsCompleted
 });
+function retryShortCircuitsCompleted(runStatus, tasks, targetTaskId) {
+  if (runStatus !== "completed") return false;
+  return !tasks.some((task) => (targetTaskId ? task.id === targetTaskId : true) && RETRYABLE_STATUSES.has(task.status));
+}
 function abortOwned(runId, taskIds, ctx, force) {
   const runCwd = locateRunCwd(runId, ctx.cwd);
   if (!runCwd) return { abortedIds: [], missingIds: taskIds ?? [], foreignIds: [] };
@@ -36585,6 +36657,13 @@ async function handleRetry(params, ctx, deps) {
     );
   }
   const targetTaskId = typeof params.taskId === "string" ? params.taskId : void 0;
+  if (retryShortCircuitsCompleted(loaded.manifest.status, loaded.tasks, targetTaskId)) {
+    return result(
+      `Run ${loaded.manifest.runId} is already completed; retry only applies to failed/cancelled runs.`,
+      { action: "retry", status: "error", runId: loaded.manifest.runId },
+      true
+    );
+  }
   return withRunLockSync(loaded.manifest, () => {
     const retryableStatuses = /* @__PURE__ */ new Set(["failed", "cancelled"]);
     const matchingTasks = loaded.tasks.filter((task) => {
@@ -36789,6 +36868,7 @@ async function handleCancel(params, ctx, deps) {
     });
   });
 }
+var RETRYABLE_STATUSES;
 var init_cancel = __esm({
   "src/extension/team-tool/cancel.ts"() {
     "use strict";
@@ -36808,6 +36888,7 @@ var init_cancel = __esm({
     init_intent_policy();
     init_param_error();
     init_run_not_found();
+    RETRYABLE_STATUSES = /* @__PURE__ */ new Set(["failed", "cancelled"]);
   }
 });
 
@@ -38785,7 +38866,9 @@ function handleWorktrees(params, ctx) {
       { action: "worktrees", status: "error" },
       true
     );
-  const loaded = loadRunManifestById(ctx.cwd, params.runId);
+  const runCwd = locateRunCwd(params.runId, ctx.cwd);
+  if (!runCwd) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "worktrees", status: "error" }, true);
+  const loaded = loadRunManifestById(runCwd, params.runId);
   if (!loaded) return result(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "worktrees", status: "error" }, true);
   const withWorktrees = loaded.tasks.filter((task) => task.worktree);
   const lines = [
@@ -39310,6 +39393,7 @@ var init_lifecycle_actions = __esm({
     init_run_export();
     init_run_import();
     init_run_maintenance();
+    init_team_tool2();
     init_context();
     init_intent_policy();
     init_param_error();
@@ -39565,6 +39649,7 @@ function serializeTeam(team) {
     team.defaultWorkflow ? `defaultWorkflow: ${team.defaultWorkflow}` : void 0,
     team.workspaceMode ? `workspaceMode: ${team.workspaceMode}` : void 0,
     team.maxConcurrency !== void 0 ? `maxConcurrency: ${team.maxConcurrency}` : void 0,
+    team.observability !== void 0 ? `observability: ${team.observability}` : void 0,
     line2("triggers", team.routing?.triggers),
     line2("useWhen", team.routing?.useWhen),
     line2("avoidWhen", team.routing?.avoidWhen),
@@ -41145,10 +41230,13 @@ async function handleManageDomain(params, ctx) {
             unsetPaths
           });
           return result(
-            ["Updated pi-crew config.", `Path: ${saved.path}`, "Effective config:", JSON.stringify(saved.config, null, 2)].join(
-              "\n"
-            ),
-            { action: "config", status: "ok" }
+            [
+              saved.written ? "Updated pi-crew config." : "Config unchanged (no effective changes).",
+              `Path: ${saved.path}`,
+              "Effective config:",
+              JSON.stringify(saved.config, null, 2)
+            ].join("\n"),
+            { action: "config", status: "ok", written: saved.written }
           );
         } catch (error) {
           const message = error instanceof Error ? error.message : String(error);
@@ -47774,7 +47862,8 @@ function handleExplain(params, cwd) {
   if (!params.runId) {
     return result3("explain requires runId", { action: "explain", status: "error" }, true);
   }
-  const loaded = loadRunManifestById(cwd, params.runId);
+  const runCwd = locateRunCwd(params.runId, cwd);
+  const loaded = runCwd ? loadRunManifestById(runCwd, params.runId) : void 0;
   if (!loaded) {
     return result3(`Run '${params.runId}' not found.${RUN_NOT_FOUND_HINT}`, { action: "explain", status: "error" }, true);
   }
@@ -47833,6 +47922,7 @@ var init_explain = __esm({
   "src/extension/team-tool/explain.ts"() {
     "use strict";
     init_state_store();
+    init_team_tool2();
     init_run_not_found();
   }
 });
@@ -48455,6 +48545,9 @@ function taskHasObservableWorkerActivity(task) {
     (task.agentProgress?.toolCount ?? 0) > 0 || task.usage || task.transcriptArtifact || task.modelAttempts?.some((attempt) => attempt.success) || task.jsonEvents
   );
 }
+function taskHasEmptyResult(task) {
+  return Boolean(task.resultArtifact && task.resultArtifact.sizeBytes === 0);
+}
 function resolveEffectivenessGuardMode(runtimeConfig, manifest) {
   const configured = runtimeConfig?.effectivenessGuard;
   if (configured === "off" || configured === "warn" || configured === "block" || configured === "fail") return configured;
@@ -48463,7 +48556,7 @@ function resolveEffectivenessGuardMode(runtimeConfig, manifest) {
 }
 function evaluateRunEffectiveness(input) {
   const completedTasks = input.tasks.filter((task) => task.status === "completed");
-  const noObservedWorkTasks = completedTasks.filter((task) => !taskHasObservableWorkerActivity(task));
+  const noObservedWorkTasks = completedTasks.filter((task) => !taskHasObservableWorkerActivity(task) || taskHasEmptyResult(task));
   const needsAttentionTasks = input.tasks.filter((task) => task.agentProgress?.activityState === "needs_attention");
   const workerExecution = input.executeWorkers ? "enabled" : "disabled/scaffold";
   const guardMode = resolveEffectivenessGuardMode(input.runtimeConfig, input.manifest);
@@ -49325,112 +49418,6 @@ var init_correlation = __esm({
   }
 });
 
-// src/plugins/plugin-registry.ts
-var PluginRegistry;
-var init_plugin_registry = __esm({
-  "src/plugins/plugin-registry.ts"() {
-    "use strict";
-    PluginRegistry = class {
-      plugins = [];
-      register(plugin) {
-        this.plugins.push(plugin);
-      }
-      activePlugins(allDeps) {
-        return this.plugins.filter(
-          (p) => p.enablers.some((enabler) => {
-            if (enabler.endsWith("/")) {
-              return allDeps.some((d) => d.startsWith(enabler));
-            }
-            return allDeps.includes(enabler);
-          })
-        );
-      }
-      allPlugins() {
-        return [...this.plugins];
-      }
-    };
-  }
-});
-
-// src/plugins/plugin-define.ts
-function definePlugin(spec) {
-  return spec;
-}
-var init_plugin_define = __esm({
-  "src/plugins/plugin-define.ts"() {
-    "use strict";
-  }
-});
-
-// src/plugins/plugins/nextjs.ts
-var NextJsPlugin;
-var init_nextjs = __esm({
-  "src/plugins/plugins/nextjs.ts"() {
-    "use strict";
-    init_plugin_define();
-    NextJsPlugin = definePlugin({
-      name: "nextjs",
-      enablers: ["next"],
-      entryPatterns: [
-        "src/app/**/*.{ts,tsx}",
-        "src/pages/**/*.{ts,tsx}",
-        "src/app/**/page.{ts,tsx}",
-        "src/app/**/layout.{ts,tsx}",
-        "src/app/**/route.{ts,tsx}",
-        "middleware.{ts,js}",
-        "next.config.{ts,js,mjs}"
-      ],
-      configPatterns: ["next.config.{ts,js,mjs}"],
-      toolingDependencies: ["next", "@next/font", "@next/mdx"],
-      pathAliases: [["~", "src"]],
-      virtualModulePrefixes: ["next:"]
-    });
-  }
-});
-
-// src/plugins/plugins/vite.ts
-var VitePlugin;
-var init_vite = __esm({
-  "src/plugins/plugins/vite.ts"() {
-    "use strict";
-    init_plugin_define();
-    VitePlugin = definePlugin({
-      name: "vite",
-      enablers: ["vite", "rolldown-vite"],
-      entryPatterns: ["src/main.{ts,tsx,js,jsx}", "src/index.{ts,tsx,js,jsx}", "index.html"],
-      configPatterns: ["vite.config.{ts,js,mts,mjs}"],
-      toolingDependencies: ["vite"],
-      virtualModulePrefixes: ["virtual:"]
-    });
-  }
-});
-
-// src/plugins/plugins/vitest.ts
-var VitestPlugin;
-var init_vitest = __esm({
-  "src/plugins/plugins/vitest.ts"() {
-    "use strict";
-    init_plugin_define();
-    VitestPlugin = definePlugin({
-      name: "vitest",
-      enablers: ["vitest"],
-      entryPatterns: ["**/*.test.{ts,tsx}", "**/*.spec.{ts,tsx}", "src/**/*.test.{ts,tsx}", "src/**/*.spec.{ts,tsx}"],
-      configPatterns: ["vitest.config.{ts,js,mjs}", "vite.config.ts"],
-      toolingDependencies: ["vitest"]
-    });
-  }
-});
-
-// src/plugins/plugins/index.ts
-var init_plugins = __esm({
-  "src/plugins/plugins/index.ts"() {
-    "use strict";
-    init_nextjs();
-    init_vite();
-    init_vitest();
-  }
-});
-
 // src/runtime/task-health.ts
 function scoreToGrade(score) {
   if (score >= 90) return "A";
@@ -50470,6 +50457,166 @@ var init_group_join = __esm({
   }
 });
 
+// src/runtime/scheduling/task-graph-scheduler.ts
+function buildTaskGraphIndex(tasks) {
+  const cached2 = taskGraphIndexCache.get(tasks);
+  if (cached2) return cached2;
+  const fresh = {
+    doneSteps: new Set(
+      tasks.filter((task) => task.status === "completed").map((task) => task.stepId).filter((id) => id !== void 0)
+    ),
+    idMap: new Map(tasks.map((task) => [task.id, task])),
+    stepToTaskId: new Map(
+      tasks.map((task) => [task.stepId, task.id]).filter((entry) => entry[0] !== void 0)
+    )
+  };
+  taskGraphIndexCache.set(tasks, fresh);
+  return fresh;
+}
+function dependencySatisfied(task, doneStepIds, idMap, stepMap) {
+  return task.dependsOn.every((dependency) => {
+    if (doneStepIds.has(dependency)) return true;
+    const taskId = stepMap.get(dependency) ?? dependency;
+    return idMap.get(taskId)?.status === "completed";
+  });
+}
+function withQueue(task, index) {
+  let resolvedQueue;
+  if (task.status === "queued") {
+    const isReady = dependencySatisfied(task, index.doneSteps, index.idMap, index.stepToTaskId);
+    resolvedQueue = isReady ? "ready" : "blocked";
+  } else if (task.status === "running") {
+    resolvedQueue = "running";
+  } else if (task.status === "completed" || task.status === "skipped" || task.status === "needs_attention") {
+    resolvedQueue = "done";
+  } else {
+    resolvedQueue = "blocked";
+  }
+  if (task.graph && task.graph.queue === resolvedQueue) {
+    return task;
+  }
+  return {
+    ...task,
+    graph: task.graph ? { ...task.graph, queue: resolvedQueue } : task.graph
+  };
+}
+function ensureIndex(tasks, index) {
+  return index ?? buildTaskGraphIndex(tasks);
+}
+function refreshTaskGraphQueues(tasks, index) {
+  const resolved = ensureIndex(tasks, index);
+  return tasks.map((task) => withQueue(task, resolved));
+}
+function taskGraphSnapshot(tasks, index) {
+  const refreshed = refreshTaskGraphQueues(tasks, index);
+  return {
+    ready: refreshed.filter((task) => task.status === "queued" && task.graph?.queue === "ready").map((task) => task.id),
+    blocked: refreshed.filter((task) => task.status === "queued" && task.graph?.queue === "blocked").map((task) => task.id),
+    running: refreshed.filter((task) => task.status === "running").map((task) => task.id),
+    done: refreshed.filter((task) => task.status === "completed" || task.status === "skipped").map((task) => task.id),
+    failed: refreshed.filter((task) => task.status === "failed").map((task) => task.id),
+    cancelled: refreshed.filter((task) => task.status === "cancelled").map((task) => task.id)
+  };
+}
+var taskGraphIndexCache;
+var init_task_graph_scheduler = __esm({
+  "src/runtime/scheduling/task-graph-scheduler.ts"() {
+    "use strict";
+    taskGraphIndexCache = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/runtime/merge-gate.ts
+function isNonTerminalTaskStatus(status) {
+  return status === "queued" || status === "running" || status === "waiting";
+}
+function safeFinishedAt(task) {
+  if (!task.finishedAt) return -Infinity;
+  const ms = new Date(task.finishedAt).getTime();
+  return Number.isNaN(ms) ? Infinity : ms;
+}
+function isMalformedFinishedAtReplacement(currentTime, updatedTime) {
+  return !Number.isFinite(currentTime) && Number.isFinite(updatedTime);
+}
+function statusMergeKey(from, to) {
+  return `${from}->${to}`;
+}
+function shouldMergeTaskUpdate(current, updated) {
+  if (REJECTED_STATUS_MERGE_TRANSITIONS.has(statusMergeKey(current.status, updated.status))) return false;
+  if (current.status === updated.status && updated.status === "running" && current.resultArtifact && !updated.resultArtifact)
+    return false;
+  if (current.status === updated.status && current.status === "completed" && current.resultArtifact && !updated.resultArtifact)
+    return false;
+  if (current.finishedAt !== void 0 && updated.finishedAt !== void 0) {
+    const currentTime = safeFinishedAt(current);
+    const updatedTime = safeFinishedAt(updated);
+    if (!Number.isFinite(currentTime)) {
+      console.warn(`[merge-gate] Task ${current.id} has malformed finishedAt: ${current.finishedAt}`);
+    }
+    if (isMalformedFinishedAtReplacement(currentTime, updatedTime)) {
+      return true;
+    }
+    if (updatedTime < currentTime) return false;
+  }
+  if (!updated.finishedAt && !isNonTerminalTaskStatus(updated.status)) return false;
+  const hasMeaningfulUpdate = updated.status !== current.status || updated.finishedAt !== current.finishedAt || updated.startedAt !== current.startedAt || Boolean(updated.resultArtifact) !== Boolean(current.resultArtifact) || Boolean(updated.resultArtifact) && updated.resultArtifact !== current.resultArtifact || Boolean(updated.error) || Boolean(updated.modelAttempts?.length) || Boolean(updated.usage) || Boolean(updated.attempts?.length) || updated.heartbeat?.lastSeenAt !== current.heartbeat?.lastSeenAt || updated.jsonEvents !== current.jsonEvents || updated.agentProgress?.lastActivityAt !== current.agentProgress?.lastActivityAt;
+  return hasMeaningfulUpdate;
+}
+function mergeTaskUpdatesPreservingTerminal(base, results) {
+  const indexById = /* @__PURE__ */ new Map();
+  for (const task of base) indexById.set(task.id, task);
+  let skipped = 0;
+  for (const result4 of results) {
+    for (const updated of result4.tasks) {
+      const current = indexById.get(updated.id);
+      if (!current) continue;
+      if (!shouldMergeTaskUpdate(current, updated)) {
+        console.debug("[merge-gate] Skipping stale merge for task", updated.id, {
+          currentStatus: current.status,
+          updatedStatus: updated.status,
+          currentFinishedAt: current.finishedAt,
+          updatedFinishedAt: updated.finishedAt
+        });
+        skipped += 1;
+        continue;
+      }
+      indexById.set(updated.id, updated);
+    }
+  }
+  const merged = base.map((task) => indexById.get(task.id) ?? task);
+  void skipped;
+  return refreshTaskGraphQueues(merged);
+}
+var REJECTED_STATUS_MERGE_TRANSITIONS, __test__shouldMergeTaskUpdate, __test__mergeTaskUpdates;
+var init_merge_gate = __esm({
+  "src/runtime/merge-gate.ts"() {
+    "use strict";
+    init_contracts();
+    init_task_graph_scheduler();
+    REJECTED_STATUS_MERGE_TRANSITIONS = (() => {
+      const rejected = /* @__PURE__ */ new Set();
+      for (const from of TEAM_TASK_STATUSES) {
+        if (!TEAM_TERMINAL_TASK_STATUSES.has(from)) continue;
+        for (const to of TEAM_TASK_STATUSES) {
+          if (!TEAM_TERMINAL_TASK_STATUSES.has(to)) rejected.add(statusMergeKey(from, to));
+        }
+      }
+      rejected.add(statusMergeKey("waiting", "running"));
+      const completedIntegrityFlips = [
+        ["completed", "failed"],
+        ["completed", "needs_attention"],
+        ["failed", "completed"],
+        ["cancelled", "completed"],
+        ["needs_attention", "completed"]
+      ];
+      for (const [from, to] of completedIntegrityFlips) rejected.add(statusMergeKey(from, to));
+      return rejected;
+    })();
+    __test__shouldMergeTaskUpdate = shouldMergeTaskUpdate;
+    __test__mergeTaskUpdates = mergeTaskUpdatesPreservingTerminal;
+  }
+});
+
 // src/runtime/model/runtime-policy.ts
 function resolveTaskRuntimeKind(globalKind, role, isolationPolicy, env = process.env) {
   if (globalKind === "scaffold") return "scaffold";
@@ -51822,75 +51969,6 @@ var init_task_graph = __esm({
   }
 });
 
-// src/runtime/scheduling/task-graph-scheduler.ts
-function buildTaskGraphIndex(tasks) {
-  const cached2 = taskGraphIndexCache.get(tasks);
-  if (cached2) return cached2;
-  const fresh = {
-    doneSteps: new Set(
-      tasks.filter((task) => task.status === "completed").map((task) => task.stepId).filter((id) => id !== void 0)
-    ),
-    idMap: new Map(tasks.map((task) => [task.id, task])),
-    stepToTaskId: new Map(
-      tasks.map((task) => [task.stepId, task.id]).filter((entry) => entry[0] !== void 0)
-    )
-  };
-  taskGraphIndexCache.set(tasks, fresh);
-  return fresh;
-}
-function dependencySatisfied(task, doneStepIds, idMap, stepMap) {
-  return task.dependsOn.every((dependency) => {
-    if (doneStepIds.has(dependency)) return true;
-    const taskId = stepMap.get(dependency) ?? dependency;
-    return idMap.get(taskId)?.status === "completed";
-  });
-}
-function withQueue(task, index) {
-  let resolvedQueue;
-  if (task.status === "queued") {
-    const isReady = dependencySatisfied(task, index.doneSteps, index.idMap, index.stepToTaskId);
-    resolvedQueue = isReady ? "ready" : "blocked";
-  } else if (task.status === "running") {
-    resolvedQueue = "running";
-  } else if (task.status === "completed" || task.status === "skipped" || task.status === "needs_attention") {
-    resolvedQueue = "done";
-  } else {
-    resolvedQueue = "blocked";
-  }
-  if (task.graph && task.graph.queue === resolvedQueue) {
-    return task;
-  }
-  return {
-    ...task,
-    graph: task.graph ? { ...task.graph, queue: resolvedQueue } : task.graph
-  };
-}
-function ensureIndex(tasks, index) {
-  return index ?? buildTaskGraphIndex(tasks);
-}
-function refreshTaskGraphQueues(tasks, index) {
-  const resolved = ensureIndex(tasks, index);
-  return tasks.map((task) => withQueue(task, resolved));
-}
-function taskGraphSnapshot(tasks, index) {
-  const refreshed = refreshTaskGraphQueues(tasks, index);
-  return {
-    ready: refreshed.filter((task) => task.status === "queued" && task.graph?.queue === "ready").map((task) => task.id),
-    blocked: refreshed.filter((task) => task.status === "queued" && task.graph?.queue === "blocked").map((task) => task.id),
-    running: refreshed.filter((task) => task.status === "running").map((task) => task.id),
-    done: refreshed.filter((task) => task.status === "completed" || task.status === "skipped").map((task) => task.id),
-    failed: refreshed.filter((task) => task.status === "failed").map((task) => task.id),
-    cancelled: refreshed.filter((task) => task.status === "cancelled").map((task) => task.id)
-  };
-}
-var taskGraphIndexCache;
-var init_task_graph_scheduler = __esm({
-  "src/runtime/scheduling/task-graph-scheduler.ts"() {
-    "use strict";
-    taskGraphIndexCache = /* @__PURE__ */ new WeakMap();
-  }
-});
-
 // src/extension/knowledge-injection.ts
 import * as fs75 from "node:fs";
 import * as path65 from "node:path";
@@ -54551,16 +54629,24 @@ function validateWorkerOutput(role, output) {
     issues
   };
 }
-var ROLE_PATTERN_DEFS, makeUrlRe;
+var MARKDOWN_STRUCTURED, STRICT_ROLE_PATTERNS, ROLE_PATTERN_DEFS, makeUrlRe;
 var init_output_validator = __esm({
   "src/runtime/output/output-validator.ts"() {
     "use strict";
+    MARKDOWN_STRUCTURED = /^(?:#{1,6}\s|\*\*|[-*]\s|\d+\.\s)/m;
+    STRICT_ROLE_PATTERNS = {
+      explorer: /^(\S+:\d+|Defs:|Refs:|Callers:|Tests:|Sites:|No match\.|totals:)/m,
+      executor: /^(\S+:\d+(-\d+)? — .{1,80}\.|verified:|too-big\.|needs-confirm\.|ambiguous\.|regressed\.)/m,
+      reviewer: new RegExp("^([^:\\s]+:\\d+:\\s+\\p{Emoji_Presentation}|No issues\\.|totals:)", "mu"),
+      "security-reviewer": new RegExp("^([^:\\s]+:\\d+:\\s+\\p{Emoji_Presentation}|No issues\\.|totals:)", "mu"),
+      verifier: /^(PASS:|FAIL:)/m
+    };
     ROLE_PATTERN_DEFS = {
-      explorer: () => /^(\S+:\d+|Defs:|Refs:|Callers:|Tests:|Sites:|No match\.|totals:)/m,
-      executor: () => /^(\S+:\d+(-\d+)? — .{1,80}\.|verified:|too-big\.|needs-confirm\.|ambiguous\.|regressed\.)/m,
-      reviewer: () => new RegExp("^([^:\\s]+:\\d+:\\s+\\p{Emoji_Presentation}|No issues\\.|totals:)", "mu"),
-      "security-reviewer": () => new RegExp("^([^:\\s]+:\\d+:\\s+\\p{Emoji_Presentation}|No issues\\.|totals:)", "mu"),
-      verifier: () => /^(PASS:|FAIL:)/m
+      explorer: () => new RegExp(`(?:${STRICT_ROLE_PATTERNS.explorer.source})|(?:${MARKDOWN_STRUCTURED.source})`, "m"),
+      executor: () => new RegExp(`(?:${STRICT_ROLE_PATTERNS.executor.source})|(?:${MARKDOWN_STRUCTURED.source})`, "m"),
+      reviewer: () => new RegExp(`(?:${STRICT_ROLE_PATTERNS.reviewer.source})|(?:${MARKDOWN_STRUCTURED.source})`, "mu"),
+      "security-reviewer": () => new RegExp(`(?:${STRICT_ROLE_PATTERNS["security-reviewer"].source})|(?:${MARKDOWN_STRUCTURED.source})`, "mu"),
+      verifier: () => new RegExp(`(?:${STRICT_ROLE_PATTERNS.verifier.source})|(?:${MARKDOWN_STRUCTURED.source})`, "m")
     };
     makeUrlRe = () => /\bhttps?:\/\/[^\s<>)\]"',;]+/gi;
   }
@@ -56787,12 +56873,13 @@ __export(team_runner_exports, {
   drainPendingUnits: () => drainPendingUnits,
   executeTeamRun: () => executeTeamRun,
   hasPendingMutatingTaskAtBoundary: () => hasPendingMutatingTaskAtBoundary,
-  mergeTaskUpdatesPreservingTerminal: () => mergeTaskUpdatesPreservingTerminal,
   setRunStatusRunning: () => setRunStatusRunning,
   shouldUseRetry: () => shouldUseRetry
 });
+import { spawn as spawn6 } from "node:child_process";
 import * as fs86 from "node:fs";
 import * as path72 from "node:path";
+import { fileURLToPath as fileURLToPath7 } from "node:url";
 function startTeamRunHeartbeat(stateRoot, runId) {
   const heartbeatPath = path72.join(stateRoot, "heartbeat.json");
   const writeHeartbeat = () => {
@@ -56816,6 +56903,87 @@ function startTeamRunHeartbeat(stateRoot, runId) {
   const interval = setInterval(writeHeartbeat, 6e4);
   return () => clearInterval(interval);
 }
+function perfScriptPath(scriptName) {
+  try {
+    const candidates = [
+      fileURLToPath7(new URL(`../../scripts/${scriptName}`, import.meta.url)),
+      fileURLToPath7(new URL(`../scripts/${scriptName}`, import.meta.url))
+    ];
+    return candidates.find((p) => fs86.existsSync(p));
+  } catch {
+    return void 0;
+  }
+}
+function startPerfSampler(manifest, team) {
+  const marker = (msg) => {
+    try {
+      fs86.appendFileSync(path72.join(manifest.artifactsRoot, "perf-obs.log"), `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
+`);
+    } catch {
+    }
+  };
+  marker(`startPerfSampler entered (team=${team.name} observability=${String(team.observability)} importMetaUrl=${import.meta.url})`);
+  if (team.observability !== true) {
+    marker(`SKIP: observability=${String(team.observability)} !== true`);
+    return;
+  }
+  const samplerPath = perfScriptPath("resource-sampler.mjs");
+  if (!samplerPath) {
+    marker(`SKIP: resource-sampler.mjs not found (importMetaUrl=${import.meta.url})`);
+    return;
+  }
+  marker(`spawning sampler from ${samplerPath}`);
+  const crewRoot = path72.dirname(path72.dirname(path72.dirname(manifest.stateRoot)));
+  const outPath = path72.join(manifest.artifactsRoot, "resources.jsonl");
+  const logPath = path72.join(manifest.artifactsRoot, "perf-obs.log");
+  try {
+    const child = spawn6(
+      process.execPath,
+      [
+        "--experimental-strip-types",
+        samplerPath,
+        "--watch-run",
+        manifest.runId,
+        "--crew-root",
+        crewRoot,
+        "--interval",
+        String(OBSERVABILITY_INTERVAL_MS),
+        "--out",
+        outPath
+      ],
+      { detached: true, stdio: ["ignore", "ignore", "pipe"] }
+    );
+    child.stderr?.on("data", (d) => {
+      try {
+        fs86.appendFileSync(logPath, String(d));
+      } catch {
+      }
+    });
+    child.unref();
+  } catch (err2) {
+    console.warn(`[perf-obs] sampler spawn failed for ${manifest.runId}: ${String(err2)}`);
+  }
+}
+function schedulePerfAnalyze(manifest, team) {
+  if (team.observability !== true) return;
+  const analyzePath = perfScriptPath("analyze-run.mjs");
+  const resourcesPath = path72.join(manifest.artifactsRoot, "resources.jsonl");
+  if (!analyzePath || !fs86.existsSync(resourcesPath)) return;
+  const crewRoot = path72.dirname(path72.dirname(path72.dirname(manifest.stateRoot)));
+  const timer = setTimeout(() => {
+    try {
+      const child = spawn6(
+        process.execPath,
+        ["--experimental-strip-types", analyzePath, manifest.runId, "--crew-root", crewRoot, "--resources", resourcesPath],
+        { detached: true, stdio: "ignore" }
+      );
+      child.unref();
+    } catch (err2) {
+      console.warn(`[perf-obs] analyze spawn failed for ${manifest.runId}: ${String(err2)}`);
+    }
+  }, OBSERVABILITY_ANALYZE_DELAY_MS);
+  timer.unref();
+}
 function checkPerTaskBudget(tasks, budgetTotal, budgetWarning, budgetAbort, fairShareFraction = 0.5) {
   const usage = aggregateUsage(tasks);
   const totalUsed = (usage?.input ?? 0) + (usage?.output ?? 0) + (usage?.cacheWrite ?? 0);
@@ -56859,9 +57027,6 @@ function markBlocked(tasks, reason) {
     } : task
   );
 }
-function isNonTerminalTaskStatus(status) {
-  return status === "queued" || status === "running" || status === "waiting";
-}
 function cancelNonTerminalTasks(tasks, status, reason, filter, transform) {
   const predicate = filter ?? ((task) => isNonTerminalTaskStatus(task.status));
   return tasks.map((task) => {
@@ -56870,63 +57035,6 @@ function cancelNonTerminalTasks(tasks, status, reason, filter, transform) {
     return transform ? transform(task, terminalised) : terminalised;
   });
 }
-function safeFinishedAt(task) {
-  if (!task.finishedAt) return -Infinity;
-  const ms = new Date(task.finishedAt).getTime();
-  return Number.isNaN(ms) ? Infinity : ms;
-}
-function isMalformedFinishedAtReplacement(currentTime, updatedTime) {
-  return !Number.isFinite(currentTime) && Number.isFinite(updatedTime);
-}
-function statusMergeKey(from, to) {
-  return `${from}->${to}`;
-}
-function shouldMergeTaskUpdate(current, updated) {
-  if (REJECTED_STATUS_MERGE_TRANSITIONS.has(statusMergeKey(current.status, updated.status))) return false;
-  if (current.status === updated.status && updated.status === "running" && current.resultArtifact && !updated.resultArtifact)
-    return false;
-  if (current.status === updated.status && current.status === "completed" && current.resultArtifact && !updated.resultArtifact)
-    return false;
-  if (current.finishedAt !== void 0 && updated.finishedAt !== void 0) {
-    const currentTime = safeFinishedAt(current);
-    const updatedTime = safeFinishedAt(updated);
-    if (!Number.isFinite(currentTime)) {
-      console.warn(`[team-runner] Task ${current.id} has malformed finishedAt: ${current.finishedAt}`);
-    }
-    if (isMalformedFinishedAtReplacement(currentTime, updatedTime)) {
-      return true;
-    }
-    if (updatedTime < currentTime) return false;
-  }
-  if (!updated.finishedAt && !isNonTerminalTaskStatus(updated.status)) return false;
-  const hasMeaningfulUpdate = updated.status !== current.status || updated.finishedAt !== current.finishedAt || updated.startedAt !== current.startedAt || Boolean(updated.resultArtifact) !== Boolean(current.resultArtifact) || Boolean(updated.resultArtifact) && updated.resultArtifact !== current.resultArtifact || Boolean(updated.error) || Boolean(updated.modelAttempts?.length) || Boolean(updated.usage) || Boolean(updated.attempts?.length) || updated.heartbeat?.lastSeenAt !== current.heartbeat?.lastSeenAt || updated.jsonEvents !== current.jsonEvents || updated.agentProgress?.lastActivityAt !== current.agentProgress?.lastActivityAt;
-  return hasMeaningfulUpdate;
-}
-function mergeTaskUpdatesPreservingTerminal(base, results) {
-  const indexById = /* @__PURE__ */ new Map();
-  for (const task of base) indexById.set(task.id, task);
-  let skipped = 0;
-  for (const result4 of results) {
-    for (const updated of result4.tasks) {
-      const current = indexById.get(updated.id);
-      if (!current) continue;
-      if (!shouldMergeTaskUpdate(current, updated)) {
-        console.debug("[team-runner] Skipping stale merge for task", updated.id, {
-          currentStatus: current.status,
-          updatedStatus: updated.status,
-          currentFinishedAt: current.finishedAt,
-          updatedFinishedAt: updated.finishedAt
-        });
-        skipped += 1;
-        continue;
-      }
-      indexById.set(updated.id, updated);
-    }
-  }
-  const merged = base.map((task) => indexById.get(task.id) ?? task);
-  void skipped;
-  return refreshTaskGraphQueues(merged);
-}
 function formatTaskProgress(task) {
   return `- ${task.id}: ${task.status} (${task.role} -> ${task.agent})${task.taskPacket ? ` scope=${task.taskPacket.scope}` : ""}${task.verification ? ` green=${task.verification.observedGreenLevel}/${task.verification.requiredGreenLevel}` : ""}${task.error ? ` - ${task.error}` : ""}`;
 }
@@ -57188,6 +57296,7 @@ async function executeTeamRun(input) {
   }
   void registerRunPromise(manifest.runId);
   const stopTeamHeartbeat = startTeamRunHeartbeat(manifest.stateRoot, manifest.runId);
+  startPerfSampler(manifest, input.team);
   const cleanupUsage = () => {
     for (const task of input.tasks) clearTrackedTaskUsage(task.id);
   };
@@ -57253,6 +57362,7 @@ async function executeTeamRun(input) {
       );
     }
     await flushEventLogBuffer();
+    schedulePerfAnalyze(manifest, input.team);
     return result4;
   } catch (error) {
     stopTeamHeartbeat();
@@ -58340,15 +58450,13 @@ async function executeTeamRunCore(input, manifest, workflow) {
     await drainPendingUnits(pendingUnits, runController);
   }
 }
-var builtInRegistry, REJECTED_STATUS_MERGE_TRANSITIONS, __test__shouldMergeTaskUpdate, __test__mergeTaskUpdates, lastProgressContentHash, __test__lastProgressContentHash, __test__writeProgress, __test__cancelPlanTasks;
+var OBSERVABILITY_INTERVAL_MS, OBSERVABILITY_ANALYZE_DELAY_MS, lastProgressContentHash, __test__lastProgressContentHash, __test__writeProgress, __test__cancelPlanTasks;
 var init_team_runner = __esm({
   "src/runtime/team-runner.ts"() {
     "use strict";
     init_errors3();
     init_registry2();
     init_correlation();
-    init_plugin_registry();
-    init_plugins();
     init_atomic_write();
     init_contracts();
     init_locks();
@@ -58366,6 +58474,7 @@ var init_team_runner = __esm({
     init_goal_achievement();
     init_group_join();
     init_live_agent_manager();
+    init_merge_gate();
     init_runtime_policy();
     init_path_overlap();
     init_policy_engine();
@@ -58387,32 +58496,10 @@ var init_team_runner = __esm({
     init_usage_tracker();
     init_workflow_state();
     init_adaptive_plan();
+    init_merge_gate();
     init_adaptive_plan();
-    builtInRegistry = new PluginRegistry();
-    builtInRegistry.register(NextJsPlugin);
-    builtInRegistry.register(VitestPlugin);
-    builtInRegistry.register(VitePlugin);
-    REJECTED_STATUS_MERGE_TRANSITIONS = (() => {
-      const rejected = /* @__PURE__ */ new Set();
-      for (const from of TEAM_TASK_STATUSES) {
-        if (!TEAM_TERMINAL_TASK_STATUSES.has(from)) continue;
-        for (const to of TEAM_TASK_STATUSES) {
-          if (!TEAM_TERMINAL_TASK_STATUSES.has(to)) rejected.add(statusMergeKey(from, to));
-        }
-      }
-      rejected.add(statusMergeKey("waiting", "running"));
-      const completedIntegrityFlips = [
-        ["completed", "failed"],
-        ["completed", "needs_attention"],
-        ["failed", "completed"],
-        ["cancelled", "completed"],
-        ["needs_attention", "completed"]
-      ];
-      for (const [from, to] of completedIntegrityFlips) rejected.add(statusMergeKey(from, to));
-      return rejected;
-    })();
-    __test__shouldMergeTaskUpdate = shouldMergeTaskUpdate;
-    __test__mergeTaskUpdates = mergeTaskUpdatesPreservingTerminal;
+    OBSERVABILITY_INTERVAL_MS = 2e3;
+    OBSERVABILITY_ANALYZE_DELAY_MS = 3e3;
     lastProgressContentHash = /* @__PURE__ */ new Map();
     __test__lastProgressContentHash = lastProgressContentHash;
     __test__writeProgress = writeProgress;
@@ -66261,7 +66348,6 @@ var init_mascot = __esm({
       currentArminGrid;
       effectState = {};
       effectDone = false;
-      visible = true;
       frame = 0;
       effectPhase = 0;
       gridVersion = 0;
@@ -66357,7 +66443,7 @@ var init_mascot = __esm({
           this.gridVersion++;
         }
         this.invalidate();
-        if (this.visible) this.requestRender?.();
+        this.requestRender?.();
       }
       tickArminEffect() {
         switch (this.effect) {
@@ -66564,14 +66650,6 @@ var init_mascot = __esm({
           this.close();
         }
       }
-      /**
-       * Set whether the mascot is currently visible (not obscured by another
-       * overlay).  When invisible, tick() skips requestRender so the animation
-       * does not trigger needless repaints while hidden.
-       */
-      setVisible(visible) {
-        this.visible = visible;
-      }
       dispose() {
         this.doneGuard.called = true;
         if (this.interval) clearInterval(this.interval);
@@ -70620,10 +70698,18 @@ var init_otlp_exporter = __esm({
 });
 
 // src/observability/metrics-primitives.ts
-function enforceLabelCap(map3, metricName) {
+function getCardinalityEvictions() {
+  return cardinalityEvictions;
+}
+function enforceLabelCap(map3, _metricName) {
   while (map3.size > MAX_LABEL_COMBINATIONS) {
     const firstKey = map3.keys().next().value;
-    if (firstKey !== void 0) map3.delete(firstKey);
+    if (firstKey !== void 0) {
+      map3.delete(firstKey);
+      cardinalityEvictions++;
+    } else {
+      break;
+    }
   }
 }
 function normalizeLabels(labels = {}) {
@@ -70637,12 +70723,13 @@ function labelKey(labels = {}) {
 function cloneLabels(labels) {
   return { ...labels };
 }
-var DEFAULT_HISTOGRAM_BUCKETS, MAX_LABEL_COMBINATIONS, Metric, Counter, Gauge, Histogram;
+var DEFAULT_HISTOGRAM_BUCKETS, MAX_LABEL_COMBINATIONS, cardinalityEvictions, Metric, Counter, Gauge, Histogram;
 var init_metrics_primitives = __esm({
   "src/observability/metrics-primitives.ts"() {
     "use strict";
     DEFAULT_HISTOGRAM_BUCKETS = [1, 2, 5, 10, 25, 50, 100, 250, 500, 1e3, 2500, 5e3, 1e4];
     MAX_LABEL_COMBINATIONS = 1e4;
+    cardinalityEvictions = 0;
     Metric = class {
       name;
       description;
@@ -70907,6 +70994,14 @@ function wireEventToMetrics(events, registry2) {
   const deadletterCount = registry2.counter("crew.task.deadletter_total", "Deadletter triggers by reason");
   const overflowCount = registry2.counter("crew.task.overflow_phase_total", "Overflow recovery phase transitions");
   const supervisorContactCount = registry2.counter("crew.task.supervisor_contact_total", "Supervisor contact requests by reason");
+  const unboundedConcurrencyCount = registry2.counter(
+    "crew.limits.unbounded_total",
+    "Runs that enabled allowUnboundedConcurrency (advisory; bypasses hard cap)"
+  );
+  const cardinalityEvictedGauge = registry2.gauge(
+    "crew.metrics.cardinality_evicted",
+    "Cumulative label-combination evictions (non-zero = unreliable aggregation)"
+  );
   registry2.gauge("crew.heartbeat.staleness_ms", "Heartbeat elapsed since last seen, milliseconds");
   const runDuration = registry2.histogram(
     "crew.run.duration_ms",
@@ -71006,11 +71101,21 @@ function wireEventToMetrics(events, registry2) {
           direction: stringValue(item.direction, "unknown")
         });
       }
+    ],
+    [
+      "crew.limits.unbounded",
+      () => {
+        unboundedConcurrencyCount.inc({});
+      }
     ]
   ];
   const unsubscribers = [];
   for (const [event, handler] of handlers) {
     const unsubscribe = events?.on?.(event, (data) => {
+      try {
+        cardinalityEvictedGauge.set({}, getCardinalityEvictions());
+      } catch {
+      }
       try {
         handler(data);
       } catch {
@@ -71031,6 +71136,7 @@ var CANCELLATION_REASON_LABELS;
 var init_event_to_metric = __esm({
   "src/observability/event-to-metric.ts"() {
     "use strict";
+    init_metrics_primitives();
     CANCELLATION_REASON_LABELS = /* @__PURE__ */ new Set([
       "caller_cancelled",
       "leader_interrupted",
@@ -72583,7 +72689,7 @@ function isDangerStage(index, levels) {
 init_pi_ui_compat();
 init_theme_adapter();
 init_visual();
-import { isAbsolute as isAbsolute10, relative as relative8, resolve as resolve21, sep as sep9 } from "node:path";
+import { isAbsolute as isAbsolute11, relative as relative8, resolve as resolve21, sep as sep9 } from "node:path";
 
 // src/extension/crew-vibes/render.ts
 function formatCount(value) {
@@ -72720,7 +72826,7 @@ function formatCwdForFooter(cwd, home) {
   const resolvedCwd = resolve21(cwd);
   const resolvedHome = resolve21(home);
   const rel = relative8(resolvedHome, resolvedCwd);
-  const inside = rel === "" || rel !== ".." && !rel.startsWith(`..${sep9}`) && !isAbsolute10(rel);
+  const inside = rel === "" || rel !== ".." && !rel.startsWith(`..${sep9}`) && !isAbsolute11(rel);
   if (!inside) return cwd;
   return rel === "" ? "~" : `~${sep9}${rel}`;
 }
@@ -75285,7 +75391,7 @@ function startForegroundRunImpl(pi, ctx, extensionCtx, runner, runId) {
 init_config();
 import * as fs103 from "node:fs";
 import * as path82 from "node:path";
-import { fileURLToPath as fileURLToPath7 } from "node:url";
+import { fileURLToPath as fileURLToPath8 } from "node:url";
 
 // src/runtime/per-write-validator.ts
 import { readFileSync as readFileSync81 } from "node:fs";
@@ -75388,7 +75494,7 @@ function installResourcesDiscoverHook(pi, ctx) {
     pi.on("resources_discover", () => {
       const sessionCwd = ctx.currentCtx?.cwd ?? process.cwd();
       const skillDir = path82.resolve(sessionCwd, "skills");
-      const extSkillDir = path82.resolve(path82.dirname(fileURLToPath7(import.meta.url)), "..", "..", "skills");
+      const extSkillDir = path82.resolve(path82.dirname(fileURLToPath8(import.meta.url)), "..", "..", "skills");
       const paths = [];
       if (fs103.existsSync(extSkillDir)) paths.push(extSkillDir);
       if (skillDir !== extSkillDir && fs103.existsSync(skillDir)) {
@@ -76011,19 +76117,6 @@ var CrewBroker = class {
     }
     this.resolvedSocketPath = null;
   }
-  /**
-   * Non-throwing enqueue entry point for the post-append mailbox observer
-   * (Phase 1) or any other in-process producer. Phase 0 accepts `notifyMessage`
-   * as a no-op shape so the lifecycle controller can install a single
-   * observer regardless of broker state.
-   *
-   * Fanout goes ONLY to authenticated connections matching the recipient.
-   * Phase 0 keeps this as a typed no-op (`not-implemented` would be
-   * inappropriate here — the caller is in-process and shouldn't be
-   * punished for testing the broker skeleton).
-   */
-  notifyMessage(_message) {
-  }
   // ------------------------------------------------------------------------
   // Connection lifecycle
   // ------------------------------------------------------------------------