pi-crew 0.9.62 → 0.9.65

package/dist/index.mjs

@@ -11513,10 +11513,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 });
   }
@@ -11602,15 +11608,51 @@ var init_frontmatter = __esm({
   }
 });
 
+// src/runtime/role-permission.ts
+function permissionForRole(role) {
+  if (READ_ONLY_ROLES.has(role)) return "read_only";
+  if (WRITE_ROLES.has(role)) return "workspace_write";
+  return "read_only";
+}
+function currentCrewRole(env = process.env) {
+  return env.PI_CREW_ROLE?.trim() || env.PI_TEAMS_ROLE?.trim() || void 0;
+}
+function checkSubagentSpawnPermission(role) {
+  if (!role) return { allowed: true, mode: "workspace_write" };
+  const mode = permissionForRole(role);
+  if (mode === "read_only")
+    return {
+      allowed: false,
+      mode,
+      reason: `Role '${role}' is read-only and cannot spawn additional subagents.`
+    };
+  return { allowed: true, mode };
+}
+var READ_ONLY_ROLES, WRITE_ROLES;
+var init_role_permission = __esm({
+  "src/runtime/role-permission.ts"() {
+    "use strict";
+    READ_ONLY_ROLES = /* @__PURE__ */ new Set(["explorer", "reviewer", "security-reviewer", "analyst", "critic", "planner"]);
+    WRITE_ROLES = /* @__PURE__ */ new Set(["executor", "test-engineer", "writer", "verifier", "agent", "cold-verifier", "chain-executor", "worker"]);
+  }
+});
+
 // src/config/role-tools.ts
 function getToolConfig(role) {
   const key = role.includes("_") ? role.replaceAll("_", "-") : role;
   return ROLE_TOOL_CONFIGS[key] ?? ROLE_TOOL_CONFIGS[role] ?? {};
 }
