pi-crew 0.9.17 → 0.9.19

package/dist/index.mjs

@@ -9058,7 +9058,7 @@ function flushOnePendingAtomicWrite(filePath) {
         pendingAtomicWrites.delete(filePath);
         throw error;
       }
-      const backoffMs = Math.min(3e4, current2.coalesceMs * Math.pow(2, current2.retryCount - 1));
+      const backoffMs = Math.min(3e4, current2.coalesceMs * 2 ** (current2.retryCount - 1));
       const timer = setTimeout(() => flushOnePendingAtomicWrite(filePath), backoffMs);
       timer.unref();
       current2.timer = timer;
@@ -9701,9 +9701,14 @@ var init_suggestions = __esm({
 // src/config/config.ts
 var config_exports = {};
 __export(config_exports, {
+  __test__configCacheSize: () => __test__configCacheSize,
+  __test__getConfigCacheEntry: () => __test__getConfigCacheEntry,
+  __test__getConfigCacheTtlMs: () => __test__getConfigCacheTtlMs,
+  __test__setConfigCacheTtlMs: () => __test__setConfigCacheTtlMs,
   asRecord: () => asRecord,
   configPath: () => configPath,
   effectiveAutonomousConfig: () => effectiveAutonomousConfig,
+  invalidateConfigCache: () => invalidateConfigCache,
   legacyConfigPath: () => legacyConfigPath,
   loadConfig: () => loadConfig,
   parseConfig: () => parseConfig,
@@ -9716,6 +9721,70 @@ __export(config_exports, {
 import * as fs5 from "node:fs";
 import * as os3 from "node:os";
 import * as path5 from "node:path";
+function __test__setConfigCacheTtlMs(ttlMs) {
+  configCacheTtlMsOverride = ttlMs;
+}
+function __test__getConfigCacheTtlMs() {
+  return configCacheTtlMsOverride ?? CONFIG_CACHE_TTL_MS;
+}
+function __test__getConfigCacheEntry(parts) {
+  return configCache.get(buildConfigCacheKey(parts));
+}
+function __test__configCacheSize() {
+  return configCache.size;
+}
+function buildConfigCacheKey(parts) {
+  return JSON.stringify([parts.filePath, parts.legacyPath, parts.projectPath, parts.projectPiCrewJsonPath, parts.cwd]);
+}
+function statMtimeMs(filePath) {
+  try {
+    return fs5.statSync(filePath).mtimeMs;
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+}
+function readCachedConfigParts(filePath, legacyPath, cwd) {
+  const projectPath2 = cwd ? projectConfigPath(cwd) : "";
+  const piCrewJsonPath = cwd ? projectPiCrewJsonPath(cwd) : "";
+  return {
+    filePath,
+    legacyPath,
+    projectPath: projectPath2,
+    projectPiCrewJsonPath: piCrewJsonPath,
+    cwd: cwd ?? null
+  };
+}
+function readCacheMtimes(parts) {
+  const mtimes = {};
+  for (const p of [parts.filePath, parts.legacyPath, parts.projectPath, parts.projectPiCrewJsonPath]) {
+    if (!p) continue;
+    const m = statMtimeMs(p);
+    if (m !== void 0) mtimes[p] = m;
+  }
+  return mtimes;
+}
+function matchesCachedMtimes(cached, current2) {
+  const cachedKeys = Object.keys(cached);
+  const currentKeys = Object.keys(current2);
+  if (cachedKeys.length !== currentKeys.length) return false;
+  for (const key of cachedKeys) {
+    if (current2[key] !== cached[key]) return false;
+  }
+  return true;
+}
+function setConfigCache(key, value, mtimes) {
+  if (configCache.has(key)) configCache.delete(key);
+  configCache.set(key, { value, mtimes, cachedAt: Date.now() });
+  const ttlMs = configCacheTtlMsOverride ?? CONFIG_CACHE_TTL_MS;
+  const now = Date.now();
+  for (const [k, entry] of configCache.entries()) {
+    if (now - entry.cachedAt > ttlMs) configCache.delete(k);
+  }
+}
+function invalidateConfigCache() {
+  configCache.clear();
+}
 function resolveHomeDir() {
   const envValue = process.env.PI_TEAMS_HOME?.trim();
   const defaultHome = os3.homedir();
@@ -10448,6 +10517,18 @@ function readOptionalConfig(filePath) {
 function loadConfig(cwd) {
   const filePath = configPath();
   const legacyPath = legacyConfigPath();
+  const cacheParts = readCachedConfigParts(filePath, legacyPath, cwd);
+  const cacheKey2 = buildConfigCacheKey(cacheParts);
+  const cached = configCache.get(cacheKey2);
+  const ttlMs = configCacheTtlMsOverride ?? CONFIG_CACHE_TTL_MS;
+  if (cached && Date.now() - cached.cachedAt <= ttlMs) {
+    const currentMtimes = readCacheMtimes(cacheParts);
+    if (matchesCachedMtimes(cached.mtimes, currentMtimes)) {
+      configCache.delete(cacheKey2);
+      configCache.set(cacheKey2, cached);
+      return cached.value;
+    }
+  }
   const paths = cwd ? [filePath, projectConfigPath(cwd)] : [filePath];
   const warnings = [];
   const legacyConfig = readOptionalConfig(legacyPath);
@@ -10480,12 +10561,16 @@ function loadConfig(cwd) {
       paths.push(piCrewJsonPath);
     }
   }
-  return {
+  const result4 = {
     path: filePath,
     paths,
     config,
     warnings: warnings.length > 0 ? warnings : void 0
   };
+  if (Object.keys(readCacheMtimes(cacheParts)).length > 0) {
+    setConfigCache(cacheKey2, result4, readCacheMtimes(cacheParts));
+  }
+  return result4;
 }
 function updateConfig(patch, options = {}) {
   const filePath = options.scope === "project" && options.cwd ? projectConfigPath(options.cwd) : configPath();
@@ -10507,6 +10592,7 @@ function updateConfig(patch, options = {}) {
     fs5.mkdirSync(path5.dirname(filePath), { recursive: true });
     atomicWriteFile(filePath, `${JSON.stringify(merged, null, 2)}
 `);
+    invalidateConfigCache();
     return { path: filePath, config: merged };
   });
 }
@@ -10525,10 +10611,11 @@ function updateAutonomousConfig(patch) {
     current2.autonomous = { ...currentAutonomous, ...patch };
     atomicWriteFile(filePath, `${JSON.stringify(current2, null, 2)}
 `);
+    invalidateConfigCache();
     return { path: filePath, config: parseConfig(current2) };
   });
 }
-var KNOWN_TOP_LEVEL_KEYS, LIMIT_CEILINGS, DANGEROUS_OBJECT_KEYS;
+var CONFIG_CACHE_TTL_MS, configCache, configCacheTtlMsOverride, KNOWN_TOP_LEVEL_KEYS, LIMIT_CEILINGS, DANGEROUS_OBJECT_KEYS;
 var init_config = __esm({
   "src/config/config.ts"() {
     "use strict";
@@ -10540,6 +10627,9 @@ var init_config = __esm({
     init_internal_error();
     init_paths();
     init_suggestions();
+    CONFIG_CACHE_TTL_MS = 2e3;
+    configCache = /* @__PURE__ */ new Map();
+    configCacheTtlMsOverride = null;
     KNOWN_TOP_LEVEL_KEYS = Object.keys(PiTeamsConfigSchema.properties ?? {});
     LIMIT_CEILINGS = {
       maxConcurrentWorkers: 1024,
@@ -12231,7 +12321,7 @@ function resolveCanonicalPath(p) {
 }
 function resolveWindowsCanonical(p) {
   try {
-    let real = fs9.realpathSync.native(p);
+    const real = fs9.realpathSync.native(p);
     if (real.includes("$Extend") || real.includes("$Deleted")) throw new Error("NTFS internal path");
     return real;
   } catch {
@@ -12331,7 +12421,6 @@ function resolveRealContainedPath(baseDir, targetPath2) {
       if (error.code === "EPERM" && process.platform === "win32") continue;
       if (error.code !== "ENOENT") throw error;
       if (i2 === resolvedParts.length - 1) continue;
-      continue;
     }
   }
   let targetFd;
@@ -12945,6 +13034,7 @@ __export(state_store_exports, {
   saveRunManifestAsync: () => saveRunManifestAsync,
   saveRunTasks: () => saveRunTasks,
   saveRunTasksAsync: () => saveRunTasksAsync,
+  saveRunTasksCoalesced: () => saveRunTasksCoalesced,
   updateRunStatus: () => updateRunStatus
 });
 import * as fs12 from "node:fs";
@@ -13199,6 +13289,15 @@ function saveRunTasks(manifest, tasks) {
     tasksSize: tasksStat.size
   });
 }
+function saveRunTasksCoalesced(manifest, tasks) {
+  invalidateRunCache(manifest.stateRoot);
+  try {
+    fs12.statSync(manifest.stateRoot);
+  } catch {
+    return;
+  }
+  atomicWriteJsonCoalesced(manifest.tasksPath, tasks);
+}
 async function saveRunTasksAsync(manifest, tasks) {
   invalidateRunCache(manifest.stateRoot);
   try {
@@ -18590,7 +18689,7 @@ ${JSON.stringify({ type: "message_end", usage: { input: 10, output: 5, cost: 1e-
         pendingOperations.clear();
       };
       let softLimitReached = false;
-      let steerInjectionFailed = false;
+      const steerInjectionFailed = false;
       const maxTurns = input.maxTurns;
       let graceTurns = input.graceTurns;
       if (graceTurns !== void 0 && graceTurns > 1e3) graceTurns = 1e3;
@@ -44753,7 +44852,6 @@ function loadRunSummaries(cwd, options = {}) {
         // tasks stored separately, not in manifest
       });
     } catch {
-      continue;
     }
   }
   return summaries;
@@ -46506,6 +46604,17 @@ var init_team_tool_schema = __esm({
         // "description-only schema" strict-provider check.
         Type.Any()
       ),
+      analysis: Type.Optional(
+        Type.String({
+          maxLength: 1e5,
+          description: "Inline analysis/context notes from the calling session. Persisted to artifacts/{runId}/shared/analysis.md (audit trail) and auto-injected into any workflow step declaring reads: analysis.md (e.g. builtin 'plan-execute'). Mutually exclusive with analysisPath. Ignored by goal-wrapped runs and chain dispatch in v1."
+        })
+      ),
+      analysisPath: Type.Optional(
+        Type.String({
+          description: "Path to an existing markdown analysis file (resolved within cwd). Copied into shared/analysis.md. Mutually exclusive with analysis."
+        })
+      ),
       focus: Type.Optional(
         Type.String({
           description: "Sub-focus for the doctor action. 'zombies' runs a READ-ONLY scan for orphaned pi-crew sub-agent processes (identified by PI_CREW_KIND=subagent); it never kills and never matches the user's interactive main session."
@@ -47299,7 +47408,6 @@ function snapshotManifests(cwd) {
       const content = fs59.readFileSync(abs);
       snapshot[rel] = createHash6("sha256").update(content).digest("hex");
     } catch {
-      continue;
     }
   }
   return snapshot;
@@ -47481,7 +47589,7 @@ function getBackgroundRunnerCommand(runnerPath, cwd, runId, loaderInput = resolv
   };
 }
 async function spawnBackgroundTeamRun(manifest) {
-  const runnerPath = path52.join(path52.dirname(fileURLToPath6(import.meta.url)), "background-runner.ts");
+  const runnerPath = path52.join(packageRoot(), "src", "runtime", "background-runner.ts");
   const logPath = path52.join(manifest.stateRoot, "background.log");
   fs60.mkdirSync(manifest.stateRoot, { recursive: true });
   const filteredEnv = sanitizeEnvSecrets(process.env, {
@@ -47571,6 +47679,7 @@ var init_async_runner = __esm({
     init_env_allowlist();
     init_env_filter();
     init_internal_error();
+    init_paths();
     init_orphan_worker_registry();
     init_peer_dep();
     requireFromHere = createRequire3(import.meta.url);
@@ -53140,18 +53249,6 @@ var init_branch_freshness = __esm({
   }
 });
 
-// src/runtime/team-runner-artifacts.ts
-function mergeArtifacts(items) {
-  const byPath = /* @__PURE__ */ new Map();
-  for (const item of items) byPath.set(item.path, item);
-  return [...byPath.values()];
-}
-var init_team_runner_artifacts = __esm({
-  "src/runtime/team-runner-artifacts.ts"() {
-    "use strict";
-  }
-});
-
 // src/runtime/coalesce-tasks.ts
 function planCoalescedGroups(readyTaskIds, tasks, workflow, enabled, maxGroupSize = DEFAULT_MAX_GROUP_SIZE, maxGroupBytes = DEFAULT_MAX_GROUP_BYTES) {
   if (!enabled || readyTaskIds.length === 0) return [];
@@ -53278,757 +53375,273 @@ var init_coalesce_tasks = __esm({
   }
 });
 
-// src/runtime/task-runner/output-splitter.ts
-function splitCoalescedOutput(rawOutput, taskIds) {
-  if (taskIds.length === 0) return [];
-  if (taskIds.length === 1) {
-    return [{ taskId: taskIds[0], text: rawOutput, strategy: "delimiter" }];
-  }
-  const byId = /* @__PURE__ */ new Map();
-  const delimiterHits = /* @__PURE__ */ new Set();
-  const delimiterRegex = /<<<TASK_RESULT:([^\s>]+)>>>([\s\S]*?)<<<END_TASK_RESULT>>>/g;
-  let match;
-  while ((match = delimiterRegex.exec(rawOutput)) !== null) {
-    const id = match[1];
-    const body = match[2].trim();
-    if (taskIds.includes(id) && !byId.has(id)) {
-      byId.set(id, body);
-      delimiterHits.add(id);
-    }
-  }
-  if (delimiterHits.size === taskIds.length) {
-    return taskIds.map((id) => ({
-      taskId: id,
-      text: byId.get(id) ?? "",
-      strategy: "delimiter"
-    }));
+// src/runtime/concurrency.ts
+function defaultWorkflowConcurrency(workflowName, workflowMaxConcurrency) {
+  if (workflowMaxConcurrency !== void 0) return workflowMaxConcurrency;
+  if (workflowName === "parallel-research") return DEFAULT_CONCURRENCY.workflow.parallelResearch;
+  if (workflowName === "research") return DEFAULT_CONCURRENCY.workflow.research;
+  if (workflowName === "implementation") return DEFAULT_CONCURRENCY.workflow.implementation;
+  if (workflowName === "review") return DEFAULT_CONCURRENCY.workflow.review;
+  if (workflowName === "default") return DEFAULT_CONCURRENCY.workflow.default;
+  return DEFAULT_CONCURRENCY.fallback;
+}
+function positiveInteger2(value) {
+  if (value === void 0 || !Number.isFinite(value)) return void 0;
+  return Math.max(1, Math.trunc(value));
+}
+function resolveBatchConcurrency(input) {
+  const workflowMax = positiveInteger2(input.workflowMaxConcurrency);
+  const defaultConcurrency = defaultWorkflowConcurrency(input.workflowName, workflowMax);
+  const limitMax = positiveInteger2(input.limitMaxConcurrentWorkers);
+  const teamMax = positiveInteger2(input.teamMaxConcurrency);
+  const requested = limitMax ?? teamMax ?? workflowMax ?? defaultWorkflowConcurrency(input.workflowName);
+  let source;
+  if (limitMax !== void 0) source = "limit";
+  else if (teamMax !== void 0) source = "team";
+  else source = "workflow";
+  const hardCap = positiveInteger2(input.hardCap) ?? DEFAULT_CONCURRENCY.hardCap;
+  const maxConcurrent = input.allowUnboundedConcurrency ? requested : Math.min(requested, hardCap);
+  const readyCount = Math.max(0, Math.trunc(Number.isFinite(input.readyCount) ? input.readyCount : 0));
+  const cappedReason = maxConcurrent < requested ? `;capped:${hardCap}` : "";
+  const unboundedReason = input.allowUnboundedConcurrency && requested > hardCap ? `;unbounded:${hardCap}` : "";
+  return {
+    maxConcurrent,
+    selectedCount: readyCount === 0 ? 0 : Math.min(readyCount, maxConcurrent),
+    defaultConcurrency,
+    reason: `${source}:${requested}${cappedReason}${unboundedReason};ready:${readyCount}`
+  };
+}
+var init_concurrency = __esm({
+  "src/runtime/concurrency.ts"() {
+    "use strict";
+    init_defaults();
   }
-  if (delimiterHits.size === 0) {
-    const bySection = parseBySectionHeadings(rawOutput, taskIds);
-    if (bySection.size === taskIds.length) {
-      return taskIds.map((id) => ({
-        taskId: id,
-        text: bySection.get(id) ?? "",
-        strategy: "section"
-      }));
-    }
+});
+
+// src/runtime/goal-achievement.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+function workflowIsMutating(workflow) {
+  const steps = workflow?.steps ?? [];
+  return steps.some((step) => typeof step?.role === "string" && MUTATING_ROLES2.has(step.role));
+}
+function isGitWorkingTreeClean(cwd) {
+  try {
+    const repoRoot = findRepoRoot(cwd);
+    if (!repoRoot) return { clean: "unknown", repoRoot: void 0 };
+    const res = spawnSync2("git", ["-C", repoRoot, "status", "--porcelain"], { encoding: "utf8", timeout: 5e3 });
+    if (res.error || res.status !== 0) return { clean: "unknown", repoRoot: void 0 };
+    return { clean: res.stdout.trim().length === 0, repoRoot };
+  } catch {
+    return { clean: "unknown", repoRoot: void 0 };
   }
-  return taskIds.map((id) => ({
-    taskId: id,
-    text: rawOutput,
-    strategy: "broadcast"
-  }));
 }
-function parseBySectionHeadings(rawOutput, taskIds) {
-  const result4 = /* @__PURE__ */ new Map();
-  const numberedRegex = /^(#{2,3})\s+Task\s+(\d+)\s+of\s+\d+.*$/gm;
-  const sections = [];
-  let m;
-  while ((m = numberedRegex.exec(rawOutput)) !== null) {
-    sections.push({ num: Number(m[2]), start: m.index + m[0].length });
+function assessGoalAchievement(manifest, tasks, workflow) {
+  if (!workflowIsMutating(workflow)) {
+    return {
+      achieved: "unknown",
+      reason: "read-only / doc-only workflow (no executor/test-engineer steps)",
+      signals: []
+    };
   }
-  if (sections.length >= taskIds.length) {
-    sections.sort((a, b) => a.start - b.start);
-    for (let i2 = 0; i2 < sections.length && i2 < taskIds.length; i2 += 1) {
-      const section2 = sections[i2];
-      const end = sections[i2 + 1]?.start ?? rawOutput.length;
-      const text = rawOutput.slice(section2.start, end).trim();
-      const taskId = taskIds[i2];
-      if (taskId) result4.set(taskId, text);
-    }
-    return result4;
+  const tree = isGitWorkingTreeClean(manifest.cwd);
+  if (tree.clean === "unknown" || !tree.repoRoot) {
+    return {
+      achieved: "unknown",
+      reason: "not a git repo or git unavailable",
+      signals: []
+    };
   }
-  const idHeaderRegex = /^(#{2,3})\s+Task\s+([^\s].*?)$/gm;
-  while ((m = idHeaderRegex.exec(rawOutput)) !== null) {
-    const headerText = m[2].trim();
-    const matchedId = taskIds.find((id) => headerText.includes(id));
-    if (matchedId && !result4.has(matchedId)) {
-      result4.set(matchedId, "");
-    }
+  if (!tree.clean) {
+    return {
+      achieved: true,
+      reason: "git working tree has changes (mutating run edited project files)",
+      signals: [`repoRoot=${tree.repoRoot}`]
+    };
   }
-  if (result4.size === taskIds.length) {
-    const headerPositions = [];
-    const idHeaderRegex2 = /^(#{2,3})\s+Task\s+([^\s].*?)$/gm;
-    while ((m = idHeaderRegex2.exec(rawOutput)) !== null) {
-      const headerText = m[2].trim();
-      const matchedId = taskIds.find((id) => headerText.includes(id));
-      if (matchedId) headerPositions.push({ taskId: matchedId, start: m.index + m[0].length });
-    }
-    headerPositions.sort((a, b) => a.start - b.start);
-    for (let i2 = 0; i2 < headerPositions.length; i2 += 1) {
-      const cur = headerPositions[i2];
-      const next = headerPositions[i2 + 1];
-      const end = next ? rawOutput.lastIndexOf("\n#", next.start) : rawOutput.length;
-      const text = rawOutput.slice(cur.start, end > 0 ? end : rawOutput.length).trim();
-      result4.set(cur.taskId, text);
-    }
+  const failedTask = tasks.find((t2) => t2.status === "failed");
+  const signals = ["git working tree clean despite mutating workflow"];
+  if (failedTask) signals.push(`corroborating failed task: ${failedTask.id} (${failedTask.role})`);
+  return {
+    // `false` = false-green detected. Whether to downgrade status is decided
+    // by the caller based on the corroborating failed-task signal.
+    achieved: false,
+    reason: "code-mutating run completed but made no project edits (false-green)",
+    signals
+  };
+}
+function applyGoalAchievement(manifest, assessment) {
+  const note2 = assessment.achieved === false ? `goal-achievement: FALSE-GREEN \u2014 ${assessment.reason}. ${assessment.signals.join("; ")}` : assessment.achieved === true ? `goal-achievement: OK \u2014 ${assessment.reason}` : `goal-achievement: unknown \u2014 ${assessment.reason}`;
+  const updated = {
+    ...manifest,
+    goalAchieved: assessment.achieved,
+    goalAchievementNote: note2
+  };
+  const hasCorroboratingFailure = assessment.signals.some((s) => s.startsWith("corroborating failed task"));
+  if (assessment.achieved === false && hasCorroboratingFailure && updated.status === "completed") {
+    return { manifest: { ...updated, status: "failed" }, downgraded: true };
   }
-  return result4;
+  return { manifest: updated, downgraded: false };
 }
-var init_output_splitter = __esm({
-  "src/runtime/task-runner/output-splitter.ts"() {
+var MUTATING_ROLES2;
+var init_goal_achievement = __esm({
+  "src/runtime/goal-achievement.ts"() {
     "use strict";
+    init_paths();
+    MUTATING_ROLES2 = /* @__PURE__ */ new Set(["executor", "test-engineer"]);
   }
 });
 
-// src/runtime/workspace-tree.ts
-import * as fs73 from "node:fs/promises";
-import * as path61 from "node:path";
-function formatBytes2(bytes) {
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+// src/runtime/tool-output-pruner.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
 }
-function formatAge(seconds2) {
-  if (seconds2 < 60) return "just now";
-  if (seconds2 < 3600) return `${Math.floor(seconds2 / 60)}m`;
-  if (seconds2 < 86400) return `${Math.floor(seconds2 / 3600)}h`;
-  if (seconds2 < 86400 * 14) return `${Math.floor(seconds2 / 86400)}d`;
-  return `${Math.floor(seconds2 / (86400 * 7))}w`;
+function firstErrorLine(text) {
+  return text.split(/\r?\n/).find((line4) => /error|failed|exception|panic/i.test(line4))?.trim();
 }
-function compareByRecency(a, b) {
-  const diff = b.mtimeMs - a.mtimeMs;
-  if (diff !== 0) return diff;
-  return a.name.localeCompare(b.name);
+function truncateField(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  if (maxLength <= 1) return "\u2026";
+  return `${value.slice(0, maxLength - 1)}\u2026`;
 }
-function applyDirLimit(children, limit) {
-  if (children.length <= limit) {
-    return { visible: children, dropped: 0 };
+function resultDigest(toolName, content, isError) {
+  const name = toolName.toLowerCase();
+  const text = content ?? "";
+  if (name === "bash") {
+    const exitCode = isError ? 1 : 0;
+    const tail = text.trim().split(/\r?\n/).filter(Boolean).at(-1) ?? "";
+    const error = firstErrorLine(text);
+    return [`exit=${exitCode}`, tail ? `tail=${tail}` : void 0, error ? `error=${error}` : void 0].filter((part) => part !== void 0).join("; ");
   }
-  if (limit <= 1) {
-    return {
-      visible: children.slice(0, limit),
-      dropped: children.length - limit
-    };
+  if (name === "search" || name === "grep") {
+    const match = text.match(/(\d+)\s+matches?/i) ?? text.match(/totalMatches["']?:\s*(\d+)/i);
+    const files = text.match(/(\d+)\s+files?/i) ?? text.match(/filesWithMatches["']?:\s*(\d+)/i);
+    const error = firstErrorLine(text);
+    return [match ? `matches=${match[1]}` : void 0, files ? `files=${files[1]}` : void 0, error ? `error=${error}` : void 0].filter((part) => part !== void 0).join("; ") || "search digest unavailable";
   }
-  const recent = children.slice(0, limit - 1);
-  const oldest = children[children.length - 1];
-  const visible = oldest ? [...recent, oldest] : recent;
-  return { visible, dropped: children.length - limit };
+  return void 0;
 }
-async function readChildren(rootPath, parent, excludedDirs) {
-  const dirPath = parent.relativePath ? path61.join(rootPath, parent.relativePath) : rootPath;
-  let names;
-  try {
-    names = await fs73.readdir(dirPath);
-  } catch {
-    return [];
+function createPrunedNotice(tokens, entry) {
+  const generic = `[Output pruned \u2014 ${tokens} tokens]`;
+  const digest = resultDigest(entry.toolName, entry.content, entry.isError);
+  if (!digest) return generic;
+  const genericTokens = Math.ceil(generic.length / 4);
+  const maxTokens = Math.max(genericTokens, Math.floor(genericTokens * DIGEST_NOTICE_TOKEN_CAP_MULTIPLIER));
+  const prefix = `[Output pruned \u2014 ${tokens} tokens; `;
+  const suffix = "]";
+  const maxChars = Math.max(0, maxTokens * 4 - prefix.length - suffix.length);
+  return `${prefix}${truncateField(digest, maxChars)}${suffix}`;
+}
+function readBasePath(filePath) {
+  let base = filePath;
+  while (READ_SELECTOR_SUFFIX.test(base)) {
+    base = base.replace(READ_SELECTOR_SUFFIX, "");
   }
-  const nodes = await Promise.all(
-    names.map(async (name) => {
-      if (name.startsWith(".")) return null;
-      const relativePath = parent.relativePath ? `${parent.relativePath}/${name}` : name;
-      const absolutePath = path61.join(rootPath, relativePath);
-      try {
-        const stat2 = await fs73.stat(absolutePath);
-        if (stat2.isDirectory() && excludedDirs.has(name)) return null;
-        return {
-          name,
-          relativePath,
-          depth: parent.depth + 1,
-          isDirectory: stat2.isDirectory(),
-          mtimeMs: stat2.mtimeMs,
-          size: stat2.size,
-          children: [],
-          droppedChildCount: 0
-        };
-      } catch {
-        return null;
-      }
-    })
-  );
-  return nodes.filter((n) => n !== null).sort(compareByRecency);
+  return base;
 }
-async function collectTree(rootPath, maxDepth, dirLimit, excludedDirs) {
-  const rootStat = await fs73.stat(rootPath);
-  const root = {
-    name: ".",
-    relativePath: "",
-    depth: 0,
-    isDirectory: true,
-    mtimeMs: rootStat.mtimeMs,
-    size: rootStat.size,
-    children: [],
-    droppedChildCount: 0
-  };
-  let truncated = false;
-  const queue = [root];
-  let cursor = 0;
-  while (cursor < queue.length) {
-    const parent = queue[cursor];
-    cursor += 1;
-    if (!parent || parent.depth >= maxDepth) continue;
-    const children = await readChildren(rootPath, parent, excludedDirs);
-    const { visible, dropped } = applyDirLimit(children, dirLimit);
-    parent.children = visible;
-    parent.droppedChildCount = dropped;
-    if (dropped > 0) truncated = true;
-    for (const child of visible) {
-      if (child.isDirectory) queue.push(child);
+function toolTargetKey(entry) {
+  if (!entry.target || entry.target.length === 0) return void 0;
+  return JSON.stringify([entry.toolName, entry.target]);
+}
+function buildStalenessIndex(toolResults, fileEdits = []) {
+  const lastResultIndexByKey = /* @__PURE__ */ new Map();
+  for (let i2 = 0; i2 < toolResults.length; i2++) {
+    const entry = toolResults[i2];
+    if (entry.isError) continue;
+    const key = toolTargetKey(entry);
+    if (key !== void 0) lastResultIndexByKey.set(key, i2);
+  }
+  const lastEditIndexByPath = /* @__PURE__ */ new Map();
+  for (const edit of fileEdits) {
+    lastEditIndexByPath.set(edit.target, edit.index);
+  }
+  const staleIndices = /* @__PURE__ */ new Set();
+  for (let i2 = 0; i2 < toolResults.length; i2++) {
+    const entry = toolResults[i2];
+    const key = toolTargetKey(entry);
+    if (key !== void 0) {
+      const lastIndex = lastResultIndexByKey.get(key);
+      if (lastIndex !== void 0 && lastIndex > i2) {
+        staleIndices.add(i2);
+        continue;
+      }
+    }
+    if (entry.toolName.toLowerCase() === "read" && entry.target) {
+      const basePath = readBasePath(entry.target);
+      const editIndex = lastEditIndexByPath.get(basePath);
+      if (editIndex !== void 0 && editIndex > i2) {
+        staleIndices.add(i2);
+      }
     }
   }
-  return { root, truncated };
+  return { staleIndices };
 }
-function collectLines(node, nowMs3, lines) {
-  if (node.depth === 0) {
-    lines.push({ text: ".", depth: 0, isRoot: true });
-  } else {
-    const indent = "  ".repeat(node.depth);
-    const suffix = node.isDirectory ? "/" : "";
-    const label = `${indent}- ${node.name}${suffix}`;
-    if (node.isDirectory) {
-      lines.push({ text: label, depth: node.depth, isRoot: false });
-    } else {
-      const ageSeconds = Math.max(0, Math.floor((nowMs3 - node.mtimeMs) / 1e3));
-      const size = formatBytes2(node.size);
-      const age = formatAge(ageSeconds);
-      lines.push({
-        text: `${label}  ${size}  ${age}`,
-        depth: node.depth,
-        isRoot: false
-      });
+function pruneToolOutputs(results, config = DEFAULT_PRUNE_CONFIG) {
+  const { staleIndices } = buildStalenessIndex(results);
+  const staleOverridable = new Set(config.staleOverridableTools ?? []);
+  let accumulatedTokens = 0;
+  let tokensSaved = 0;
+  let prunedCount = 0;
+  const candidates = [];
+  const prunedIds = [];
+  for (let i2 = results.length - 1; i2 >= 0; i2--) {
+    const entry = results[i2];
+    const tokens = estimateTokens(entry.content);
+    const isStale = staleIndices.has(i2);
+    const isProtected = config.protectedTools.includes(entry.toolName) && !(isStale && staleOverridable.has(entry.toolName));
+    const insideProtectWindow = accumulatedTokens < config.protectTokens;
+    if (insideProtectWindow && !isStale || isProtected) {
+      accumulatedTokens += tokens;
+      continue;
     }
-  }
-  if (node.droppedChildCount > 0) {
-    const recentChildren = node.children.slice(0, -1);
-    const oldestChild = node.children[node.children.length - 1];
-    for (const child of recentChildren) collectLines(child, nowMs3, lines);
-    const childDepth = node.depth + 1;
-    const indent = "  ".repeat(childDepth);
-    lines.push({
-      text: `${indent}- \u2026 ${node.droppedChildCount} more`,
-      depth: childDepth,
-      isRoot: false
+    const notice = createPrunedNotice(tokens, entry);
+    candidates.push({
+      index: i2,
+      entry,
+      tokens,
+      notice,
+      savings: Math.max(0, tokens - Math.ceil(notice.length / 4))
     });
-    if (oldestChild) collectLines(oldestChild, nowMs3, lines);
-  } else {
-    for (const child of node.children) collectLines(child, nowMs3, lines);
+    accumulatedTokens += tokens;
   }
+  for (const candidate of candidates) {
+    tokensSaved += candidate.savings;
+  }
+  if (tokensSaved < config.minimumSavings || candidates.length === 0) {
+    return { prunedCount: 0, tokensSaved: 0, results, prunedIds: [] };
+  }
+  const prunedResults = [...results];
+  for (const candidate of candidates) {
+    prunedResults[candidate.index] = {
+      ...candidate.entry,
+      content: candidate.notice
+    };
+    prunedIds.push(candidate.entry.id);
+    prunedCount++;
+  }
+  return { prunedCount, tokensSaved, results: prunedResults, prunedIds };
 }
-function applyLineCap(lines, cap) {
-  if (lines.length <= cap) return { lines, elided: 0 };
-  const target = Math.max(1, cap - 1);
-  const removeCount = lines.length - target;
-  const removable = lines.map((line4, index) => ({ line: line4, index })).filter((item) => !item.line.isRoot).sort((a, b) => b.line.depth - a.line.depth || b.index - a.index).slice(0, removeCount);
-  if (removable.length === 0) return { lines, elided: 0 };
-  const removedIndexes = new Set(removable.map((item) => item.index));
-  const kept = lines.filter((_, index) => !removedIndexes.has(index));
-  kept.push({
-    text: `\u2026 (${removable.length} lines elided)`,
-    depth: 0,
-    isRoot: false
-  });
-  return { lines: kept, elided: removable.length };
-}
-function treeCacheKey(cwd, options) {
-  return `${path61.resolve(cwd)}|${options?.maxDepth ?? ""}|${options?.dirLimit ?? ""}|${options?.lineCap ?? ""}`;
-}
-async function buildWorkspaceTree(cwd, options) {
-  const rootPath = path61.resolve(cwd);
-  const cacheKey2 = treeCacheKey(cwd, options);
-  const cached = treeCache.get(cacheKey2);
-  if (cached && cached.expiresAt > Date.now()) {
-    return cached.tree;
+var DEFAULT_PRUNE_CONFIG, DIGEST_NOTICE_TOKEN_CAP_MULTIPLIER, READ_SELECTOR_SUFFIX;
+var init_tool_output_pruner = __esm({
+  "src/runtime/tool-output-pruner.ts"() {
+    "use strict";
+    DEFAULT_PRUNE_CONFIG = {
+      protectTokens: 4e4,
+      minimumSavings: 2e4,
+      protectedTools: ["read"],
+      staleOverridableTools: ["read"]
+    };
+    DIGEST_NOTICE_TOKEN_CAP_MULTIPLIER = 1.25;
+    READ_SELECTOR_SUFFIX = /:(?:raw|conflicts|\d+(?:[-+]\d+)?(?:,\d+(?:[-+]\d+)?)*)$/;
   }
-  try {
-    const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
-    const dirLimit = options?.dirLimit ?? DEFAULT_DIR_LIMIT;
-    const lineCap = options?.lineCap ?? DEFAULT_LINE_CAP;
-    const excludedDirs = options?.excludedDirs ?? DEFAULT_EXCLUDED_DIRS;
-    const { root, truncated: dirTruncated } = await collectTree(rootPath, maxDepth, dirLimit, excludedDirs);
-    const nowMs3 = Date.now();
-    const lines = [];
-    collectLines(root, nowMs3, lines);
-    const { lines: capped, elided } = applyLineCap(lines, lineCap);
-    const rendered = capped.map((l) => l.text).join("\n");
-    const result4 = {
-      rootPath,
-      rendered,
-      truncated: dirTruncated || elided > 0,
-      totalLines: capped.length
-    };
-    treeCache.set(cacheKey2, {
-      tree: result4,
-      expiresAt: Date.now() + TREE_CACHE_TTL_MS
-    });
-    return result4;
-  } catch {
-    return emptyResult(rootPath);
-  }
-}
-var DEFAULT_MAX_DEPTH, DEFAULT_DIR_LIMIT, DEFAULT_LINE_CAP, DEFAULT_EXCLUDED_DIRS, emptyResult, TREE_CACHE_TTL_MS, treeCache;
-var init_workspace_tree = __esm({
-  "src/runtime/workspace-tree.ts"() {
-    "use strict";
-    DEFAULT_MAX_DEPTH = 3;
-    DEFAULT_DIR_LIMIT = 12;
-    DEFAULT_LINE_CAP = 120;
-    DEFAULT_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
-      "node_modules",
-      ".git",
-      ".next",
-      "dist",
-      "build",
-      "target",
-      ".venv",
-      ".cache",
-      ".turbo"
-    ]);
-    emptyResult = (rootPath) => ({
-      rootPath,
-      rendered: "",
-      truncated: false,
-      totalLines: 0
-    });
-    TREE_CACHE_TTL_MS = 3e4;
-    treeCache = /* @__PURE__ */ new Map();
-  }
-});
-
-// src/runtime/run-coalesced-task-group.ts
-async function runCoalescedTaskGroup(input) {
-  const { manifest, groupTasks, step, agent, signal, executeWorkers } = input;
-  const groupId = groupTasks.map((t2) => t2.id).join("+");
-  const firstTask = groupTasks[0];
-  const taskIds = groupTasks.map((t2) => t2.id);
-  let updatedTasks = input.tasks.map((t2) => {
-    if (taskIds.includes(t2.id) && t2.status !== "running") {
-      return { ...t2, status: "running", startedAt: (/* @__PURE__ */ new Date()).toISOString() };
-    }
-    return t2;
-  });
-  saveRunTasks(manifest, updatedTasks);
-  await appendEventAsync(manifest.eventsPath, {
-    type: "task.coalesced_dispatch_start",
-    runId: manifest.runId,
-    message: `Dispatching ${groupTasks.length} coalesced tasks in 1 worker (role=${firstTask.role}, cwd=${firstTask.cwd})`,
-    data: { groupId, role: firstTask.role, cwd: firstTask.cwd, taskIds }
-  });
-  const combinedPrompt = await buildCoalescedPrompt(manifest, step, groupTasks, agent);
-  updatedTasks = updatedTasks.map((t2) => {
-    if (!taskIds.includes(t2.id)) return t2;
-    return {
-      ...t2,
-      heartbeat: t2.heartbeat ?? createWorkerHeartbeat(t2.id)
-    };
-  });
-  saveRunTasks(manifest, updatedTasks);
-  let rawOutput = "";
-  let success = false;
-  if (!executeWorkers) {
-    rawOutput = buildScaffoldOutput(groupTasks);
-    success = true;
-  } else {
-    const heartbeatTimer = setInterval(() => {
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      updatedTasks = updatedTasks.map((t2) => {
-        if (!taskIds.includes(t2.id)) return t2;
-        return {
-          ...t2,
-          heartbeat: touchWorkerHeartbeat(t2.heartbeat ?? createWorkerHeartbeat(t2.id), { alive: true })
-        };
-      });
-      try {
-        saveRunTasks(manifest, updatedTasks);
-      } catch {
-      }
-    }, 15e3);
-    try {
-      const result4 = await runChildPi({
-        cwd: firstTask.cwd,
-        task: combinedPrompt,
-        agent,
-        signal,
-        excludeContextBash: true,
-        maxTurns: 5,
-        onJsonEvent: (e) => input.onJsonEvent?.(firstTask.id, manifest.runId, e)
-      });
-      rawOutput = result4.rawFinalText ?? result4.stdout ?? "";
-      success = result4.exitStatus?.exitCode === 0;
-    } catch (err2) {
-      rawOutput = `Worker dispatch failed: ${err2 instanceof Error ? err2.message : String(err2)}`;
-      success = false;
-    } finally {
-      clearInterval(heartbeatTimer);
-    }
-  }
-  const split = splitCoalescedOutput(rawOutput, taskIds);
-  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
-  const newArtifacts = [];
-  updatedTasks = updatedTasks.map((t2) => {
-    if (!taskIds.includes(t2.id)) return t2;
-    const entry = split.find((s) => s.taskId === t2.id);
-    const ok = success && Boolean(entry?.text);
-    const text = entry?.text ?? rawOutput;
-    const resultArtifact = writeArtifact(manifest.artifactsRoot, {
-      kind: "result",
-      relativePath: `results/${t2.id}.txt`,
-      content: text,
-      producer: t2.id
-    });
-    newArtifacts.push(resultArtifact);
-    return {
-      ...t2,
-      status: ok ? "completed" : "failed",
-      finishedAt,
-      result: {
-        text,
-        producer: groupId,
-        strategy: entry?.strategy ?? "broadcast"
-      },
-      resultArtifact
-    };
-  });
-  saveRunTasks(manifest, updatedTasks);
-  let updatedManifest = {
-    ...manifest,
-    artifacts: mergeArtifacts([...manifest.artifacts, ...newArtifacts])
-  };
-  if (success) {
-    updatedManifest = updateRunStatus(updatedManifest, "running");
-  }
-  await appendEventAsync(updatedManifest.eventsPath, {
-    type: "task.coalesced_dispatch_end",
-    runId: manifest.runId,
-    message: `Coalesced dispatch ${success ? "completed" : "failed"} (${taskIds.length} tasks, ${split[0]?.strategy ?? "broadcast"} split)`,
-    data: { groupId, taskIds, success, strategy: split[0]?.strategy }
-  });
-  return { manifest: updatedManifest, tasks: updatedTasks, taskIds, rawOutput, success };
-}
-async function buildCoalescedPrompt(manifest, step, groupTasks, agent) {
-  const tree = await buildWorkspaceTree(groupTasks[0].cwd);
-  const treeBlock = tree.rendered ? `# Workspace Structure
-${tree.rendered}` : "";
-  const roleInstructions = permissionForRole(groupTasks[0].role) === "read_only" ? `You are running in READ-ONLY mode. Do not create, modify, delete, or move files. Emit your findings as TEXT in your final output.` : "";
-  const taskBlocks = groupTasks.map((task, idx) => {
-    return [
-      `### Task ${idx + 1} of ${groupTasks.length} (id: ${task.id})`,
-      `Step: ${step.id}`,
-      `Role: ${step.role}`,
-      `Task: ${step.task.replaceAll("{goal}", manifest.goal)}`
-    ].join("\n");
-  }).join("\n\n---\n\n");
-  const outputInstructions = groupTasks.map((task) => `<<<TASK_RESULT:${task.id}>>>`).join(" ... ");
-  return [
-    "# pi-crew Coalesced Worker Prompt",
-    `Run ID: ${manifest.runId}`,
-    `Team: ${manifest.team}`,
-    `Workflow: ${manifest.workflow ?? "(none)"}`,
-    `Goal: ${manifest.goal}`,
-    `Tasks in this batch: ${groupTasks.length}`,
-    ``,
-    roleInstructions,
-    ``,
-    treeBlock,
-    ``,
-    `# Your Tasks`,
-    `Complete ALL ${groupTasks.length} tasks below. For each, structure your final output using the delimiters shown.`,
-    ``,
-    taskBlocks,
-    ``,
-    `# Output Format (CRITICAL)`,
-    `After completing all tasks, structure your final output using these delimiters:`,
-    ``,
-    outputInstructions,
-    ``,
-    `Wrap each task's result between the start and end delimiters:`,
-    `<<<TASK_RESULT:{taskId}>>>`,
-    `...your result for this task...`,
-    `<<<END_TASK_RESULT>>>`,
-    ``,
-    `If delimiters don't fit your workflow, use \`### Task N of M\` headings and we'll parse those instead.`
-  ].filter(Boolean).join("\n");
-}
-function buildScaffoldOutput(groupTasks) {
-  return groupTasks.map(
-    (task, idx) => `<<<TASK_RESULT:${task.id}>>>
-Scaffold result for task ${idx + 1} of ${groupTasks.length}: ${task.id}
-<<<END_TASK_RESULT>>>`
-  ).join("\n\n");
-}
-var init_run_coalesced_task_group = __esm({
-  "src/runtime/run-coalesced-task-group.ts"() {
-    "use strict";
-    init_role_permission();
-    init_child_pi();
-    init_output_splitter();
-    init_workspace_tree();
-    init_state_store();
-    init_artifact_store();
-    init_event_log();
-    init_worker_heartbeat();
-    init_team_runner_artifacts();
-  }
-});
-
-// src/runtime/concurrency.ts
-function defaultWorkflowConcurrency(workflowName, workflowMaxConcurrency) {
-  if (workflowMaxConcurrency !== void 0) return workflowMaxConcurrency;
-  if (workflowName === "parallel-research") return DEFAULT_CONCURRENCY.workflow.parallelResearch;
-  if (workflowName === "research") return DEFAULT_CONCURRENCY.workflow.research;
-  if (workflowName === "implementation") return DEFAULT_CONCURRENCY.workflow.implementation;
-  if (workflowName === "review") return DEFAULT_CONCURRENCY.workflow.review;
-  if (workflowName === "default") return DEFAULT_CONCURRENCY.workflow.default;
-  return DEFAULT_CONCURRENCY.fallback;
-}
-function positiveInteger2(value) {
-  if (value === void 0 || !Number.isFinite(value)) return void 0;
-  return Math.max(1, Math.trunc(value));
-}
-function resolveBatchConcurrency(input) {
-  const workflowMax = positiveInteger2(input.workflowMaxConcurrency);
-  const defaultConcurrency = defaultWorkflowConcurrency(input.workflowName, workflowMax);
-  const limitMax = positiveInteger2(input.limitMaxConcurrentWorkers);
-  const teamMax = positiveInteger2(input.teamMaxConcurrency);
-  const requested = limitMax ?? teamMax ?? workflowMax ?? defaultWorkflowConcurrency(input.workflowName);
-  let source;
-  if (limitMax !== void 0) source = "limit";
-  else if (teamMax !== void 0) source = "team";
-  else source = "workflow";
-  const hardCap = positiveInteger2(input.hardCap) ?? DEFAULT_CONCURRENCY.hardCap;
-  const maxConcurrent = input.allowUnboundedConcurrency ? requested : Math.min(requested, hardCap);
-  const readyCount = Math.max(0, Math.trunc(Number.isFinite(input.readyCount) ? input.readyCount : 0));
-  const cappedReason = maxConcurrent < requested ? `;capped:${hardCap}` : "";
-  const unboundedReason = input.allowUnboundedConcurrency && requested > hardCap ? `;unbounded:${hardCap}` : "";
-  return {
-    maxConcurrent,
-    selectedCount: readyCount === 0 ? 0 : Math.min(readyCount, maxConcurrent),
-    defaultConcurrency,
-    reason: `${source}:${requested}${cappedReason}${unboundedReason};ready:${readyCount}`
-  };
-}
-var init_concurrency = __esm({
-  "src/runtime/concurrency.ts"() {
-    "use strict";
-    init_defaults();
-  }
-});
-
-// src/runtime/goal-achievement.ts
-import { spawnSync as spawnSync2 } from "node:child_process";
-function workflowIsMutating(workflow) {
-  const steps = workflow?.steps ?? [];
-  return steps.some((step) => typeof step?.role === "string" && MUTATING_ROLES2.has(step.role));
-}
-function isGitWorkingTreeClean(cwd) {
-  try {
-    const repoRoot = findRepoRoot(cwd);
-    if (!repoRoot) return { clean: "unknown", repoRoot: void 0 };
-    const res = spawnSync2("git", ["-C", repoRoot, "status", "--porcelain"], { encoding: "utf8", timeout: 5e3 });
-    if (res.error || res.status !== 0) return { clean: "unknown", repoRoot: void 0 };
-    return { clean: res.stdout.trim().length === 0, repoRoot };
-  } catch {
-    return { clean: "unknown", repoRoot: void 0 };
-  }
-}
-function assessGoalAchievement(manifest, tasks, workflow) {
-  if (!workflowIsMutating(workflow)) {
-    return {
-      achieved: "unknown",
-      reason: "read-only / doc-only workflow (no executor/test-engineer steps)",
-      signals: []
-    };
-  }
-  const tree = isGitWorkingTreeClean(manifest.cwd);
-  if (tree.clean === "unknown" || !tree.repoRoot) {
-    return {
-      achieved: "unknown",
-      reason: "not a git repo or git unavailable",
-      signals: []
-    };
-  }
-  if (!tree.clean) {
-    return {
-      achieved: true,
-      reason: "git working tree has changes (mutating run edited project files)",
-      signals: [`repoRoot=${tree.repoRoot}`]
-    };
-  }
-  const failedTask = tasks.find((t2) => t2.status === "failed");
-  const signals = ["git working tree clean despite mutating workflow"];
-  if (failedTask) signals.push(`corroborating failed task: ${failedTask.id} (${failedTask.role})`);
-  return {
-    // `false` = false-green detected. Whether to downgrade status is decided
-    // by the caller based on the corroborating failed-task signal.
-    achieved: false,
-    reason: "code-mutating run completed but made no project edits (false-green)",
-    signals
-  };
-}
-function applyGoalAchievement(manifest, assessment) {
-  const note2 = assessment.achieved === false ? `goal-achievement: FALSE-GREEN \u2014 ${assessment.reason}. ${assessment.signals.join("; ")}` : assessment.achieved === true ? `goal-achievement: OK \u2014 ${assessment.reason}` : `goal-achievement: unknown \u2014 ${assessment.reason}`;
-  const updated = {
-    ...manifest,
-    goalAchieved: assessment.achieved,
-    goalAchievementNote: note2
-  };
-  const hasCorroboratingFailure = assessment.signals.some((s) => s.startsWith("corroborating failed task"));
-  if (assessment.achieved === false && hasCorroboratingFailure && updated.status === "completed") {
-    return { manifest: { ...updated, status: "failed" }, downgraded: true };
-  }
-  return { manifest: updated, downgraded: false };
-}
-var MUTATING_ROLES2;
-var init_goal_achievement = __esm({
-  "src/runtime/goal-achievement.ts"() {
-    "use strict";
-    init_paths();
-    MUTATING_ROLES2 = /* @__PURE__ */ new Set(["executor", "test-engineer"]);
-  }
-});
-
-// src/runtime/tool-output-pruner.ts
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function firstErrorLine(text) {
-  return text.split(/\r?\n/).find((line4) => /error|failed|exception|panic/i.test(line4))?.trim();
-}
-function truncateField(value, maxLength) {
-  if (value.length <= maxLength) return value;
-  if (maxLength <= 1) return "\u2026";
-  return `${value.slice(0, maxLength - 1)}\u2026`;
-}
-function resultDigest(toolName, content, isError) {
-  const name = toolName.toLowerCase();
-  const text = content ?? "";
-  if (name === "bash") {
-    const exitCode = isError ? 1 : 0;
-    const tail = text.trim().split(/\r?\n/).filter(Boolean).at(-1) ?? "";
-    const error = firstErrorLine(text);
-    return [`exit=${exitCode}`, tail ? `tail=${tail}` : void 0, error ? `error=${error}` : void 0].filter((part) => part !== void 0).join("; ");
-  }
-  if (name === "search" || name === "grep") {
-    const match = text.match(/(\d+)\s+matches?/i) ?? text.match(/totalMatches["']?:\s*(\d+)/i);
-    const files = text.match(/(\d+)\s+files?/i) ?? text.match(/filesWithMatches["']?:\s*(\d+)/i);
-    const error = firstErrorLine(text);
-    return [match ? `matches=${match[1]}` : void 0, files ? `files=${files[1]}` : void 0, error ? `error=${error}` : void 0].filter((part) => part !== void 0).join("; ") || "search digest unavailable";
-  }
-  return void 0;
-}
-function createPrunedNotice(tokens, entry) {
-  const generic = `[Output pruned \u2014 ${tokens} tokens]`;
-  const digest = resultDigest(entry.toolName, entry.content, entry.isError);
-  if (!digest) return generic;
-  const genericTokens = Math.ceil(generic.length / 4);
-  const maxTokens = Math.max(genericTokens, Math.floor(genericTokens * DIGEST_NOTICE_TOKEN_CAP_MULTIPLIER));
-  const prefix = `[Output pruned \u2014 ${tokens} tokens; `;
-  const suffix = "]";
-  const maxChars = Math.max(0, maxTokens * 4 - prefix.length - suffix.length);
-  return `${prefix}${truncateField(digest, maxChars)}${suffix}`;
-}
-function readBasePath(filePath) {
-  let base = filePath;
-  while (READ_SELECTOR_SUFFIX.test(base)) {
-    base = base.replace(READ_SELECTOR_SUFFIX, "");
-  }
-  return base;
-}
-function toolTargetKey(entry) {
-  if (!entry.target || entry.target.length === 0) return void 0;
-  return JSON.stringify([entry.toolName, entry.target]);
-}
-function buildStalenessIndex(toolResults, fileEdits = []) {
-  const lastResultIndexByKey = /* @__PURE__ */ new Map();
-  for (let i2 = 0; i2 < toolResults.length; i2++) {
-    const entry = toolResults[i2];
-    if (entry.isError) continue;
-    const key = toolTargetKey(entry);
-    if (key !== void 0) lastResultIndexByKey.set(key, i2);
-  }
-  const lastEditIndexByPath = /* @__PURE__ */ new Map();
-  for (const edit of fileEdits) {
-    lastEditIndexByPath.set(edit.target, edit.index);
-  }
-  const staleIndices = /* @__PURE__ */ new Set();
-  for (let i2 = 0; i2 < toolResults.length; i2++) {
-    const entry = toolResults[i2];
-    const key = toolTargetKey(entry);
-    if (key !== void 0) {
-      const lastIndex = lastResultIndexByKey.get(key);
-      if (lastIndex !== void 0 && lastIndex > i2) {
-        staleIndices.add(i2);
-        continue;
-      }
-    }
-    if (entry.toolName.toLowerCase() === "read" && entry.target) {
-      const basePath = readBasePath(entry.target);
-      const editIndex = lastEditIndexByPath.get(basePath);
-      if (editIndex !== void 0 && editIndex > i2) {
-        staleIndices.add(i2);
-      }
-    }
-  }
-  return { staleIndices };
-}
-function pruneToolOutputs(results, config = DEFAULT_PRUNE_CONFIG) {
-  const { staleIndices } = buildStalenessIndex(results);
-  const staleOverridable = new Set(config.staleOverridableTools ?? []);
-  let accumulatedTokens = 0;
-  let tokensSaved = 0;
-  let prunedCount = 0;
-  const candidates = [];
-  const prunedIds = [];
-  for (let i2 = results.length - 1; i2 >= 0; i2--) {
-    const entry = results[i2];
-    const tokens = estimateTokens(entry.content);
-    const isStale = staleIndices.has(i2);
-    const isProtected = config.protectedTools.includes(entry.toolName) && !(isStale && staleOverridable.has(entry.toolName));
-    const insideProtectWindow = accumulatedTokens < config.protectTokens;
-    if (insideProtectWindow && !isStale || isProtected) {
-      accumulatedTokens += tokens;
-      continue;
-    }
-    const notice = createPrunedNotice(tokens, entry);
-    candidates.push({
-      index: i2,
-      entry,
-      tokens,
-      notice,
-      savings: Math.max(0, tokens - Math.ceil(notice.length / 4))
-    });
-    accumulatedTokens += tokens;
-  }
-  for (const candidate of candidates) {
-    tokensSaved += candidate.savings;
-  }
-  if (tokensSaved < config.minimumSavings || candidates.length === 0) {
-    return { prunedCount: 0, tokensSaved: 0, results, prunedIds: [] };
-  }
-  const prunedResults = [...results];
-  for (const candidate of candidates) {
-    prunedResults[candidate.index] = {
-      ...candidate.entry,
-      content: candidate.notice
-    };
-    prunedIds.push(candidate.entry.id);
-    prunedCount++;
-  }
-  return { prunedCount, tokensSaved, results: prunedResults, prunedIds };
-}
-var DEFAULT_PRUNE_CONFIG, DIGEST_NOTICE_TOKEN_CAP_MULTIPLIER, READ_SELECTOR_SUFFIX;
-var init_tool_output_pruner = __esm({
-  "src/runtime/tool-output-pruner.ts"() {
-    "use strict";
-    DEFAULT_PRUNE_CONFIG = {
-      protectTokens: 4e4,
-      minimumSavings: 2e4,
-      protectedTools: ["read"],
-      staleOverridableTools: ["read"]
-    };
-    DIGEST_NOTICE_TOKEN_CAP_MULTIPLIER = 1.25;
-    READ_SELECTOR_SUFFIX = /:(?:raw|conflicts|\d+(?:[-+]\d+)?(?:,\d+(?:[-+]\d+)?)*)$/;
-  }
-});
-
-// src/runtime/task-output-context.ts
-import * as fs74 from "node:fs";
-import * as path62 from "node:path";
-function containedExists(filePath, baseDir) {
+});
+
+// src/runtime/task-output-context.ts
+import * as fs73 from "node:fs";
+import * as path61 from "node:path";
+function containedExists(filePath, baseDir) {
   try {
     const safePath = baseDir ? resolveRealContainedPath(baseDir, filePath) : filePath;
-    return fs74.existsSync(safePath);
+    return fs73.existsSync(safePath);
   } catch {
     return false;
   }
@@ -54038,12 +53651,12 @@ function safeTeeName(taskId, artifactName) {
   return `${safe(taskId)}-${safe(artifactName)}.full.txt`;
 }
 function teePathForArtifact(artifactsRoot, taskId, artifactName) {
-  return path62.join(artifactsRoot, "tee", safeTeeName(taskId, artifactName));
+  return path61.join(artifactsRoot, "tee", safeTeeName(taskId, artifactName));
 }
 function writeTeeFile(fullOutputPath, content) {
   try {
-    fs74.mkdirSync(path62.dirname(fullOutputPath), { recursive: true });
-    fs74.writeFileSync(fullOutputPath, content, "utf-8");
+    fs73.mkdirSync(path61.dirname(fullOutputPath), { recursive: true });
+    fs73.writeFileSync(fullOutputPath, content, "utf-8");
     return true;
   } catch {
     return false;
@@ -54053,7 +53666,7 @@ function readIfSmallWithTee(filePath, opts = {}) {
   const maxChars = MAX_RESULT_INLINE_BYTES;
   try {
     const safePath = opts.baseDir ? resolveRealContainedPath(opts.baseDir, filePath) : filePath;
-    const content = fs74.readFileSync(safePath, "utf-8");
+    const content = fs73.readFileSync(safePath, "utf-8");
     if (content.length > maxChars) {
       let fullOutputPath;
       if (opts.tee && content.length > maxChars * TEE_THRESHOLD_MULTIPLIER) {
@@ -54087,15 +53700,15 @@ function readIfSmall(filePath, baseDir) {
 }
 function safeSharedName(name) {
   const normalized = name.replaceAll("\\", "/").replace(/^\.\/+/, "");
-  if (!normalized || normalized.split("/").some((segment) => segment === "..") || path62.isAbsolute(normalized))
+  if (!normalized || normalized.split("/").some((segment) => segment === "..") || path61.isAbsolute(normalized))
     throw new Error(`Invalid shared artifact name: ${name}`);
   return normalized;
 }
 function sharedPath(manifest, name) {
-  const sharedRoot = path62.resolve(manifest.artifactsRoot, "shared");
-  const resolved = path62.resolve(sharedRoot, safeSharedName(name));
-  const relative8 = path62.relative(sharedRoot, resolved);
-  if (relative8.startsWith("..") || path62.isAbsolute(relative8)) throw new Error(`Invalid shared artifact name: ${name}`);
+  const sharedRoot = path61.resolve(manifest.artifactsRoot, "shared");
+  const resolved = path61.resolve(sharedRoot, safeSharedName(name));
+  const relative8 = path61.relative(sharedRoot, resolved);
+  if (relative8.startsWith("..") || path61.isAbsolute(relative8)) throw new Error(`Invalid shared artifact name: ${name}`);
   return resolved;
 }
 function tryParseJson(text) {
@@ -54110,7 +53723,7 @@ function listTaskArtifacts(manifest, taskId) {
   const produced = manifest.artifacts.filter((a) => a.producer === taskId);
   if (produced.length === 0) return void 0;
   return produced.map((a) => {
-    const relative8 = path62.relative(manifest.artifactsRoot, a.path);
+    const relative8 = path61.relative(manifest.artifactsRoot, a.path);
     return relative8.startsWith("..") ? a.path : relative8;
   });
 }
@@ -54168,7 +53781,7 @@ function pruneSharedReads(reads, dependencies, artifactsRoot) {
     for (const artifact of produced) {
       if (typeof artifact !== "string") continue;
       fileEdits.push({
-        target: path62.resolve(artifactsRoot, artifact),
+        target: path61.resolve(artifactsRoot, artifact),
         index: reads.length + depIndex
       });
     }
@@ -54221,7 +53834,7 @@ function collectDependencyOutputContext(manifest, tasks, task, step) {
     const filePath = sharedPath(manifest, name);
     const teePath = teePathForArtifact(manifest.artifactsRoot, task.id, name);
     const teeResult = readIfSmallWithTee(filePath, {
-      baseDir: path62.resolve(manifest.artifactsRoot, "shared"),
+      baseDir: path61.resolve(manifest.artifactsRoot, "shared"),
       tee: { fullOutputPath: teePath }
     });
     if (teeResult === void 0) return { name, path: filePath, content: "" };
@@ -54733,6 +54346,502 @@ var init_retry_executor = __esm({
   }
 });
 
+// src/runtime/task-runner/output-splitter.ts
+function splitCoalescedOutput(rawOutput, taskIds) {
+  if (taskIds.length === 0) return [];
+  if (taskIds.length === 1) {
+    return [{ taskId: taskIds[0], text: rawOutput, strategy: "delimiter" }];
+  }
+  const byId = /* @__PURE__ */ new Map();
+  const delimiterHits = /* @__PURE__ */ new Set();
+  const delimiterRegex = /<<<TASK_RESULT:([^\s>]+)>>>([\s\S]*?)<<<END_TASK_RESULT>>>/g;
+  let match;
+  while ((match = delimiterRegex.exec(rawOutput)) !== null) {
+    const id = match[1];
+    const body = match[2].trim();
+    if (taskIds.includes(id) && !byId.has(id)) {
+      byId.set(id, body);
+      delimiterHits.add(id);
+    }
+  }
+  if (delimiterHits.size === taskIds.length) {
+    return taskIds.map((id) => ({
+      taskId: id,
+      text: byId.get(id) ?? "",
+      strategy: "delimiter"
+    }));
+  }
+  if (delimiterHits.size === 0) {
+    const bySection = parseBySectionHeadings(rawOutput, taskIds);
+    if (bySection.size === taskIds.length) {
+      return taskIds.map((id) => ({
+        taskId: id,
+        text: bySection.get(id) ?? "",
+        strategy: "section"
+      }));
+    }
+  }
+  return taskIds.map((id) => ({
+    taskId: id,
+    text: rawOutput,
+    strategy: "broadcast"
+  }));
+}
+function parseBySectionHeadings(rawOutput, taskIds) {
+  const result4 = /* @__PURE__ */ new Map();
+  const numberedRegex = /^(#{2,3})\s+Task\s+(\d+)\s+of\s+\d+.*$/gm;
+  const sections = [];
+  let m;
+  while ((m = numberedRegex.exec(rawOutput)) !== null) {
+    sections.push({ num: Number(m[2]), start: m.index + m[0].length });
+  }
+  if (sections.length >= taskIds.length) {
+    sections.sort((a, b) => a.start - b.start);
+    for (let i2 = 0; i2 < sections.length && i2 < taskIds.length; i2 += 1) {
+      const section2 = sections[i2];
+      const end = sections[i2 + 1]?.start ?? rawOutput.length;
+      const text = rawOutput.slice(section2.start, end).trim();
+      const taskId = taskIds[i2];
+      if (taskId) result4.set(taskId, text);
+    }
+    return result4;
+  }
+  const idHeaderRegex = /^(#{2,3})\s+Task\s+([^\s].*?)$/gm;
+  while ((m = idHeaderRegex.exec(rawOutput)) !== null) {
+    const headerText = m[2].trim();
+    const matchedId = taskIds.find((id) => headerText.includes(id));
+    if (matchedId && !result4.has(matchedId)) {
+      result4.set(matchedId, "");
+    }
+  }
+  if (result4.size === taskIds.length) {
+    const headerPositions = [];
+    const idHeaderRegex2 = /^(#{2,3})\s+Task\s+([^\s].*?)$/gm;
+    while ((m = idHeaderRegex2.exec(rawOutput)) !== null) {
+      const headerText = m[2].trim();
+      const matchedId = taskIds.find((id) => headerText.includes(id));
+      if (matchedId) headerPositions.push({ taskId: matchedId, start: m.index + m[0].length });
+    }
+    headerPositions.sort((a, b) => a.start - b.start);
+    for (let i2 = 0; i2 < headerPositions.length; i2 += 1) {
+      const cur = headerPositions[i2];
+      const next = headerPositions[i2 + 1];
+      const end = next ? rawOutput.lastIndexOf("\n#", next.start) : rawOutput.length;
+      const text = rawOutput.slice(cur.start, end > 0 ? end : rawOutput.length).trim();
+      result4.set(cur.taskId, text);
+    }
+  }
+  return result4;
+}
+var init_output_splitter = __esm({
+  "src/runtime/task-runner/output-splitter.ts"() {
+    "use strict";
+  }
+});
+
+// src/runtime/team-runner-artifacts.ts
+function mergeArtifacts(items) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const item of items) byPath.set(item.path, item);
+  return [...byPath.values()];
+}
+var init_team_runner_artifacts = __esm({
+  "src/runtime/team-runner-artifacts.ts"() {
+    "use strict";
+  }
+});
+
+// src/runtime/workspace-tree.ts
+import * as fs74 from "node:fs/promises";
+import * as path62 from "node:path";
+function formatBytes2(bytes) {
+  if (bytes < 1024) return `${bytes}B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
+}
+function formatAge(seconds2) {
+  if (seconds2 < 60) return "just now";
+  if (seconds2 < 3600) return `${Math.floor(seconds2 / 60)}m`;
+  if (seconds2 < 86400) return `${Math.floor(seconds2 / 3600)}h`;
+  if (seconds2 < 86400 * 14) return `${Math.floor(seconds2 / 86400)}d`;
+  return `${Math.floor(seconds2 / (86400 * 7))}w`;
+}
+function compareByRecency(a, b) {
+  const diff = b.mtimeMs - a.mtimeMs;
+  if (diff !== 0) return diff;
+  return a.name.localeCompare(b.name);
+}
+function applyDirLimit(children, limit) {
+  if (children.length <= limit) {
+    return { visible: children, dropped: 0 };
+  }
+  if (limit <= 1) {
+    return {
+      visible: children.slice(0, limit),
+      dropped: children.length - limit
+    };
+  }
+  const recent = children.slice(0, limit - 1);
+  const oldest = children[children.length - 1];
+  const visible = oldest ? [...recent, oldest] : recent;
+  return { visible, dropped: children.length - limit };
+}
+async function readChildren(rootPath, parent, excludedDirs) {
+  const dirPath = parent.relativePath ? path62.join(rootPath, parent.relativePath) : rootPath;
+  let names;
+  try {
+    names = await fs74.readdir(dirPath);
+  } catch {
+    return [];
+  }
+  const nodes = await Promise.all(
+    names.map(async (name) => {
+      if (name.startsWith(".")) return null;
+      const relativePath = parent.relativePath ? `${parent.relativePath}/${name}` : name;
+      const absolutePath = path62.join(rootPath, relativePath);
+      try {
+        const stat2 = await fs74.stat(absolutePath);
+        if (stat2.isDirectory() && excludedDirs.has(name)) return null;
+        return {
+          name,
+          relativePath,
+          depth: parent.depth + 1,
+          isDirectory: stat2.isDirectory(),
+          mtimeMs: stat2.mtimeMs,
+          size: stat2.size,
+          children: [],
+          droppedChildCount: 0
+        };
+      } catch {
+        return null;
+      }
+    })
+  );
+  return nodes.filter((n) => n !== null).sort(compareByRecency);
+}
+async function collectTree(rootPath, maxDepth, dirLimit, excludedDirs) {
+  const rootStat = await fs74.stat(rootPath);
+  const root = {
+    name: ".",
+    relativePath: "",
+    depth: 0,
+    isDirectory: true,
+    mtimeMs: rootStat.mtimeMs,
+    size: rootStat.size,
+    children: [],
+    droppedChildCount: 0
+  };
+  let truncated = false;
+  const queue = [root];
+  let cursor = 0;
+  while (cursor < queue.length) {
+    const parent = queue[cursor];
+    cursor += 1;
+    if (!parent || parent.depth >= maxDepth) continue;
+    const children = await readChildren(rootPath, parent, excludedDirs);
+    const { visible, dropped } = applyDirLimit(children, dirLimit);
+    parent.children = visible;
+    parent.droppedChildCount = dropped;
+    if (dropped > 0) truncated = true;
+    for (const child of visible) {
+      if (child.isDirectory) queue.push(child);
+    }
+  }
+  return { root, truncated };
+}
+function collectLines(node, nowMs3, lines) {
+  if (node.depth === 0) {
+    lines.push({ text: ".", depth: 0, isRoot: true });
+  } else {
+    const indent = "  ".repeat(node.depth);
+    const suffix = node.isDirectory ? "/" : "";
+    const label = `${indent}- ${node.name}${suffix}`;
+    if (node.isDirectory) {
+      lines.push({ text: label, depth: node.depth, isRoot: false });
+    } else {
+      const ageSeconds = Math.max(0, Math.floor((nowMs3 - node.mtimeMs) / 1e3));
+      const size = formatBytes2(node.size);
+      const age = formatAge(ageSeconds);
+      lines.push({
+        text: `${label}  ${size}  ${age}`,
+        depth: node.depth,
+        isRoot: false
+      });
+    }
+  }
+  if (node.droppedChildCount > 0) {
+    const recentChildren = node.children.slice(0, -1);
+    const oldestChild = node.children[node.children.length - 1];
+    for (const child of recentChildren) collectLines(child, nowMs3, lines);
+    const childDepth = node.depth + 1;
+    const indent = "  ".repeat(childDepth);
+    lines.push({
+      text: `${indent}- \u2026 ${node.droppedChildCount} more`,
+      depth: childDepth,
+      isRoot: false
+    });
+    if (oldestChild) collectLines(oldestChild, nowMs3, lines);
+  } else {
+    for (const child of node.children) collectLines(child, nowMs3, lines);
+  }
+}
+function applyLineCap(lines, cap) {
+  if (lines.length <= cap) return { lines, elided: 0 };
+  const target = Math.max(1, cap - 1);
+  const removeCount = lines.length - target;
+  const removable = lines.map((line4, index) => ({ line: line4, index })).filter((item) => !item.line.isRoot).sort((a, b) => b.line.depth - a.line.depth || b.index - a.index).slice(0, removeCount);
+  if (removable.length === 0) return { lines, elided: 0 };
+  const removedIndexes = new Set(removable.map((item) => item.index));
+  const kept = lines.filter((_, index) => !removedIndexes.has(index));
+  kept.push({
+    text: `\u2026 (${removable.length} lines elided)`,
+    depth: 0,
+    isRoot: false
+  });
+  return { lines: kept, elided: removable.length };
+}
+function treeCacheKey(cwd, options) {
+  return `${path62.resolve(cwd)}|${options?.maxDepth ?? ""}|${options?.dirLimit ?? ""}|${options?.lineCap ?? ""}`;
+}
+async function buildWorkspaceTree(cwd, options) {
+  const rootPath = path62.resolve(cwd);
+  const cacheKey2 = treeCacheKey(cwd, options);
+  const cached = treeCache.get(cacheKey2);
+  if (cached && cached.expiresAt > Date.now()) {
+    return cached.tree;
+  }
+  try {
+    const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const dirLimit = options?.dirLimit ?? DEFAULT_DIR_LIMIT;
+    const lineCap = options?.lineCap ?? DEFAULT_LINE_CAP;
+    const excludedDirs = options?.excludedDirs ?? DEFAULT_EXCLUDED_DIRS;
+    const { root, truncated: dirTruncated } = await collectTree(rootPath, maxDepth, dirLimit, excludedDirs);
+    const nowMs3 = Date.now();
+    const lines = [];
+    collectLines(root, nowMs3, lines);
+    const { lines: capped, elided } = applyLineCap(lines, lineCap);
+    const rendered = capped.map((l) => l.text).join("\n");
+    const result4 = {
+      rootPath,
+      rendered,
+      truncated: dirTruncated || elided > 0,
+      totalLines: capped.length
+    };
+    treeCache.set(cacheKey2, {
+      tree: result4,
+      expiresAt: Date.now() + TREE_CACHE_TTL_MS
+    });
+    return result4;
+  } catch {
+    return emptyResult(rootPath);
+  }
+}
+var DEFAULT_MAX_DEPTH, DEFAULT_DIR_LIMIT, DEFAULT_LINE_CAP, DEFAULT_EXCLUDED_DIRS, emptyResult, TREE_CACHE_TTL_MS, treeCache;
+var init_workspace_tree = __esm({
+  "src/runtime/workspace-tree.ts"() {
+    "use strict";
+    DEFAULT_MAX_DEPTH = 3;
+    DEFAULT_DIR_LIMIT = 12;
+    DEFAULT_LINE_CAP = 120;
+    DEFAULT_EXCLUDED_DIRS = /* @__PURE__ */ new Set([
+      "node_modules",
+      ".git",
+      ".next",
+      "dist",
+      "build",
+      "target",
+      ".venv",
+      ".cache",
+      ".turbo"
+    ]);
+    emptyResult = (rootPath) => ({
+      rootPath,
+      rendered: "",
+      truncated: false,
+      totalLines: 0
+    });
+    TREE_CACHE_TTL_MS = 3e4;
+    treeCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/runtime/run-coalesced-task-group.ts
+async function runCoalescedTaskGroup(input) {
+  const { manifest, groupTasks, step, agent, signal, executeWorkers } = input;
+  const groupId = groupTasks.map((t2) => t2.id).join("+");
+  const firstTask = groupTasks[0];
+  const taskIds = groupTasks.map((t2) => t2.id);
+  let updatedTasks = input.tasks.map((t2) => {
+    if (taskIds.includes(t2.id) && t2.status !== "running") {
+      return { ...t2, status: "running", startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+    return t2;
+  });
+  saveRunTasks(manifest, updatedTasks);
+  await appendEventAsync(manifest.eventsPath, {
+    type: "task.coalesced_dispatch_start",
+    runId: manifest.runId,
+    message: `Dispatching ${groupTasks.length} coalesced tasks in 1 worker (role=${firstTask.role}, cwd=${firstTask.cwd})`,
+    data: { groupId, role: firstTask.role, cwd: firstTask.cwd, taskIds }
+  });
+  const combinedPrompt = await buildCoalescedPrompt(manifest, step, groupTasks, agent);
+  updatedTasks = updatedTasks.map((t2) => {
+    if (!taskIds.includes(t2.id)) return t2;
+    return {
+      ...t2,
+      heartbeat: t2.heartbeat ?? createWorkerHeartbeat(t2.id)
+    };
+  });
+  saveRunTasks(manifest, updatedTasks);
+  let rawOutput = "";
+  let success = false;
+  if (!executeWorkers) {
+    rawOutput = buildScaffoldOutput(groupTasks);
+    success = true;
+  } else {
+    const heartbeatTimer = setInterval(() => {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      updatedTasks = updatedTasks.map((t2) => {
+        if (!taskIds.includes(t2.id)) return t2;
+        return {
+          ...t2,
+          heartbeat: touchWorkerHeartbeat(t2.heartbeat ?? createWorkerHeartbeat(t2.id), { alive: true })
+        };
+      });
+      try {
+        saveRunTasks(manifest, updatedTasks);
+      } catch {
+      }
+    }, 15e3);
+    try {
+      const result4 = await runChildPi({
+        cwd: firstTask.cwd,
+        task: combinedPrompt,
+        agent,
+        signal,
+        excludeContextBash: true,
+        maxTurns: 5,
+        onJsonEvent: (e) => input.onJsonEvent?.(firstTask.id, manifest.runId, e)
+      });
+      rawOutput = result4.rawFinalText ?? result4.stdout ?? "";
+      success = result4.exitStatus?.exitCode === 0;
+    } catch (err2) {
+      rawOutput = `Worker dispatch failed: ${err2 instanceof Error ? err2.message : String(err2)}`;
+      success = false;
+    } finally {
+      clearInterval(heartbeatTimer);
+    }
+  }
+  const split = splitCoalescedOutput(rawOutput, taskIds);
+  const finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const newArtifacts = [];
+  updatedTasks = updatedTasks.map((t2) => {
+    if (!taskIds.includes(t2.id)) return t2;
+    const entry = split.find((s) => s.taskId === t2.id);
+    const ok = success && Boolean(entry?.text);
+    const text = entry?.text ?? rawOutput;
+    const resultArtifact = writeArtifact(manifest.artifactsRoot, {
+      kind: "result",
+      relativePath: `results/${t2.id}.txt`,
+      content: text,
+      producer: t2.id
+    });
+    newArtifacts.push(resultArtifact);
+    return {
+      ...t2,
+      status: ok ? "completed" : "failed",
+      finishedAt,
+      result: {
+        text,
+        producer: groupId,
+        strategy: entry?.strategy ?? "broadcast"
+      },
+      resultArtifact
+    };
+  });
+  saveRunTasks(manifest, updatedTasks);
+  let updatedManifest = {
+    ...manifest,
+    artifacts: mergeArtifacts([...manifest.artifacts, ...newArtifacts])
+  };
+  if (success) {
+    updatedManifest = updateRunStatus(updatedManifest, "running");
+  }
+  await appendEventAsync(updatedManifest.eventsPath, {
+    type: "task.coalesced_dispatch_end",
+    runId: manifest.runId,
+    message: `Coalesced dispatch ${success ? "completed" : "failed"} (${taskIds.length} tasks, ${split[0]?.strategy ?? "broadcast"} split)`,
+    data: { groupId, taskIds, success, strategy: split[0]?.strategy }
+  });
+  return { manifest: updatedManifest, tasks: updatedTasks, taskIds, rawOutput, success };
+}
+async function buildCoalescedPrompt(manifest, step, groupTasks, agent) {
+  const tree = await buildWorkspaceTree(groupTasks[0].cwd);
+  const treeBlock = tree.rendered ? `# Workspace Structure
+${tree.rendered}` : "";
+  const roleInstructions = permissionForRole(groupTasks[0].role) === "read_only" ? `You are running in READ-ONLY mode. Do not create, modify, delete, or move files. Emit your findings as TEXT in your final output.` : "";
+  const taskBlocks = groupTasks.map((task, idx) => {
+    return [
+      `### Task ${idx + 1} of ${groupTasks.length} (id: ${task.id})`,
+      `Step: ${step.id}`,
+      `Role: ${step.role}`,
+      `Task: ${step.task.replaceAll("{goal}", manifest.goal)}`
+    ].join("\n");
+  }).join("\n\n---\n\n");
+  const outputInstructions = groupTasks.map((task) => `<<<TASK_RESULT:${task.id}>>>`).join(" ... ");
+  return [
+    "# pi-crew Coalesced Worker Prompt",
+    `Run ID: ${manifest.runId}`,
+    `Team: ${manifest.team}`,
+    `Workflow: ${manifest.workflow ?? "(none)"}`,
+    `Goal: ${manifest.goal}`,
+    `Tasks in this batch: ${groupTasks.length}`,
+    ``,
+    roleInstructions,
+    ``,
+    treeBlock,
+    ``,
+    `# Your Tasks`,
+    `Complete ALL ${groupTasks.length} tasks below. For each, structure your final output using the delimiters shown.`,
+    ``,
+    taskBlocks,
+    ``,
+    `# Output Format (CRITICAL)`,
+    `After completing all tasks, structure your final output using these delimiters:`,
+    ``,
+    outputInstructions,
+    ``,
+    `Wrap each task's result between the start and end delimiters:`,
+    `<<<TASK_RESULT:{taskId}>>>`,
+    `...your result for this task...`,
+    `<<<END_TASK_RESULT>>>`,
+    ``,
+    `If delimiters don't fit your workflow, use \`### Task N of M\` headings and we'll parse those instead.`
+  ].filter(Boolean).join("\n");
+}
+function buildScaffoldOutput(groupTasks) {
+  return groupTasks.map(
+    (task, idx) => `<<<TASK_RESULT:${task.id}>>>
+Scaffold result for task ${idx + 1} of ${groupTasks.length}: ${task.id}
+<<<END_TASK_RESULT>>>`
+  ).join("\n\n");
+}
+var init_run_coalesced_task_group = __esm({
+  "src/runtime/run-coalesced-task-group.ts"() {
+    "use strict";
+    init_artifact_store();
+    init_event_log();
+    init_state_store();
+    init_child_pi();
+    init_role_permission();
+    init_output_splitter();
+    init_team_runner_artifacts();
+    init_worker_heartbeat();
+    init_workspace_tree();
+  }
+});
+
 // src/runtime/runtime-policy.ts
 function resolveTaskRuntimeKind(globalKind, role, isolationPolicy, env = process.env) {
   if (globalKind === "scaffold") return "scaffold";
@@ -55719,7 +55828,7 @@ function hashToBase36(content, length) {
 }
 function calculateAdaptiveLength(existingCount, config = DEFAULT_CONFIG) {
   for (let length = config.minLength; length <= config.maxLength; length++) {
-    const totalPossibilities = Math.pow(36, length);
+    const totalPossibilities = 36 ** length;
     const probability = 1 - Math.exp(-(existingCount * existingCount) / (2 * totalPossibilities));
     if (probability <= config.maxCollisionProbability) {
       return length;
@@ -56812,7 +56921,8 @@ function persistSingleTaskUpdate(manifest, fallbackTasks, updated, checkpointPha
   } : updated;
   try {
     return withRunLockSync(manifest, () => {
-      retryLoop: for (let attempt = 0; attempt < 100; attempt++) {
+      for (let attempt = 0; attempt < 100; attempt++) {
+        flushPendingAtomicWrites();
         const latest = loadRunManifestById(manifest.cwd, manifest.runId)?.tasks ?? fallbackTasks;
         merged = updateTask(latest, taskWithCheckpoint);
         let currentMtime;
@@ -56823,7 +56933,7 @@ function persistSingleTaskUpdate(manifest, fallbackTasks, updated, checkpointPha
         }
         if (currentMtime !== baseMtime) {
           baseMtime = currentMtime;
-          continue retryLoop;
+          continue;
         }
         let recheckMtime;
         try {
@@ -56833,7 +56943,7 @@ function persistSingleTaskUpdate(manifest, fallbackTasks, updated, checkpointPha
         }
         if (recheckMtime !== baseMtime) {
           baseMtime = recheckMtime;
-          continue retryLoop;
+          continue;
         }
         let preWriteMtime;
         try {
@@ -56843,16 +56953,16 @@ function persistSingleTaskUpdate(manifest, fallbackTasks, updated, checkpointPha
         }
         if (preWriteMtime !== baseMtime) {
           baseMtime = preWriteMtime;
-          continue retryLoop;
+          continue;
         }
-        break retryLoop;
+        break;
       }
       if (merged === void 0) {
         logInternalError("persistSingleTaskUpdate", new Error("failed to converge after 50 attempts"));
         throw new Error("persistSingleTaskUpdate: failed to converge after 50 attempts");
       }
       try {
-        saveRunTasks(manifest, merged);
+        saveRunTasksCoalesced(manifest, merged);
       } catch (err2) {
         logInternalError("persistSingleTaskUpdate", err2);
         throw err2;
@@ -56884,6 +56994,7 @@ function checkpointTask(manifest, tasks, task, phase, childPid) {
 var init_state_helpers = __esm({
   "src/runtime/task-runner/state-helpers.ts"() {
     "use strict";
+    init_atomic_write();
     init_locks();
     init_state_store();
     init_internal_error();
@@ -60494,10 +60605,8 @@ var init_team_runner = __esm({
     init_usage();
     init_internal_error();
     init_branch_freshness();
-    init_team_runner_artifacts();
     init_cancellation();
     init_coalesce_tasks();
-    init_run_coalesced_task_group();
     init_concurrency();
     init_crew_agent_records();
     init_crew_hooks();
@@ -60512,6 +60621,7 @@ var init_team_runner = __esm({
     init_recovery_recipes();
     init_retry_executor();
     init_role_permission();
+    init_run_coalesced_task_group();
     init_run_tracker();
     init_runtime_policy();
     init_task_display();
@@ -60519,6 +60629,7 @@ var init_team_runner = __esm({
     init_task_graph_scheduler();
     init_task_output_context();
     init_task_runner();
+    init_team_runner_artifacts();
     init_usage_tracker();
     init_workflow_state();
     init_adaptive_plan();
@@ -68516,7 +68627,6 @@ function tryScanJson(text) {
     try {
       return JSON.parse(candidate);
     } catch {
-      continue;
     }
   }
   return void 0;
@@ -68672,7 +68782,7 @@ function makeWorkflowCtx(manifest, opts) {
   const semaphore = new Semaphore(concurrency);
   let finalResult;
   let agentCount = opts.resumedState ? opts.resumedState.agentCount : 0;
-  let phaseState = opts.resumedState ? {
+  const phaseState = opts.resumedState ? {
     currentPhase: opts.resumedState.currentPhase,
     phases: [...opts.resumedState.phases]
   } : { currentPhase: void 0, phases: [] };
@@ -69443,6 +69553,48 @@ ${tail}` : ""}`;
   }, 3e3);
   timer.unref();
 }
+function resolveAnalysisText(params, cwd) {
+  const hasInline = typeof params.analysis === "string" && params.analysis.length > 0;
+  const hasPath = typeof params.analysisPath === "string" && params.analysisPath.length > 0;
+  if (hasInline && hasPath) {
+    return {
+      error: "`analysis` and `analysisPath` are mutually exclusive. Set exactly one.",
+      source: "none"
+    };
+  }
+  if (!hasInline && !hasPath) return { source: "none" };
+  if (hasPath) {
+    let resolved;
+    try {
+      resolved = resolveContainedPath(cwd, params.analysisPath);
+    } catch {
+      return {
+        error: `analysisPath must be within project directory: ${params.analysisPath}`,
+        source: "none"
+      };
+    }
+    if (!fs90.existsSync(resolved)) {
+      return {
+        error: `Analysis file not found: ${resolved}`,
+        source: "none"
+      };
+    }
+    const { size } = fs90.statSync(resolved);
+    if (size > MAX_ANALYSIS_BYTES) {
+      return {
+        error: `Analysis file too large: ${size} bytes (max ${MAX_ANALYSIS_BYTES}). Trim the analysis or pass a summary inline.`,
+        source: "none"
+      };
+    }
+    const raw = fs90.readFileSync(resolved, "utf-8");
+    const sanitized2 = sanitizeTaskText(raw);
+    if (!sanitized2) return { source: "none" };
+    return { text: sanitized2, source: "path" };
+  }
+  const sanitized = sanitizeTaskText(params.analysis);
+  if (!sanitized) return { source: "none" };
+  return { text: sanitized, source: "inline" };
+}
 async function handleRun(params, ctx) {
   if (params.chain) {
     const { handleChainRun: handleChainRun2 } = await Promise.resolve().then(() => (init_chain_dispatch(), chain_dispatch_exports));
@@ -69526,11 +69678,14 @@ Commit or stash changes before using worktree mode, or use workspaceMode: 'singl
         id: "01_agent",
         role: params.role ?? "agent",
         task: "{goal}",
-        model: params.model
+        model: params.model,
+        reads: params.analysis || params.analysisPath ? ["analysis.md"] : void 0
       }
     ]
   } : workflows.find((item) => item.name === workflowName);
   if (!baseWorkflow) return result(`Workflow '${workflowName}' not found.`, { action: "run", status: "error" }, true);
+  const analysisParam = resolveAnalysisText(params, resolvedCtx.cwd);
+  if (analysisParam.error) return result(analysisParam.error, { action: "run", status: "error" }, true);
   const { expandParallelResearchWorkflow: expandParallelResearch } = await Promise.resolve().then(() => (init_parallel_research(), parallel_research_exports));
   const workflow = directAgent ? baseWorkflow : expandParallelResearch(baseWorkflow, resolvedCtx.cwd);
   if (!directAgent) {
@@ -69548,6 +69703,11 @@ Commit or stash changes before using worktree mode, or use workspaceMode: 'singl
   if (!directAgent && workflow.source === "builtin" && isGoalWrapEnabled(resolvedCtx.cwd, workflow.name)) {
     const decision2 = shouldGoalWrap(resolvedCtx.cwd, workflow);
     if (decision2.enabled) {
+      if (analysisParam.text) {
+        console.warn(
+          `[team-tool.run] analysis param is ignored by goal-wrapped run (workflow=${workflow.name}). The analysis artifact will not be written.`
+        );
+      }
       return await startGoalWrappedRun(params, ctx, workflow, goal);
     }
     if (decision2.message) {
@@ -69623,10 +69783,19 @@ Commit or stash changes before using worktree mode, or use workspaceMode: 'singl
 `,
     producer: "team-tool"
   });
+  const analysisArtifacts = analysisParam.text ? [
+    writeArtifact(paths.artifactsRoot, {
+      kind: "prompt",
+      relativePath: "shared/analysis.md",
+      content: `${analysisParam.text}
+`,
+      producer: "team-tool"
+    })
+  ] : [];
   const updatedManifest = {
     ...manifest,
     ...skillOverride !== void 0 ? { skillOverride } : {},
-    artifacts: [goalArtifact],
+    artifacts: [goalArtifact, ...analysisArtifacts],
     summary: "Run manifest created; worker execution is not implemented yet."
   };
   atomicWriteJson(paths.manifestPath, updatedManifest);
@@ -70140,13 +70309,14 @@ ${dwfResult.manifest.summary ?? ""}`,
     executed.manifest.status === "failed"
   );
 }
-var _cachedExecuteTeamRun, crewInitPromise;
+var _cachedExecuteTeamRun, crewInitPromise, MAX_ANALYSIS_BYTES;
 var init_run = __esm({
   "src/extension/team-tool/run.ts"() {
     "use strict";
     init_discover_agents();
     init_config();
     init_pipeline_runner();
+    init_task_packet();
     init_active_run_registry();
     init_artifact_store();
     init_atomic_write();
@@ -70166,6 +70336,7 @@ var init_run = __esm({
     init_config_patch();
     init_context();
     init_goal_wrap();
+    MAX_ANALYSIS_BYTES = 1e5;
   }
 });