pi-crew 0.9.17 → 0.9.18

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;
@@ -47299,7 +47397,6 @@ function snapshotManifests(cwd) {
       const content = fs59.readFileSync(abs);
       snapshot[rel] = createHash6("sha256").update(content).digest("hex");
     } catch {
-      continue;
     }
   }
   return snapshot;
@@ -47481,7 +47578,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 +47668,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 +53238,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,490 +53364,6 @@ 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"
-    }));
-  }
-  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/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`;
-}
-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 ? path61.join(rootPath, parent.relativePath) : rootPath;
-  let names;
-  try {
-    names = await fs73.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 = 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);
-}
-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);
-    }
-  }
-  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 `${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;
-  }
-  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;
@@ -54023,12 +53625,12 @@ var init_tool_output_pruner = __esm({
 });
 
 // src/runtime/task-output-context.ts
-import * as fs74 from "node:fs";
-import * as path62 from "node:path";
+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 +53640,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 +53655,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 +53689,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 +53712,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 +53770,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 +53823,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 +54335,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 +55817,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 +56910,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 +56922,7 @@ function persistSingleTaskUpdate(manifest, fallbackTasks, updated, checkpointPha
         }
         if (currentMtime !== baseMtime) {
           baseMtime = currentMtime;
-          continue retryLoop;
+          continue;
         }
         let recheckMtime;
         try {
@@ -56833,7 +56932,7 @@ function persistSingleTaskUpdate(manifest, fallbackTasks, updated, checkpointPha
         }
         if (recheckMtime !== baseMtime) {
           baseMtime = recheckMtime;
-          continue retryLoop;
+          continue;
         }
         let preWriteMtime;
         try {
@@ -56843,16 +56942,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 +56983,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 +60594,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 +60610,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 +60618,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 +68616,6 @@ function tryScanJson(text) {
     try {
       return JSON.parse(candidate);
     } catch {
-      continue;
     }
   }
   return void 0;
@@ -68672,7 +68771,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: [] };