+function isScratchpadEnabledForRole(role, agent) {
+  const normalized = role.includes("_") ? role.replaceAll("_", "-") : role;
+  if (permissionForRole(normalized) === "read_only") return false;
+  if (agent?.scratchpad === false) return false;
+  return agent?.scratchpad === true || getToolConfig(normalized).scratchpad === true;
+}
 var ROLE_TOOL_CONFIGS;
 var init_role_tools = __esm({
   "src/config/role-tools.ts"() {
     "use strict";
+    init_role_permission();
     ROLE_TOOL_CONFIGS = {
       // Explorer - Read-only exploration; bash is included for git log/show
       // (decisions stream needs commit-history mining) but edit/write stay
@@ -11641,9 +11683,11 @@ var init_role_tools = __esm({
         tools: ["read", "grep", "find", "ls", "glob"],
         excludeTools: ["edit", "write", "bash", "web"]
       },
-      // Executor - Full access (default)
+      // Executor - Full access (default). Phase 1 scratchpad-enabled (stateful
+      // evaluator compounds intermediate results across execute calls).
       executor: {
         // No restrictions - full tool access
+        scratchpad: true
       },
       // Reviewer - Read and review, no write
       reviewer: {
@@ -11670,12 +11714,16 @@ var init_role_tools = __esm({
       // integrity is preserved during verification. Mirrors cold-verifier behavior.
       verifier: {
         tools: ["read", "grep", "find", "ls", "bash"],
-        excludeTools: ["edit", "write", "web"]
+        excludeTools: ["edit", "write", "web"],
+        // Phase 1 scratchpad: multi-cell test/verify flows reuse parsed state.
+        scratchpad: true
       },
       // Test Engineer - Can write tests (F1: hyphenated key)
       "test-engineer": {
         tools: ["read", "edit", "write", "bash", "ls"],
-        excludeTools: ["web"]
+        excludeTools: ["web"],
+        // Phase 1 scratchpad: build/run test suites with state across cells.
+        scratchpad: true
       }
     };
   }
@@ -11891,6 +11939,14 @@ function parseAgentFile(filePath, source) {
       fallbackModels: parseCsv(frontmatter.fallbackModels),
       thinking: frontmatter.thinking === "false" ? void 0 : frontmatter.thinking || void 0,
       tools: parseToolsField(frontmatter.tools),
+      // Phase 1 scratchpad opt-in (Q3: pi ignores unknown frontmatter keys; pi-crew
+      // is the sole consumer in the worker path — task arrives via -p, agent file
+      // is not re-read by pi). 3-STATE parse (NOT `=== "true"` like
+      // inheritProjectContext): omitted/malformed → undefined so the F6 kill-switch
+      // (`agent.scratchpad === false`) only fires on an EXPLICIT `scratchpad: false`,
+      // not on every agent without the key (which would wrongly kill role
+      // default-on). Only the literal "true"/"false" are honored.
+      scratchpad: frontmatter.scratchpad === "true" ? true : frontmatter.scratchpad === "false" ? false : void 0,
       // SEC-1: Strip extensions/excludeExtensions for untrusted project-sourced
       // agents (RCE prevention). Both `project` (.crew/agents/) and
       // `project-pi` (.pi/agents/) are repo-adjacent / untrusted sources —
@@ -12392,6 +12448,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 {
@@ -14860,6 +14918,55 @@ var init_env_filter = __esm({
   }
 });
 
+// src/runtime/scratchpad/snapshot-lookup.ts
+import { lstatSync as lstatSync5, readdirSync as readdirSync8 } from "node:fs";
+import { join as join18 } from "node:path";
+function findLatestScratchpadSnapshot(artifactsRoot, agentId) {
+  const scratchpadDir = join18(artifactsRoot, "scratchpad");
+  let dirStat;
+  try {
+    dirStat = lstatSync5(scratchpadDir);
+  } catch {
+    return null;
+  }
+  if (dirStat.isSymbolicLink() || !dirStat.isDirectory()) return null;
+  let entries;
+  try {
+    entries = readdirSync8(scratchpadDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const prefix = `${agentId}.attempt-`;
+  let best = null;
+  for (const dirent of entries) {
+    if (dirent.isSymbolicLink() || !dirent.isFile()) continue;
+    const name = dirent.name;
+    if (!name.startsWith(prefix) || !name.endsWith(SNAPSHOT_SUFFIX)) continue;
+    const attemptPart = name.slice(prefix.length, name.length - SNAPSHOT_SUFFIX.length);
+    if (!/^\d+$/.test(attemptPart)) continue;
+    const attempt = Number.parseInt(attemptPart, 10);
+    let stat2;
+    try {
+      stat2 = lstatSync5(join18(scratchpadDir, name));
+    } catch {
+      continue;
+    }
+    if (!stat2.isFile()) continue;
+    const hit = { path: join18(scratchpadDir, name), attempt, mtimeMs: stat2.mtimeMs };
+    if (best === null || hit.mtimeMs > best.mtimeMs || hit.mtimeMs === best.mtimeMs && hit.attempt < best.attempt) {
+      best = hit;
+    }
+  }
+  return best;
+}
+var SNAPSHOT_SUFFIX;
+var init_snapshot_lookup = __esm({
+  "src/runtime/scratchpad/snapshot-lookup.ts"() {
+    "use strict";
+    SNAPSHOT_SUFFIX = ".snapshot.json";
+  }
+});
+
 // src/runtime/child-pi/child-pi-spawn.ts
 import * as fs18 from "node:fs";
 import * as path18 from "node:path";
@@ -14956,6 +15063,21 @@ function prepareSpawnContext(input, effectiveTask) {
     if (input.runId) built.env.PI_CREW_BROKER_RUN_ID = input.runId;
     if (input.agentId) built.env.PI_CREW_BROKER_TASK_ID = input.agentId;
   }
+  if (input.agentId && isScratchpadEnabledForRole(input.role ?? input.agent.name, input.agent)) {
+    built.env.PI_CREW_SCRATCHPAD = "1";
+    built.env.PI_CREW_TASK_ID = input.agentId;
+    built.env.PI_CREW_ATTEMPT = String(input.attempt ?? 0);
+    if (input.artifactsRoot) {
+      built.env.PI_CREW_ARTIFACTS_ROOT = input.artifactsRoot;
+    }
+    const scratchTempDir = built.tempDir ?? createSafeTempDir(getPiTempBase(), "pi-crew-scratchpad-");
+    built.env.PI_CREW_SCRATCHPAD_SNAPSHOT = resolveRealContainedPath(scratchTempDir, `${input.agentId}.snapshot.json`);
+    const restoreHit = input.artifactsRoot ? findLatestScratchpadSnapshot(input.artifactsRoot, input.agentId) : null;
+    if (restoreHit) {
+      built.env.PI_CREW_SCRATCHPAD_RESTORE = restoreHit.path;
+      built.env.PI_CREW_SCRATCHPAD_RESTORE_MTIME = String(restoreHit.mtimeMs);
+    }
+  }
   if (input.signal?.aborted) {
     return {
       kind: "aborted",
@@ -14983,11 +15105,14 @@ var BASE_ALLOWLIST;
 var init_child_pi_spawn = __esm({
   "src/runtime/child-pi/child-pi-spawn.ts"() {
     "use strict";
+    init_role_tools();
     init_env_allowlist();
     init_env_filter();
     init_internal_error();
+    init_safe_paths();
     init_pi_args();
     init_pi_spawn();
+    init_snapshot_lookup();
     BASE_ALLOWLIST = [
       "PATH",
       "HOME",
@@ -22287,7 +22412,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,
@@ -23005,12 +23141,12 @@ var init_crew_hooks = __esm({
 
 // src/runtime/skill-effectiveness.ts
 import { existsSync as existsSync23, mkdirSync as mkdirSync14, readFileSync as readFileSync23, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname16, join as join29 } from "node:path";
+import { dirname as dirname16, join as join30 } from "node:path";
 function getSkillMetricsPath(cwd, runId) {
-  return join29(projectCrewRoot(cwd), `state/runs/${runId}/skill-metrics.jsonl`);
+  return join30(projectCrewRoot(cwd), `state/runs/${runId}/skill-metrics.jsonl`);
 }
 function getSkillActivationsPath(cwd, runId) {
-  return join29(projectCrewRoot(cwd), `state/runs/${runId}/skill-activations.jsonl`);
+  return join30(projectCrewRoot(cwd), `state/runs/${runId}/skill-activations.jsonl`);
 }
 function ensureSkillMetricsDir(cwd, runId) {
   const dir = dirname16(getSkillMetricsPath(cwd, runId));
@@ -23725,10 +23861,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
@@ -33743,35 +33881,6 @@ var init_live_session_runtime = __esm({
   }
 });
 
-// src/runtime/role-permission.ts
-function permissionForRole(role) {
-  if (READ_ONLY_ROLES.has(role)) return "read_only";
-  if (WRITE_ROLES.has(role)) return "workspace_write";
-  return "read_only";
-}
-function currentCrewRole(env = process.env) {
-  return env.PI_CREW_ROLE?.trim() || env.PI_TEAMS_ROLE?.trim() || void 0;
-}
-function checkSubagentSpawnPermission(role) {
-  if (!role) return { allowed: true, mode: "workspace_write" };
-  const mode = permissionForRole(role);
-  if (mode === "read_only")
-    return {
-      allowed: false,
-      mode,
-      reason: `Role '${role}' is read-only and cannot spawn additional subagents.`
-    };
-  return { allowed: true, mode };
-}
-var READ_ONLY_ROLES, WRITE_ROLES;
-var init_role_permission = __esm({
-  "src/runtime/role-permission.ts"() {
-    "use strict";
-    READ_ONLY_ROLES = /* @__PURE__ */ new Set(["explorer", "reviewer", "security-reviewer", "analyst", "critic", "planner"]);
-    WRITE_ROLES = /* @__PURE__ */ new Set(["executor", "test-engineer", "writer", "verifier", "agent", "cold-verifier", "chain-executor", "worker"]);
-  }
-});
-
 // src/state/coordination/task-claims.ts
 import { randomUUID as randomUUID4, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 function createTaskClaim(owner, leaseMs = 5 * 6e4, now = /* @__PURE__ */ new Date()) {
@@ -39426,6 +39535,7 @@ function serializeAgent(agent) {
     line("fallbackModels", agent.fallbackModels),
     line("thinking", agent.thinking),
     line("tools", agent.tools),
+    line("scratchpad", agent.scratchpad),
     agent.extensions !== void 0 ? line("extensions", agent.extensions) ?? "extensions:" : void 0,
     line("skills", agent.skills),
     line("systemPromptMode", agent.systemPromptMode),
@@ -39476,6 +39586,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),
@@ -40772,9 +40883,9 @@ var init_handle_settings = __esm({
 
 // src/extension/team-tool/workflow-manage.ts
 import { existsSync as existsSync41, readFileSync as readFileSync40, rmSync as rmSync14, writeFileSync as writeFileSync7 } from "node:fs";
-import { dirname as dirname29, join as join45 } from "node:path";
+import { dirname as dirname29, join as join46 } from "node:path";
 function allowedWorkflowDirs(cwd) {
-  return [join45(projectCrewRoot(cwd), "workflows"), join45(userPiRoot(), "workflows"), join45(packageRoot(), "workflows")];
+  return [join46(projectCrewRoot(cwd), "workflows"), join46(userPiRoot(), "workflows"), join46(packageRoot(), "workflows")];
 }
 function validateScriptContent(content) {
   for (const pattern of FORBIDDEN_PATTERNS) {
@@ -40786,7 +40897,7 @@ function validateScriptContent(content) {
 }
 function resolveWorkflowWritePath(cwd, name, scope = "project") {
   assertSafePathId("workflowName", name);
-  const base = scope === "user" ? join45(userPiRoot(), "workflows") : join45(projectCrewRoot(cwd), "workflows");
+  const base = scope === "user" ? join46(userPiRoot(), "workflows") : join46(projectCrewRoot(cwd), "workflows");
   return resolveRealContainedPath(base, `${name}.dwf.ts`);
 }
 function handleWorkflowCreate(params, ctx) {
@@ -41640,7 +41751,7 @@ var init_async_runner = __esm({
 });
 
 // src/runtime/goal-workflow/goal-state-store.ts
-import { closeSync as closeSync10, existsSync as existsSync44, mkdirSync as mkdirSync26, openSync as openSync10, readdirSync as readdirSync20, readFileSync as readFileSync42, statSync as statSync33, unlinkSync as unlinkSync7 } from "node:fs";
+import { closeSync as closeSync10, existsSync as existsSync44, mkdirSync as mkdirSync26, openSync as openSync10, readdirSync as readdirSync21, readFileSync as readFileSync42, statSync as statSync33, unlinkSync as unlinkSync7 } from "node:fs";
 import { dirname as dirname32 } from "node:path";
 function resolveGoalsRoot(cwd) {
   const crewRoot = projectCrewRoot(cwd) ?? userCrewRoot();
@@ -41800,7 +41911,7 @@ var init_goal_state_store = __esm({
         try {
           const root = resolveGoalsRoot(this.cwd);
           if (!existsSync44(root)) return [];
-          const entries = readdirSync20(root);
+          const entries = readdirSync21(root);
           const goals = [];
           for (const entry of entries) {
             if (!entry.endsWith(".json")) continue;
@@ -41864,7 +41975,7 @@ var init_verification_integrity = __esm({
 
 // src/runtime/workspace-lock.ts
 import { createHash as createHash7 } from "node:crypto";
-import { closeSync as closeSync11, existsSync as existsSync45, mkdirSync as mkdirSync27, openSync as openSync11, readdirSync as readdirSync21, readFileSync as readFileSync44, statSync as statSync35, unlinkSync as unlinkSync8, writeFileSync as writeFileSync8 } from "node:fs";
+import { closeSync as closeSync11, existsSync as existsSync45, mkdirSync as mkdirSync27, openSync as openSync11, readdirSync as readdirSync22, readFileSync as readFileSync44, statSync as statSync35, unlinkSync as unlinkSync8, writeFileSync as writeFileSync8 } from "node:fs";
 import * as path50 from "node:path";
 function workspaceLockPath(cwd) {
   const absCwd = path50.resolve(cwd);
@@ -45069,7 +45180,8 @@ __export(crash_recovery_exports, {
   detectInterruptedRuns: () => detectInterruptedRuns,
   purgeStaleActiveRunIndex: () => purgeStaleActiveRunIndex,
   readManifestWithTransientRetry: () => readManifestWithTransientRetry,
-  reconcileAllStaleRuns: () => reconcileAllStaleRuns
+  reconcileAllStaleRuns: () => reconcileAllStaleRuns,
+  shouldRecoverTask: () => shouldRecoverTask
 });
 import * as fs63 from "node:fs";
 import * as path52 from "node:path";
@@ -48365,6 +48477,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;
@@ -48373,7 +48488,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);
@@ -49235,112 +49350,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";
@@ -50380,6 +50389,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";
@@ -51732,75 +51901,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";
@@ -53188,6 +53288,20 @@ function detectRetryableModelFailureFromOutput(parsed) {
   }
   return void 0;
 }
+function evidenceStatusFor(childResult) {
+  return childResult.exitStatus?.cancelled ? "cancelled" : childResult.error || childResult.exitCode && childResult.exitCode !== 0 ? "failed" : "completed";
+}
+function attemptErrorFor(childResult, parsedOutput, taskId) {
+  let err2 = childResult.error || (childResult.exitCode && childResult.exitCode !== 0 ? childResult.stderr || `Child Pi exited with ${childResult.exitCode}` : void 0);
+  if (childResult.exitStatus?.timedOut) {
+    err2 = errors.childTimeout({ taskId, stderr: childResult.stderr }).message;
+  }
+  if (!err2 && parsedOutput) {
+    const rateLimitErr = detectRetryableModelFailureFromOutput(parsedOutput);
+    if (rateLimitErr) err2 = rateLimitErr;
+  }
+  return err2;
+}
 async function runChildProcessTask(ctx) {
   const input = ctx.input;
   const manifest = ctx.manifest;
@@ -53371,6 +53485,7 @@ async function runChildProcessTask(ctx) {
         runId: manifest.runId,
         agentId: task.id,
         artifactsRoot: manifest.artifactsRoot,
+        attempt: i,
         steeringFile: resolveRealContainedPath(`${manifest.artifactsRoot}/steering`, `${task.id}.jsonl`),
         onSpawn: (pid) => {
           try {
@@ -53459,7 +53574,7 @@ async function runChildProcessTask(ctx) {
         input.signal.removeEventListener("abort", externalAbortListener);
       }
     }
-    const evidenceStatus = childResult.exitStatus?.cancelled ? "cancelled" : childResult.error || childResult.exitCode && childResult.exitCode !== 0 ? "failed" : "completed";
+    const evidenceStatus = evidenceStatusFor(childResult);
     terminalEvidence = [
       ...terminalEvidence,
       {
@@ -53505,17 +53620,7 @@ async function runChildProcessTask(ctx) {
     parsedOutput = parsePiJsonOutput(transcriptText2);
     rawFinalText = childResult.rawFinalText;
     intermediateFindings = childResult.intermediateFindings;
-    error = childResult.error || (childResult.exitCode && childResult.exitCode !== 0 ? childResult.stderr || `Child Pi exited with ${childResult.exitCode}` : void 0);
-    if (childResult.exitStatus?.timedOut) {
-      error = errors.childTimeout({
-        taskId: task.id,
-        stderr: childResult.stderr
-      }).message;
-    }
-    if (!error && parsedOutput) {
-      const rateLimitErr = detectRetryableModelFailureFromOutput(parsedOutput);
-      if (rateLimitErr) error = rateLimitErr;
-    }
+    error = attemptErrorFor(childResult, parsedOutput, task.id);
     persistHeartbeat(true);
     persistChildProgress({ type: "attempt_finished" }, true);
     const attempt = {
@@ -56692,12 +56797,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 = () => {
@@ -56721,6 +56827,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);
@@ -56764,9 +56951,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) => {
@@ -56775,63 +56959,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}` : ""}`;
 }
@@ -57093,6 +57220,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);
   };
@@ -57158,6 +57286,7 @@ async function executeTeamRun(input) {
       );
     }
     await flushEventLogBuffer();
+    schedulePerfAnalyze(manifest, input.team);
     return result4;
   } catch (error) {
     stopTeamHeartbeat();
@@ -58245,15 +58374,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();
@@ -58271,6 +58398,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();
@@ -58292,32 +58420,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;
@@ -61073,7 +61179,7 @@ __export(dynamic_workflow_runner_exports, {
   runDynamicWorkflow: () => runDynamicWorkflow
 });
 import { readFileSync as readFileSync67 } from "node:fs";
-import { join as join71 } from "node:path";
+import { join as join72 } from "node:path";
 import { transformSync } from "esbuild";
 function assertStructuredCloneable(value, name) {
   try {
@@ -61085,7 +61191,7 @@ function assertStructuredCloneable(value, name) {
 }
 function resolveScriptPath(workflow, cwd) {
   const crewRoot = projectCrewRoot(cwd);
-  const allowedBases = [join71(projectCrewRoot(cwd), "workflows"), join71(userPiRoot(), "workflows"), join71(packageRoot(), "workflows")];
+  const allowedBases = [join72(projectCrewRoot(cwd), "workflows"), join72(userPiRoot(), "workflows"), join72(packageRoot(), "workflows")];
   for (const base of allowedBases) {
     try {
       const real = resolveRealContainedPath(base, workflow.filePath);
@@ -66166,7 +66272,6 @@ var init_mascot = __esm({
       currentArminGrid;
       effectState = {};
       effectDone = false;
-      visible = true;
       frame = 0;
       effectPhase = 0;
       gridVersion = 0;
@@ -66262,7 +66367,7 @@ var init_mascot = __esm({
           this.gridVersion++;
         }
         this.invalidate();
-        if (this.visible) this.requestRender?.();
+        this.requestRender?.();
       }
       tickArminEffect() {
         switch (this.effect) {
@@ -66469,14 +66574,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);
@@ -70525,10 +70622,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 = {}) {
@@ -70542,12 +70647,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;
@@ -70812,6 +70918,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",
@@ -70911,11 +71025,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 {
@@ -70936,6 +71060,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",
@@ -72238,20 +72363,20 @@ init_internal_error();
 
 // src/extension/crew-vibes/config.ts
 import { existsSync as existsSync75, mkdirSync as mkdirSync42, readFileSync as readFileSync74, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname39, join as join77 } from "node:path";
+import { dirname as dirname39, join as join78 } from "node:path";
 
 // src/extension/crew-vibes/font-detect.ts
 import { existsSync as existsSync74, readFileSync as readFileSync73 } from "node:fs";
 import { homedir as homedir11, platform } from "node:os";
-import { join as join76 } from "node:path";
+import { join as join77 } from "node:path";
 function fontPath() {
   const os18 = platform();
   const home = homedir11();
-  if (os18 === "darwin") return join76(home, "Library", "Fonts", "crew-vibes.ttf");
-  if (os18 === "linux") return join76(home, ".local", "share", "fonts", "crew-vibes.ttf");
+  if (os18 === "darwin") return join77(home, "Library", "Fonts", "crew-vibes.ttf");
+  if (os18 === "linux") return join77(home, ".local", "share", "fonts", "crew-vibes.ttf");
   if (os18 === "win32") {
-    const local = process.env.LOCALAPPDATA ?? join76(home, "AppData", "Local");
-    return join76(local, "Microsoft", "Windows", "Fonts", "crew-vibes.ttf");
+    const local = process.env.LOCALAPPDATA ?? join77(home, "AppData", "Local");
+    return join77(local, "Microsoft", "Windows", "Fonts", "crew-vibes.ttf");
   }
   return "";
 }
@@ -72300,7 +72425,7 @@ function resolveHome() {
   return (process.env.PI_TEAMS_HOME ?? process.env.PI_CREW_HOME)?.trim() || process.env.HOME || process.env.USERPROFILE || "";
 }
 function configPath2() {
-  return join77(resolveHome(), ".pi", "agent", "pi-crew-vibes.json");
+  return join78(resolveHome(), ".pi", "agent", "pi-crew-vibes.json");
 }
 var DEFAULT_CONFIG2 = {
   enabled: true,
@@ -72488,7 +72613,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) {
@@ -72625,7 +72750,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}`;
 }
@@ -72800,14 +72925,14 @@ function createCrewVibesFooter(deps) {
 // src/extension/crew-vibes/provider-usage.ts
 import { readFileSync as readFileSync75 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
-import { join as join78 } from "node:path";
+import { join as join79 } 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 join78(homedir12(), ".pi", "agent", "auth.json");
+  return join79(homedir12(), ".pi", "agent", "auth.json");
 }
 function loadAnthropicToken() {
   const envToken = process.env.ANTHROPIC_OAUTH_TOKEN?.trim();
@@ -72852,8 +72977,8 @@ function tokenFromHostEntry(entry) {
   return void 0;
 }
 function loadLegacyCopilotToken() {
-  const configHome = process.env.XDG_CONFIG_HOME?.trim() || join78(homedir12(), ".config");
-  const candidates = [join78(configHome, "github-copilot", "hosts.json"), join78(homedir12(), ".github-copilot", "hosts.json")];
+  const configHome = process.env.XDG_CONFIG_HOME?.trim() || join79(homedir12(), ".config");
+  const candidates = [join79(configHome, "github-copilot", "hosts.json"), join79(homedir12(), ".github-copilot", "hosts.json")];
   for (const hostsPath of candidates) {
     try {
       const data = JSON.parse(readFileSync75(hostsPath, "utf8"));
@@ -75190,7 +75315,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";
@@ -75293,7 +75418,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)) {
@@ -75916,19 +76041,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
   // ------------------------------------------------------------------------