@sortedyuan/maybecode 0.3.2 → 0.5.0

package/dist/cli/{team-v2-JGBBQ7FR.js → team-v2-YYO2G7DJ.js}

@@ -1,17 +1,18 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
+  TeamExecutionEnvironments,
   createListTool
-} from "./chunk-F4XRPLUM.js";
+} from "./chunk-SLWLUEHQ.js";
 import {
   createMaybeCodeModel,
   getDefaultMaybeCodeDataDirectory,
-  loadMayConfig,
+  readMaybeCodeSettings,
+  resolveMaybeCodeRecording,
   selectMaybeCodeModel
-} from "./chunk-WOFEI42C.js";
-import "./chunk-H7SNBFO4.js";
-import "./chunk-VAZMCNBB.js";
+} from "./chunk-3IORPKBL.js";
+import "./chunk-MNBYXL5Y.js";
+import "./chunk-WVIRS76R.js";
 import {
-  AsyncStateSerializer,
   CoordinationRuntime,
   FileArtifactStore,
   FileCoordinationStore,
@@ -19,49 +20,60 @@ import {
   MaybeCodeUsageError,
   TaskWorkspaceManager,
   createApplicationAgent,
-  createEditTool,
-  createReadTool,
-  createWriteTool,
-  defineAgent,
+  require_lib,
   sharedBudgetTotals
-} from "./chunk-K5JWPNSY.js";
+} from "./chunk-5SLWALZK.js";
+import "./chunk-UQDZ55LQ.js";
 import "./chunk-BSBNNF34.js";
 import {
-  __name
+  __name,
+  __toESM
 } from "./chunk-E732GDOI.js";
 
 // apps/maybecode/src/team-v2.ts
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdir as mkdir3, open as open5, readFile, realpath as realpath3, rename as rename2, stat } from "node:fs/promises";
+import { mkdir as mkdir3, open as open5, readFile, realpath as realpath3, stat } from "node:fs/promises";
 import { dirname as dirname2, isAbsolute as isAbsolute3, join as join4, relative as relative3, resolve as resolve3, sep as sep3 } from "node:path";
-import { resolveRunBudget as resolveRunBudget2 } from "@sortedyuan/core";
-import { FileSessionStore as FileSessionStore2 } from "@sortedyuan/session/file-store";
-import { withFileAccess } from "@sortedyuan/session/file-access";
+import { defineAgent } from "@sortedyuan/may";
+import {
+  createEditTool,
+  createReadTool,
+  createWriteTool,
+  createGlobTool,
+  createGrepTool,
+  createFetchTool
+} from "@sortedyuan/coding-tools";
+import { loadMayConfig } from "@sortedyuan/may/config";
+var import_write_file_atomic = __toESM(require_lib(), 1);
+import { resolveRunBudget as resolveRunBudget2 } from "@sortedyuan/may/core";
+import { FileSessionStore as FileSessionStore2 } from "@sortedyuan/may/session/file-store";
+import { hasErrorCode as hasErrorCode3, withFileAccess } from "@sortedyuan/may/storage";
 
 // apps/maybecode/src/team-plan.ts
 import { open as open2 } from "node:fs/promises";
-import { resolveRunBudget } from "@sortedyuan/core";
+import { omitUndefined, resolveRunBudget } from "@sortedyuan/may/core";
 
 // apps/maybecode/src/team-verification.ts
-import { acquireFileLock, releaseFileLock } from "@sortedyuan/session/file-store";
+import { acquireFileLock, hasErrorCode } from "@sortedyuan/may/storage";
 import { createHash } from "node:crypto";
-import { spawn } from "node:child_process";
 import { constants } from "node:fs";
 import { lstat, mkdir, open, readdir, realpath } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { isDeepStrictEqual } from "node:util";
+import { AsyncStateSerializer } from "@sortedyuan/may/core";
+import { openCodingExecutionEnvironment } from "@sortedyuan/coding-tools";
 var maxJournalBytes = 16777216;
 var TeamVerificationStore = class _TeamVerificationStore {
-  constructor(file, lock, lockPath, checks) {
+  constructor(file, lock, checks, executionFor) {
     this.file = file;
     this.lock = lock;
-    this.lockPath = lockPath;
     this.checks = checks;
+    this.executionFor = executionFor;
   }
   file;
   lock;
-  lockPath;
   checks;
+  executionFor;
   static {
     __name(this, "TeamVerificationStore");
   }
@@ -76,14 +88,12 @@ var TeamVerificationStore = class _TeamVerificationStore {
   static async open(options) {
     const checks = parseTeamChecks(options.checks ?? []);
     await mkdir(options.directory, { recursive: true });
-    if ((await lstat(options.directory)).isSymbolicLink()) throw new Error("Verification directory must not be a symbolic link");
+    if ((await lstat(options.directory)).isSymbolicLink())
+      throw new Error("Verification directory must not be a symbolic link");
     const path = join(await realpath(options.directory), "verification.jsonl");
-    const lockPath = `${path}.lock`;
-    const lock = await acquireFileLock(lockPath);
+    const lock = await acquireFileLock(`${path}.lock`);
     let file;
     try {
-      await lock.writeFile(JSON.stringify({ pid: process.pid }));
-      await lock.sync();
       await rejectLinkIfPresent(path);
       file = await open(path, constants.O_CREAT | constants.O_APPEND | constants.O_RDWR | noFollow(), 384);
       const { entries, committed, size } = await readJournal(file);
@@ -96,21 +106,33 @@ var TeamVerificationStore = class _TeamVerificationStore {
           await repair.close();
         }
       }
-      const store = new _TeamVerificationStore(file, lock, lockPath, checks);
+      const store = new _TeamVerificationStore(file, lock, checks, options.executionFor);
       store.size = committed;
       for (const entry of entries) {
         store.apply(entry.event);
         store.sequence = entry.sequence;
       }
-      if (entries.length && !isDeepStrictEqual(entries[0].event.checks, checks)) throw new Error("Verification checks changed on resume");
+      if (entries.length && !isDeepStrictEqual(entries[0].event.checks, checks))
+        throw new Error("Verification checks changed on resume");
       if (!entries.length) await store.append({ type: "config", checks });
-      for (const result of store.results.values()) if (result.status === "pending") {
-        await store.append({ type: "check", result: { ...result, status: "unknown", detail: "Interrupted check; inspect effects and reconcile before a new command." } });
-      }
+      for (const result of store.results.values())
+        if (result.status === "pending") {
+          await store.append({
+            type: "check",
+            result: {
+              ...result,
+              status: "unknown",
+              detail: "Interrupted check; inspect effects and reconcile before a new command."
+            }
+          });
+        }
       return store;
     } catch (error) {
-      await file?.close().catch(() => void 0);
-      await releaseFileLock(lock, lockPath);
+      try {
+        await file?.close();
+      } finally {
+        await lock.release();
+      }
       throw error;
     }
   }
@@ -122,7 +144,7 @@ var TeamVerificationStore = class _TeamVerificationStore {
     try {
       file = await open(path, constants.O_RDONLY | noFollow());
     } catch (error) {
-      if (isMissing(error)) return { reports: [], checks: [] };
+      if (hasErrorCode(error, "ENOENT")) return { reports: [], checks: [] };
       throw error;
     }
     try {
@@ -152,38 +174,72 @@ var TeamVerificationStore = class _TeamVerificationStore {
       if (!spec) throw new Error("Check is not configured for this task");
       return this.runCheck(commandId, spec, workspace, { ...options, ...extra, execution });
     }, "runCheck");
-    const tools = /* @__PURE__ */ __name(() => [{
-      name: "submit_report",
-      permissionVersion: "team-verification-v1",
-      description: "Store a structured report and file/line evidence. The host validates evidence bytes, not claim correctness. This never grants acceptance.",
-      inputSchema: { type: "object", additionalProperties: false, required: ["summary", "claims"], properties: {
-        summary: { type: "string" },
-        claims: { type: "array", items: { type: "object", additionalProperties: false, required: ["text", "kind"], properties: {
-          text: { type: "string" },
-          kind: { type: "string", enum: ["finding", "proposal"] },
-          evidence: { type: "array", items: { type: "object", additionalProperties: false, required: ["path", "startLine", "endLine"], properties: { path: { type: "string" }, startLine: { type: "integer" }, endLine: { type: "integer" }, quote: { type: "string" } } } }
-        } } }
-      } },
-      parse: parseTeamReport,
-      async execute(input, call) {
-        call.signal.throwIfAborted();
-        return submit(hash(call.idempotencyKey), input);
-      }
-    }, {
-      name: "run_check",
-      permissionVersion: "team-verification-v1",
-      description: `Run one exact host-configured check by id; no model-supplied commands or arguments. Available: ${this.checks.filter((entry) => entry.taskId === identity.taskId).map((entry) => entry.id).join(", ") || "none"}. Command checks require explicit host authorization and are not sandboxed.`,
-      inputSchema: { type: "object", additionalProperties: false, required: ["id"], properties: { id: { type: "string" } } },
-      parse(value) {
-        const input = fields(value, ["id"]);
-        identifier(input.id, "check id");
-        return { id: input.id };
+    const tools = /* @__PURE__ */ __name(() => [
+      {
+        name: "submit_report",
+        permissionVersion: "team-verification-v1",
+        description: "Store a structured report and file/line evidence. The host validates evidence bytes, not claim correctness. This never grants acceptance.",
+        inputSchema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["summary", "claims"],
+          properties: {
+            summary: { type: "string" },
+            claims: {
+              type: "array",
+              items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["text", "kind"],
+                properties: {
+                  text: { type: "string" },
+                  kind: { type: "string", enum: ["finding", "proposal"] },
+                  evidence: {
+                    type: "array",
+                    items: {
+                      type: "object",
+                      additionalProperties: false,
+                      required: ["path", "startLine", "endLine"],
+                      properties: {
+                        path: { type: "string" },
+                        startLine: { type: "integer" },
+                        endLine: { type: "integer" },
+                        quote: { type: "string" }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
+        parse: parseTeamReport,
+        async execute(input, call) {
+          call.signal.throwIfAborted();
+          return submit(hash(call.idempotencyKey), input);
+        }
       },
-      async execute(input, call) {
-        call.signal.throwIfAborted();
-        return runCheck(hash(call.idempotencyKey), input.id, { signal: call.signal });
+      {
+        name: "run_check",
+        permissionVersion: "team-verification-v1",
+        description: `Run one exact host-configured check by id; no model-supplied commands or arguments. Available: ${this.checks.filter((entry) => entry.taskId === identity.taskId).map((entry) => entry.id).join(", ") || "none"}. Command checks require explicit host authorization and are not sandboxed.`,
+        inputSchema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["id"],
+          properties: { id: { type: "string" } }
+        },
+        parse(value) {
+          const input = fields(value, ["id"]);
+          identifier(input.id, "check id");
+          return { id: input.id };
+        },
+        async execute(input, call) {
+          call.signal.throwIfAborted();
+          return runCheck(hash(call.idempotencyKey), input.id, { signal: call.signal });
+        }
       }
-    }], "tools");
+    ], "tools");
     return { submit, runCheck, tools };
   }
   runCheck(commandId, input, workspace, options = {}) {
@@ -195,16 +251,19 @@ var TeamVerificationStore = class _TeamVerificationStore {
   /** Host reconciliation never invents a passing result and never executes a command. */
   async reconcile(commandId, outcome, evidence) {
     boundedString(evidence, "reconciliation evidence", 8192);
-    if (outcome.status !== "failed" && outcome.status !== "cancelled") throw new Error("Reconciliation cannot grant acceptance");
+    if (outcome.status !== "failed" && outcome.status !== "cancelled")
+      throw new Error("Reconciliation cannot grant acceptance");
     return this.serial.run(async () => {
       this.assertOpen();
       const current = this.results.get(commandId);
       if (!current) throw new Error("Unknown check command");
       if (current.reconciliation) {
-        if (current.status !== outcome.status || current.reconciliation !== evidence) throw new Error("Reconciliation already recorded differently");
+        if (current.status !== outcome.status || current.reconciliation !== evidence)
+          throw new Error("Reconciliation already recorded differently");
         return structuredClone(current);
       }
-      if (current.status !== "unknown") throw new Error("Only an unknown check can be reconciled; an active pending check must first stop");
+      if (current.status !== "unknown")
+        throw new Error("Only an unknown check can be reconciled; an active pending check must first stop");
       const result = { ...current, status: outcome.status, reconciliation: evidence };
       await this.write({ type: "check", result });
       return structuredClone(result);
@@ -216,10 +275,17 @@ var TeamVerificationStore = class _TeamVerificationStore {
     const identity = execution ? taskIdentity(execution) : void 0;
     const report = state.reports.filter((entry) => entry.taskId === taskId && (!identity || sameIdentity(entry, identity))).at(-1);
     const checks = this.checks.filter((spec) => spec.taskId === taskId).map((spec) => {
-      const result = state.checks.filter((entry) => entry.spec.id === spec.id && (!identity || entry.dispatchId === void 0 || sameIdentity(entry, identity))).at(-1);
+      const result = state.checks.filter(
+        (entry) => entry.spec.id === spec.id && (!identity || entry.dispatchId === void 0 || sameIdentity(entry, identity))
+      ).at(-1);
       if (!result) return { id: spec.id, status: "missing" };
       const stale = result.workspaceFingerprint !== fingerprint || result.afterFingerprint !== fingerprint;
-      return { id: spec.id, status: stale && !["pending", "unknown"].includes(result.status) ? "stale" : result.status, commandId: result.commandId, ...result.detail ? { detail: result.detail } : {} };
+      return {
+        id: spec.id,
+        status: stale && !["pending", "unknown"].includes(result.status) ? "stale" : result.status,
+        commandId: result.commandId,
+        ...result.detail ? { detail: result.detail } : {}
+      };
     });
     const currentReport = report?.workspaceFingerprint === fingerprint;
     const badEvidence = currentReport && report.evidence.some((item) => !item.valid);
@@ -239,7 +305,7 @@ var TeamVerificationStore = class _TeamVerificationStore {
       try {
         await this.file.close();
       } finally {
-        await releaseFileLock(this.lock, this.lockPath);
+        await this.lock.release();
       }
     })();
   }
@@ -250,32 +316,41 @@ var TeamVerificationStore = class _TeamVerificationStore {
       this.assertOpen();
       const old = this.reports.find((entry) => entry.commandId === commandId);
       if (old) {
-        if (!sameIdentity(old, identity) || !isDeepStrictEqual(old.report, report)) throw new Error("Report command already used with different content or identity");
+        if (!sameIdentity(old, identity) || !isDeepStrictEqual(old.report, report))
+          throw new Error("Report command already used with different content or identity");
         return structuredClone(old);
       }
       if (this.reports.length >= 256) throw new Error("Report quota exceeded");
       const fingerprint = await workspaceFingerprint(workspace);
       const evidence = [];
-      for (const claim of report.claims) for (const item of claim.evidence ?? []) {
-        try {
-          const bytes = await readWorkspaceFile(workspace, item.path);
-          const lines2 = bytes.toString("utf8").replace(/\r\n/gu, "\n").split("\n");
-          if (lines2.at(-1) === "") lines2.pop();
-          const excerpt = lines2.slice(item.startLine - 1, item.endLine).join("\n");
-          const valid = item.endLine <= lines2.length && (item.quote === void 0 || excerpt.includes(item.quote.replace(/\r\n/gu, "\n")));
-          evidence.push({
-            path: item.path,
-            startLine: item.startLine,
-            endLine: item.endLine,
-            sha256: hash(bytes),
-            valid,
-            ...!valid ? { detail: "Line range or quote does not match the file" } : {}
-          });
-        } catch (error) {
-          evidence.push({ path: item.path, startLine: item.startLine, endLine: item.endLine, valid: false, detail: message(error) });
+      for (const claim of report.claims)
+        for (const item of claim.evidence ?? []) {
+          try {
+            const bytes = await readWorkspaceFile(workspace, item.path);
+            const lines2 = bytes.toString("utf8").replace(/\r\n/gu, "\n").split("\n");
+            if (lines2.at(-1) === "") lines2.pop();
+            const excerpt = lines2.slice(item.startLine - 1, item.endLine).join("\n");
+            const valid = item.endLine <= lines2.length && (item.quote === void 0 || excerpt.includes(item.quote.replace(/\r\n/gu, "\n")));
+            evidence.push({
+              path: item.path,
+              startLine: item.startLine,
+              endLine: item.endLine,
+              sha256: hash(bytes),
+              valid,
+              ...!valid ? { detail: "Line range or quote does not match the file" } : {}
+            });
+          } catch (error) {
+            evidence.push({
+              path: item.path,
+              startLine: item.startLine,
+              endLine: item.endLine,
+              valid: false,
+              detail: message(error)
+            });
+          }
         }
-      }
-      if (await workspaceFingerprint(workspace) !== fingerprint) throw new Error("Workspace changed while validating report evidence");
+      if (await workspaceFingerprint(workspace) !== fingerprint)
+        throw new Error("Workspace changed while validating report evidence");
       const stored = { ...identity, commandId, report, workspaceFingerprint: fingerprint, evidence };
       await this.write({ type: "report", report: stored });
       return structuredClone(stored);
@@ -293,14 +368,25 @@ var TeamVerificationStore = class _TeamVerificationStore {
       this.assertOpen();
       const old = this.results.get(commandId);
       if (old) {
-        if (!isDeepStrictEqual(old.spec, spec) || !sameIdentity(old, identity)) throw new Error("Check command already used with different specification or identity");
+        if (!isDeepStrictEqual(old.spec, spec) || !sameIdentity(old, identity))
+          throw new Error("Check command already used with different specification or identity");
         return structuredClone(old);
       }
       if (this.results.size >= 512) throw new Error("Check quota exceeded");
-      if ([...this.results.values()].some((entry) => entry.taskId === spec.taskId && ["unknown", "pending"].includes(entry.status))) throw new Error("Task has a pending or unknown check; inspect and reconcile before another check");
-      if (spec.type === "command" && options.allowCommands !== true) throw new Error("Command checks require explicit --allow-checks authorization");
+      if ([...this.results.values()].some(
+        (entry) => entry.taskId === spec.taskId && ["unknown", "pending"].includes(entry.status)
+      ))
+        throw new Error("Task has a pending or unknown check; inspect and reconcile before another check");
+      if (spec.type === "command" && options.allowCommands !== true)
+        throw new Error("Command checks require explicit --allow-checks authorization");
       options.signal?.throwIfAborted();
-      const result2 = { ...identity, commandId, spec, workspaceFingerprint: await workspaceFingerprint(workspace), status: "pending" };
+      const result2 = {
+        ...identity,
+        commandId,
+        spec,
+        workspaceFingerprint: await workspaceFingerprint(workspace),
+        status: "pending"
+      };
       await this.write({ type: "check", result: result2 });
       fresh = true;
       return result2;
@@ -308,12 +394,15 @@ var TeamVerificationStore = class _TeamVerificationStore {
     if (!fresh) return pending;
     let outcome;
     try {
-      if (spec.type === "command") outcome = await runCommand(spec, workspace, options.signal);
+      if (spec.type === "command") outcome = await runCommand(spec, workspace, options.signal, this.executionFor);
       else {
         options.signal?.throwIfAborted();
         const bytes = await readWorkspaceFile(workspace, spec.path);
         const passed = spec.type === "file-sha256" ? hash(bytes) === spec.sha256 : bytes.toString("utf8").includes(spec.text);
-        outcome = { status: passed ? "passed" : "failed", detail: passed ? "Exact configured file check passed" : "Configured file predicate did not match" };
+        outcome = {
+          status: passed ? "passed" : "failed",
+          detail: passed ? "Exact configured file check passed" : "Configured file predicate did not match"
+        };
       }
     } catch (error) {
       outcome = { status: spec.type === "command" ? "unknown" : "failed", detail: message(error) };
@@ -322,7 +411,11 @@ var TeamVerificationStore = class _TeamVerificationStore {
     try {
       afterFingerprint = await workspaceFingerprint(workspace);
     } catch (error) {
-      outcome = { ...outcome, status: spec.type === "command" ? "unknown" : "failed", detail: `Cannot inspect workspace after check: ${message(error)}` };
+      outcome = {
+        ...outcome,
+        status: spec.type === "command" ? "unknown" : "failed",
+        detail: `Cannot inspect workspace after check: ${message(error)}`
+      };
     }
     const result = { ...pending, ...outcome, ...afterFingerprint ? { afterFingerprint } : {} };
     await this.append({ type: "check", result });
@@ -357,7 +450,18 @@ var TeamVerificationStore = class _TeamVerificationStore {
   }
 };
 function parseTeamCheck(value) {
-  const raw = fields(value, ["id", "taskId", "type", "path", "text", "sha256", "command", "args", "timeoutMs", "maxOutputBytes"]);
+  const raw = fields(value, [
+    "id",
+    "taskId",
+    "type",
+    "path",
+    "text",
+    "sha256",
+    "command",
+    "args",
+    "timeoutMs",
+    "maxOutputBytes"
+  ]);
   identifier(raw.id, "check id");
   identifier(raw.taskId, "check taskId");
   if (raw.type === "file-contains") {
@@ -371,7 +475,8 @@ function parseTeamCheck(value) {
   } else if (raw.type === "command") {
     fields(raw, ["id", "taskId", "type", "command", "args", "timeoutMs", "maxOutputBytes"]);
     boundedString(raw.command, "check command", 4096);
-    if (/[\u0000\r\n]/u.test(raw.command) || !Array.isArray(raw.args) || raw.args.length > 64 || raw.args.some((arg) => typeof arg !== "string" || arg.length > 8192 || arg.includes("\0"))) throw new Error("Invalid check command arguments");
+    if (/[\u0000\r\n]/u.test(raw.command) || !Array.isArray(raw.args) || raw.args.length > 64 || raw.args.some((arg) => typeof arg !== "string" || arg.length > 8192 || arg.includes("\0")))
+      throw new Error("Invalid check command arguments");
     if (raw.timeoutMs !== void 0) integer(raw.timeoutMs, 1, 12e4, "check timeoutMs");
     if (raw.maxOutputBytes !== void 0) integer(raw.maxOutputBytes, 1, 1048576, "check maxOutputBytes");
   } else throw new Error("Unknown check type");
@@ -388,7 +493,8 @@ __name(parseTeamChecks, "parseTeamChecks");
 function parseTeamReport(value) {
   const report = fields(value, ["summary", "claims"]);
   boundedString(report.summary, "report summary", 8192);
-  if (!Array.isArray(report.claims) || report.claims.length > 64) throw new Error("Report claims must be an array of at most 64 entries");
+  if (!Array.isArray(report.claims) || report.claims.length > 64)
+    throw new Error("Report claims must be an array of at most 64 entries");
   for (const value2 of report.claims) {
     const claim = fields(value2, ["text", "kind", "evidence"]);
     boundedString(claim.text, "claim text", 4096);
@@ -400,7 +506,8 @@ function parseTeamReport(value) {
         safeRelative(evidence.path);
         integer(evidence.startLine, 1, 1e6, "evidence startLine");
         integer(evidence.endLine, evidence.startLine, 1e6, "evidence endLine");
-        if (evidence.endLine - evidence.startLine > 1e3) throw new Error("Evidence range exceeds 1001 lines");
+        if (evidence.endLine - evidence.startLine > 1e3)
+          throw new Error("Evidence range exceeds 1001 lines");
         if (evidence.quote !== void 0) boundedString(evidence.quote, "evidence quote", 8192);
       }
     }
@@ -421,7 +528,8 @@ async function workspaceFingerprint(directory) {
       const child = join(path, name);
       const stat2 = await lstat(child);
       const nameInRoot = relative(root, child).split(sep).join("/");
-      if (++files > 1e4 || stat2.isSymbolicLink()) throw new Error("Workspace exceeds 10000 entries or contains a symbolic link");
+      if (++files > 1e4 || stat2.isSymbolicLink())
+        throw new Error("Workspace exceeds 10000 entries or contains a symbolic link");
       if (stat2.isDirectory()) {
         entries.push([nameInRoot, "directory"]);
         await visit(child);
@@ -447,13 +555,15 @@ async function readWorkspaceFile(directory, path) {
   }
   const canonical = await realpath(target);
   const rel = relative(root, canonical);
-  if (!rel || rel.startsWith(`..${sep}`) || rel === ".." || isAbsolute(rel)) throw new Error("Evidence/check path escapes workspace");
+  if (!rel || rel.startsWith(`..${sep}`) || rel === ".." || isAbsolute(rel))
+    throw new Error("Evidence/check path escapes workspace");
   const before = await lstat(target);
   if (!before.isFile() || before.size > 67108864) throw new Error("Evidence/check file is invalid or exceeds 64 MiB");
   const file = await open(target, constants.O_RDONLY | noFollow());
   try {
     const current = await file.stat();
-    if (!current.isFile() || current.dev !== before.dev || current.ino !== before.ino || current.size !== before.size) throw new Error("File changed while opening");
+    if (!current.isFile() || current.dev !== before.dev || current.ino !== before.ino || current.size !== before.size)
+      throw new Error("File changed while opening");
     const buffer = Buffer.alloc(before.size + 1);
     let length = 0;
     while (length < buffer.length) {
@@ -462,43 +572,79 @@ async function readWorkspaceFile(directory, path) {
       length += chunk.bytesRead;
     }
     const after = await file.stat();
-    if (length !== before.size || after.size !== current.size || after.mtimeMs !== current.mtimeMs) throw new Error("File changed while reading");
+    if (length !== before.size || after.size !== current.size || after.mtimeMs !== current.mtimeMs)
+      throw new Error("File changed while reading");
     return buffer.subarray(0, length);
   } finally {
     await file.close();
   }
 }
 __name(readWorkspaceFile, "readWorkspaceFile");
-async function runCommand(spec, workspace, signal) {
+async function runCommand(spec, workspace, signal, executionFor) {
+  const environment = executionFor ? await executionFor(workspace) : await openCodingExecutionEnvironment({ workspace, isolation: { mode: "host" } });
+  try {
+    return await runEnvironmentCommand(spec, workspace, environment, signal);
+  } finally {
+    if (!executionFor) await environment.close();
+  }
+}
+__name(runCommand, "runCommand");
+async function runEnvironmentCommand(spec, workspace, environment, signal) {
   signal?.throwIfAborted();
-  if (process.platform === "win32" && /\.(?:cmd|bat)$/iu.test(spec.command)) return { status: "failed", detail: "Command checks execute native programs directly. Use node.exe with the package manager JavaScript entry point, not .cmd/.bat." };
+  if (process.platform === "win32" && /\.(?:cmd|bat)$/iu.test(spec.command))
+    return {
+      status: "failed",
+      detail: "Command checks execute native programs directly. Use node.exe with the package manager JavaScript entry point, not .cmd/.bat."
+    };
   const cwd = await realpath(workspace);
   const env = {};
-  for (const key of ["PATH", "Path", "PATHEXT", "SystemRoot", "WINDIR", "COMSPEC", "TEMP", "TMP", "TMPDIR", "LANG", "LC_ALL"]) if (process.env[key] !== void 0) env[key] = process.env[key];
+  for (const key of [
+    "PATH",
+    "Path",
+    "PATHEXT",
+    "SystemRoot",
+    "WINDIR",
+    "COMSPEC",
+    "TEMP",
+    "TMP",
+    "TMPDIR",
+    "LANG",
+    "LC_ALL"
+  ])
+    if (environment.isolation.mode === "host" && process.env[key] !== void 0) env[key] = process.env[key];
   env.CI = "1";
-  return new Promise((resolveResult) => {
+  return new Promise((resolveResult, rejectResult) => {
+    const cancellation = new AbortController();
     let output = Buffer.alloc(0);
     let reason;
     let settled = false;
-    const child = spawn(spec.command, [...spec.args], { cwd, env, shell: false, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] });
+    const child = environment.spawn(spec.command, spec.args, {
+      cwd,
+      env,
+      signal: cancellation.signal
+    });
+    const stdout = child.stdout;
+    const stderr = child.stderr;
+    if (!stdout || !stderr) {
+      rejectResult(new Error("Execution environment must provide command output pipes"));
+      return;
+    }
     const finish = /* @__PURE__ */ __name((status, exitCode, detail) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
-      clearTimeout(killWait);
       signal?.removeEventListener("abort", abort);
-      resolveResult({ status, ...exitCode !== void 0 ? { exitCode } : {}, ...detail ? { detail } : {}, output: boundedOutput(output, spec.maxOutputBytes ?? 65536) });
+      resolveResult({
+        status,
+        ...exitCode !== void 0 ? { exitCode } : {},
+        ...detail ? { detail } : {},
+        output: boundedOutput(output, spec.maxOutputBytes ?? 65536)
+      });
     }, "finish");
-    let killWait;
     const stop = /* @__PURE__ */ __name((detail) => {
       if (reason) return;
       reason = detail;
-      child.kill("SIGKILL");
-      killWait = setTimeout(() => {
-        child.stdout.destroy();
-        child.stderr.destroy();
-        finish("unknown", void 0, `${detail}; child effects require inspection`);
-      }, 1e3);
+      cancellation.abort();
     }, "stop");
     const abort = /* @__PURE__ */ __name(() => stop("Check interrupted"), "abort");
     const timer = setTimeout(() => stop("Check timed out"), spec.timeoutMs ?? 3e4);
@@ -509,18 +655,24 @@ async function runCommand(spec, workspace, signal) {
         stop("Check output limit exceeded");
       } else output = Buffer.concat([output, chunk]);
     }, "collect");
-    child.stdout.on("data", collect);
-    child.stderr.on("data", collect);
+    stdout.on("data", collect);
+    stderr.on("data", collect);
     child.on("error", (error) => finish(child.pid === void 0 ? "failed" : "unknown", void 0, message(error)));
     child.on("close", (code, terminationSignal) => {
-      if (reason || terminationSignal || code === null) finish("unknown", void 0, reason ?? `Check ended by ${terminationSignal ?? "unknown termination"}`);
-      else finish(code === 0 ? "passed" : "failed", code, code === 0 ? "Configured command exited successfully" : "Configured command exited unsuccessfully");
+      if (reason || terminationSignal || code === null)
+        finish("unknown", void 0, reason ?? `Check ended by ${terminationSignal ?? "unknown termination"}`);
+      else
+        finish(
+          code === 0 ? "passed" : "failed",
+          code,
+          code === 0 ? "Configured command exited successfully" : "Configured command exited unsuccessfully"
+        );
     });
     signal?.addEventListener("abort", abort, { once: true });
     if (signal?.aborted) abort();
   });
 }
-__name(runCommand, "runCommand");
+__name(runEnvironmentCommand, "runEnvironmentCommand");
 async function readJournal(file) {
   const stat2 = await file.stat();
   if (!stat2.isFile() || stat2.size > maxJournalBytes) throw new Error("Invalid verification journal type or size");
@@ -538,7 +690,8 @@ async function readJournal(file) {
   let specs = [];
   for (const line of bytes.subarray(0, committed).toString("utf8").split("\n").slice(0, -1)) {
     const entry = JSON.parse(line);
-    if (!entry || entry.sequence !== entries.length + 1 || !entry.event) throw new Error("Invalid verification journal sequence");
+    if (!entry || entry.sequence !== entries.length + 1 || !entry.event)
+      throw new Error("Invalid verification journal sequence");
     const event = entry.event;
     if (event.type === "config") {
       if (entries.length !== 0) throw new Error("Duplicate verification config");
@@ -547,24 +700,32 @@ async function readJournal(file) {
     else if (event.type === "report") {
       parseTeamReport(event.report.report);
       validateStored(event.report);
-      if (reportIds.size >= 256 || reportIds.has(event.report.commandId) || !Array.isArray(event.report.evidence)) throw new Error("Invalid stored report history");
+      if (reportIds.size >= 256 || reportIds.has(event.report.commandId) || !Array.isArray(event.report.evidence))
+        throw new Error("Invalid stored report history");
       for (const item of event.report.evidence) {
         safeRelative(item.path);
         integer(item.startLine, 1, 1e6, "stored evidence startLine");
         integer(item.endLine, item.startLine, 1e6, "stored evidence endLine");
-        if (typeof item.valid !== "boolean" || item.valid && !/^[a-f0-9]{64}$/u.test(item.sha256 ?? "")) throw new Error("Invalid stored evidence");
+        if (typeof item.valid !== "boolean" || item.valid && !/^[a-f0-9]{64}$/u.test(item.sha256 ?? ""))
+          throw new Error("Invalid stored evidence");
       }
       reportIds.add(event.report.commandId);
     } else if (event.type === "check") {
       const result = event.result;
       parseTeamCheck(result.spec);
       validateStored(result);
-      if (!isDeepStrictEqual(specs.find((entry2) => entry2.id === result.spec.id), result.spec) || result.taskId !== result.spec.taskId || !["pending", "passed", "failed", "unknown", "cancelled"].includes(result.status) || result.afterFingerprint !== void 0 && !/^[a-f0-9]{64}$/u.test(result.afterFingerprint)) throw new Error("Invalid check record");
+      if (!isDeepStrictEqual(
+        specs.find((entry2) => entry2.id === result.spec.id),
+        result.spec
+      ) || result.taskId !== result.spec.taskId || !["pending", "passed", "failed", "unknown", "cancelled"].includes(result.status) || result.afterFingerprint !== void 0 && !/^[a-f0-9]{64}$/u.test(result.afterFingerprint))
+        throw new Error("Invalid check record");
       const old = checkResults.get(result.commandId);
       if (!old) {
-        if (checkResults.size >= 512 || result.status !== "pending") throw new Error("Check result has no pending intent");
+        if (checkResults.size >= 512 || result.status !== "pending")
+          throw new Error("Check result has no pending intent");
       } else {
-        if (!sameIdentity(old, result) || !isDeepStrictEqual(old.spec, result.spec) || old.workspaceFingerprint !== result.workspaceFingerprint || old.status !== "pending" && old.status !== "unknown" || result.status === "pending" || old.status === "unknown" && (!["failed", "cancelled"].includes(result.status) || !result.reconciliation)) throw new Error("Invalid check history transition");
+        if (!sameIdentity(old, result) || !isDeepStrictEqual(old.spec, result.spec) || old.workspaceFingerprint !== result.workspaceFingerprint || old.status !== "pending" && old.status !== "unknown" || result.status === "pending" || old.status === "unknown" && (!["failed", "cancelled"].includes(result.status) || !result.reconciliation))
+          throw new Error("Invalid check history transition");
       }
       checkResults.set(result.commandId, result);
     } else throw new Error("Unknown verification journal record");
@@ -580,7 +741,12 @@ function validateStored(value) {
 }
 __name(validateStored, "validateStored");
 function taskIdentity(execution) {
-  return { taskId: execution.task.id, coordinationId: execution.coordinationId, dispatchId: execution.task.dispatchId, turn: execution.task.turn ?? 0 };
+  return {
+    taskId: execution.task.id,
+    coordinationId: execution.coordinationId,
+    dispatchId: execution.task.dispatchId,
+    turn: execution.task.turn ?? 0
+  };
 }
 __name(taskIdentity, "taskIdentity");
 function sameIdentity(a, b) {
@@ -588,39 +754,40 @@ function sameIdentity(a, b) {
 }
 __name(sameIdentity, "sameIdentity");
 function fields(value, allowed) {
-  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => !allowed.includes(key))) throw new Error("Invalid verification fields");
+  if (!value || typeof value !== "object" || Array.isArray(value) || Object.keys(value).some((key) => !allowed.includes(key)))
+    throw new Error("Invalid verification fields");
   return value;
 }
 __name(fields, "fields");
 function identifier(value, label) {
-  if (typeof value !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,255}$/u.test(value)) throw new Error(`Invalid ${label}`);
+  if (typeof value !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,255}$/u.test(value))
+    throw new Error(`Invalid ${label}`);
 }
 __name(identifier, "identifier");
 function boundedString(value, label, max) {
-  if (typeof value !== "string" || value.length < 1 || Buffer.byteLength(value) > max || value.includes("\0")) throw new Error(`Invalid ${label}`);
+  if (typeof value !== "string" || value.length < 1 || Buffer.byteLength(value) > max || value.includes("\0"))
+    throw new Error(`Invalid ${label}`);
 }
 __name(boundedString, "boundedString");
 function integer(value, min, max, label) {
-  if (!Number.isSafeInteger(value) || value < min || value > max) throw new Error(`Invalid ${label}`);
+  if (!Number.isSafeInteger(value) || value < min || value > max)
+    throw new Error(`Invalid ${label}`);
 }
 __name(integer, "integer");
 function safeRelative(value) {
   boundedString(value, "workspace relative path", 2048);
-  if (isAbsolute(value) || /[:\u0000-\u001f]/u.test(value) || value.replace(/\\/gu, "/").split("/").some((part) => !part || part === "." || part === "..")) throw new Error("Unsafe workspace relative path");
+  if (isAbsolute(value) || /[:\u0000-\u001f]/u.test(value) || value.replace(/\\/gu, "/").split("/").some((part) => !part || part === "." || part === ".."))
+    throw new Error("Unsafe workspace relative path");
 }
 __name(safeRelative, "safeRelative");
 async function rejectLinkIfPresent(path) {
   try {
     if ((await lstat(path)).isSymbolicLink()) throw new Error("Verification file must not be a symbolic link");
   } catch (error) {
-    if (!isMissing(error)) throw error;
+    if (!hasErrorCode(error, "ENOENT")) throw error;
   }
 }
 __name(rejectLinkIfPresent, "rejectLinkIfPresent");
-function isMissing(error) {
-  return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-__name(isMissing, "isMissing");
 function noFollow() {
   return process.platform === "win32" ? 0 : constants.O_NOFOLLOW;
 }
@@ -649,8 +816,17 @@ __name(boundedOutput, "boundedOutput");
 
 // apps/maybecode/src/team-plan.ts
 var MAX_PLAN_BYTES = 1048576;
-var READ_TOOLS = ["read", "list_files", "publish_artifact", "read_artifact", "submit_report", "run_check"];
-var ALL_TOOLS = [...READ_TOOLS, "write", "edit"];
+var READ_TOOLS = [
+  "read",
+  "glob",
+  "grep",
+  "list_files",
+  "publish_artifact",
+  "read_artifact",
+  "submit_report",
+  "run_check"
+];
+var ALL_TOOLS = [...READ_TOOLS, "fetch", "write", "edit"];
 var LIMIT_CAPS = {
   maxConcurrent: 8,
   maxTasks: 128,
@@ -672,36 +848,48 @@ function parseTeamPlan(value, options = {}) {
   if (plan.format !== 1) fail("plan.format must be 1");
   const name = plan.name === void 0 ? void 0 : text(plan.name, "plan.name", 128);
   const roleValues = object(plan.roles, "plan.roles");
-  if (Object.keys(roleValues).length < 1 || Object.keys(roleValues).length > 16) fail("plan.roles must contain 1-16 roles");
+  if (Object.keys(roleValues).length < 1 || Object.keys(roleValues).length > 16)
+    fail("plan.roles must contain 1-16 roles");
   const roles = {};
   for (const [id, value2] of Object.entries(roleValues)) {
     identifier2(id, "role id");
-    const role = object(value2, `role ${id}`, ["model", "instructions", "tools", "delegateTo", "messaging", "runBudget"]);
+    const role = object(value2, `role ${id}`, [
+      "model",
+      "instructions",
+      "tools",
+      "delegateTo",
+      "messaging",
+      "runBudget"
+    ]);
     const model = role.model === void 0 ? void 0 : text(role.model, `role ${id}.model`, 128);
     const instructions2 = role.instructions === void 0 ? void 0 : text(role.instructions, `role ${id}.instructions`, 16384);
     const tools = role.tools === void 0 ? [...READ_TOOLS] : stringArray(role.tools, `role ${id}.tools`, ALL_TOOLS.length);
     for (const tool of tools) {
       if (!ALL_TOOLS.includes(tool)) fail(`Unknown tool in role ${id}: ${tool}`);
-      if (mode === "read-only" && (tool === "write" || tool === "edit")) fail(`Tool ${tool} in role ${id} requires --mode coding`);
+      if (mode === "read-only" && (tool === "write" || tool === "edit"))
+        fail(`Tool ${tool} in role ${id} requires --mode coding`);
     }
     const delegateTo = role.delegateTo === void 0 ? [] : stringArray(role.delegateTo, `role ${id}.delegateTo`, 16);
     delegateTo.forEach((target) => identifier2(target, `role ${id}.delegateTo`));
-    if (role.messaging !== void 0 && typeof role.messaging !== "boolean") fail(`role ${id}.messaging must be boolean`);
+    if (role.messaging !== void 0 && typeof role.messaging !== "boolean")
+      fail(`role ${id}.messaging must be boolean`);
     const runBudget = role.runBudget === void 0 ? void 0 : budget(role.runBudget, `role ${id}.runBudget`);
-    roles[id] = {
-      ...model === void 0 ? {} : { model },
-      ...instructions2 === void 0 ? {} : { instructions: instructions2 },
+    roles[id] = omitUndefined({
+      model,
+      instructions: instructions2,
       tools,
       delegateTo,
       messaging: role.messaging ?? false,
-      ...runBudget === void 0 ? {} : { runBudget }
-    };
+      runBudget
+    });
   }
   for (const [id, role] of Object.entries(roles)) {
-    for (const target of role.delegateTo) if (!Object.hasOwn(roles, target)) fail(`Unknown delegated role ${target} in role ${id}`);
+    for (const target of role.delegateTo)
+      if (!Object.hasOwn(roles, target)) fail(`Unknown delegated role ${target} in role ${id}`);
   }
   const limits = plan.limits === void 0 ? void 0 : parseLimits(plan.limits);
-  if (!Array.isArray(plan.tasks) || plan.tasks.length < 1 || plan.tasks.length > (limits?.maxTasks ?? 128)) fail("plan.tasks exceeds its task quota or is empty");
+  if (!Array.isArray(plan.tasks) || plan.tasks.length < 1 || plan.tasks.length > (limits?.maxTasks ?? 128))
+    fail("plan.tasks exceeds its task quota or is empty");
   const tasks = plan.tasks.map((value2, index) => {
     const task = object(value2, `task ${index}`, ["id", "agent", "input", "dependsOn"]);
     const id = identifier2(task.id, "task id");
@@ -721,16 +909,10 @@ function parseTeamPlan(value, options = {}) {
   } catch (error) {
     fail(`plan.checks: ${error instanceof Error ? error.message : "Invalid checks"}`);
   }
-  for (const check of checks) if (!tasks.some((task) => task.id === check.taskId)) fail(`Check ${check.id} references unknown task ${check.taskId}`);
-  const result = {
-    format: 1,
-    ...name === void 0 ? {} : { name },
-    roles,
-    tasks,
-    resultTaskId,
-    ...limits === void 0 ? {} : { limits },
-    checks
-  };
+  for (const check of checks)
+    if (!tasks.some((task) => task.id === check.taskId))
+      fail(`Check ${check.id} references unknown task ${check.taskId}`);
+  const result = omitUndefined({ format: 1, name, roles, tasks, resultTaskId, limits, checks });
   if (Buffer.byteLength(JSON.stringify(result), "utf8") > MAX_PLAN_BYTES) fail("Team plan exceeds 1 MiB");
   return freeze(result);
 }
@@ -750,7 +932,9 @@ async function loadTeamPlan(path, options = {}) {
     if (length > MAX_PLAN_BYTES) fail("Team plan exceeds 1 MiB");
     let value;
     try {
-      value = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, length)).replace(/^\uFEFF/u, ""));
+      value = JSON.parse(
+        new TextDecoder("utf-8", { fatal: true }).decode(buffer.subarray(0, length)).replace(/^\uFEFF/u, "")
+      );
     } catch {
       fail("Team plan must contain valid UTF-8 JSON");
     }
@@ -765,55 +949,75 @@ function createTeamPreset(preset, prompt, options = {}) {
   text(prompt, "team prompt", 32768);
   const coding = options.mode === "coding";
   const worker = {
-    ...options.model === void 0 ? {} : { model: options.model },
+    ...omitUndefined({ model: options.model }),
     tools: coding ? [...READ_TOOLS, "write", "edit"] : READ_TOOLS,
     instructions: coding ? "Implement a bounded change in your own workspace copy. Run only configured checks. Submit evidence and a report; never claim source changes have been applied." : "Investigate independently using workspace evidence. Do not change files or claim unperformed tests. Submit findings, evidence, and limitations."
   };
   const final = {
-    ...options.model === void 0 ? {} : { model: options.model },
+    ...omitUndefined({ model: options.model }),
     tools: READ_TOOLS,
     delegateTo: preset === "supervisor" ? ["worker"] : [],
     instructions: "Synthesize the dependency reports, identify each task's contribution, and distinguish verified evidence from unverified claims. Dependency workspaces are not automatically merged. Do not wait for unsolicited messages."
   };
   const restriction = coding ? "Work only in your isolated copy; source application requires later human confirmation." : "Do not change files.";
   const tasks = preset === "pipeline" ? [
-    { id: "analysis", agent: "worker", input: `Inspect the request and produce evidence and a concrete ${coding ? "implementation" : "investigation"}. ${restriction}
+    {
+      id: "analysis",
+      agent: "worker",
+      input: `Inspect the request and produce evidence and a concrete ${coding ? "implementation" : "investigation"}. ${restriction}
 
 User task:
-${prompt}` },
-    { id: "review", agent: "worker", dependsOn: ["analysis"], input: `Review the analysis report for correctness, edge cases, and verification gaps. Your workspace is an independent baseline; no prior edits are present. ${restriction}
+${prompt}`
+    },
+    {
+      id: "review",
+      agent: "worker",
+      dependsOn: ["analysis"],
+      input: `Review the analysis report for correctness, edge cases, and verification gaps. Your workspace is an independent baseline; no prior edits are present. ${restriction}
 
 User task:
-${prompt}` },
+${prompt}`
+    },
     { id: "summary", agent: "supervisor", dependsOn: ["analysis", "review"], input: prompt }
   ] : [
-    { id: "analysis", agent: "worker", input: `Investigate the user's task independently. Inspect relevant files and identify a concrete approach with evidence. ${restriction}
+    {
+      id: "analysis",
+      agent: "worker",
+      input: `Investigate the user's task independently. Inspect relevant files and identify a concrete approach with evidence. ${restriction}
 
 User task:
-${prompt}` },
-    { id: "review", agent: "worker", input: `Independently review risks, edge cases, and validation needs. Inspect files and provide evidence. ${restriction}
+${prompt}`
+    },
+    {
+      id: "review",
+      agent: "worker",
+      input: `Independently review risks, edge cases, and validation needs. Inspect files and provide evidence. ${restriction}
 
 User task:
-${prompt}` },
+${prompt}`
+    },
     { id: "summary", agent: "supervisor", dependsOn: ["analysis", "review"], input: prompt }
   ];
-  return parseTeamPlan({
-    format: 1,
-    name: preset,
-    roles: { worker, supervisor: final },
-    tasks,
-    resultTaskId: "summary",
-    limits: {
-      maxConcurrent: 2,
-      maxTasks: 8,
-      maxDepth: 2,
-      maxTaskTurns: 4,
-      maxDurationMs: 6e5,
-      maxOutputBytes: 65536,
-      maxMessages: 24,
-      maxMessageBytes: 8192
-    }
-  }, { mode: options.mode ?? "read-only" });
+  return parseTeamPlan(
+    {
+      format: 1,
+      name: preset,
+      roles: { worker, supervisor: final },
+      tasks,
+      resultTaskId: "summary",
+      limits: {
+        maxConcurrent: 2,
+        maxTasks: 8,
+        maxDepth: 2,
+        maxTaskTurns: 4,
+        maxDurationMs: 6e5,
+        maxOutputBytes: 65536,
+        maxMessages: 24,
+        maxMessageBytes: 8192
+      }
+    },
+    { mode: options.mode ?? "read-only" }
+  );
 }
 __name(createTeamPreset, "createTeamPreset");
 function parseLimits(value) {
@@ -825,7 +1029,8 @@ function parseLimits(value) {
       continue;
     }
     const cap = LIMIT_CAPS[key];
-    if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < 1 || value2 > cap) fail(`plan.limits.${key} must be an integer from 1 to ${cap}`);
+    if (typeof value2 !== "number" || !Number.isSafeInteger(value2) || value2 < 1 || value2 > cap)
+      fail(`plan.limits.${key} must be an integer from 1 to ${cap}`);
     result[key] = value2;
   }
   return result;
@@ -843,7 +1048,8 @@ __name(budget, "budget");
 function validateGraph(tasks) {
   const pending = new Map(tasks.map((task) => [task.id, task]));
   if (pending.size !== tasks.length) fail("Duplicate task id");
-  for (const task of tasks) for (const id of task.dependsOn ?? []) if (!pending.has(id)) fail(`Unknown dependency ${id} in task ${task.id}`);
+  for (const task of tasks)
+    for (const id of task.dependsOn ?? []) if (!pending.has(id)) fail(`Unknown dependency ${id} in task ${task.id}`);
   while (pending.size) {
     let progress = false;
     for (const [id, task] of pending) {
@@ -856,7 +1062,8 @@ function validateGraph(tasks) {
 }
 __name(validateGraph, "validateGraph");
 function object(value, label, keys) {
-  if (!value || typeof value !== "object" || Array.isArray(value) || ![null, Object.prototype].includes(Object.getPrototypeOf(value))) fail(`${label} must be an object`);
+  if (!value || typeof value !== "object" || Array.isArray(value) || ![null, Object.prototype].includes(Object.getPrototypeOf(value)))
+    fail(`${label} must be an object`);
   const record = value;
   if (keys) {
     for (const key of Object.keys(record)) if (!keys.includes(key)) fail(`Unknown ${label} field: ${key}`);
@@ -865,17 +1072,20 @@ function object(value, label, keys) {
 }
 __name(object, "object");
 function identifier2(value, label) {
-  if (typeof value !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/u.test(value) || ["__proto__", "constructor", "prototype"].includes(value)) fail(`${label} must be a non-reserved 1-128 character ASCII identifier`);
+  if (typeof value !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9_.-]{0,127}$/u.test(value) || ["__proto__", "constructor", "prototype"].includes(value))
+    fail(`${label} must be a non-reserved 1-128 character ASCII identifier`);
   return value;
 }
 __name(identifier2, "identifier");
 function text(value, label, maxBytes) {
-  if (typeof value !== "string" || !value.trim() || value.includes("\0") || Buffer.byteLength(value, "utf8") > maxBytes) fail(`${label} must be nonempty text of at most ${maxBytes} bytes without NUL`);
+  if (typeof value !== "string" || !value.trim() || value.includes("\0") || Buffer.byteLength(value, "utf8") > maxBytes)
+    fail(`${label} must be nonempty text of at most ${maxBytes} bytes without NUL`);
   return value;
 }
 __name(text, "text");
 function stringArray(value, label, max) {
-  if (!Array.isArray(value) || value.length > max || value.some((item) => typeof item !== "string") || new Set(value).size !== value.length) fail(`${label} must be an array of at most ${max} unique strings`);
+  if (!Array.isArray(value) || value.length > max || value.some((item) => typeof item !== "string") || new Set(value).size !== value.length)
+    fail(`${label} must be an array of at most ${max} unique strings`);
   return [...value];
 }
 __name(stringArray, "stringArray");
@@ -896,12 +1106,13 @@ __name(fail, "fail");
 import { createHash as createHash2 } from "node:crypto";
 import { open as open3 } from "node:fs/promises";
 import { join as join2 } from "node:path";
-import { FileSessionStore } from "@sortedyuan/session/file-store";
+import { FileSessionStore } from "@sortedyuan/may/session/file-store";
 async function readTeamResolution(path) {
   const file = await open3(path, "r");
   let value;
   try {
-    if (!(await file.stat()).isFile() || (await file.stat()).size > 32768) throw new Error("Resolution file exceeds 32768 bytes");
+    if (!(await file.stat()).isFile() || (await file.stat()).size > 32768)
+      throw new Error("Resolution file exceeds 32768 bytes");
     const bytes = await file.readFile();
     if (bytes.length > 32768) throw new Error("Resolution file exceeds 32768 bytes");
     value = JSON.parse(bytes.toString("utf8"));
@@ -910,22 +1121,28 @@ async function readTeamResolution(path) {
   }
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("Resolution must be an object");
   const input = value;
-  if (input.format !== 1 || !["task", "budget", "check"].includes(input.kind) || typeof input.finding !== "string" || !input.finding.trim() || input.finding.length > (input.kind === "budget" ? 256 : 8192) || /[\u0000-\u001f]/u.test(input.finding)) throw new Error("Resolution requires format 1, a supported kind, and bounded verified finding");
+  if (input.format !== 1 || !["task", "budget", "check"].includes(input.kind) || typeof input.finding !== "string" || !input.finding.trim() || input.finding.length > (input.kind === "budget" ? 256 : 8192) || /[\u0000-\u001f]/u.test(input.finding))
+    throw new Error("Resolution requires format 1, a supported kind, and bounded verified finding");
   const keys = input.kind === "budget" ? ["callId", "usage"] : [input.kind === "task" ? "taskId" : "commandId", "outcome"];
-  if (Object.keys(input).some((key) => !["format", "kind", "finding", ...keys].includes(key))) throw new Error("Unknown resolution field");
+  if (Object.keys(input).some((key) => !["format", "kind", "finding", ...keys].includes(key)))
+    throw new Error("Unknown resolution field");
   const id = input[keys[0]];
-  if (typeof id !== "string" || !id.length || id.length > 256 || /[\u0000-\u001f]/u.test(id)) throw new Error("Invalid resolution identity");
+  if (typeof id !== "string" || !id.length || id.length > 256 || /[\u0000-\u001f]/u.test(id))
+    throw new Error("Invalid resolution identity");
   if (input.kind === "budget") {
     const usage = input.usage;
-    if (!usage || typeof usage !== "object" || Array.isArray(usage) || Object.keys(usage).some((key) => !["inputTokens", "outputTokens", "totalTokens"].includes(key)) || !Object.keys(usage).length || Object.values(usage).some((n) => !Number.isSafeInteger(n) || n < 0) || usage.totalTokens === void 0 && (usage.inputTokens === void 0 || usage.outputTokens === void 0)) throw new Error("Supply verified non-negative token usage; do not estimate unknown usage as zero");
-  } else if (!["failed", "cancelled"].includes(input.outcome)) throw new Error("Reconciliation cannot manufacture a successful answer/check");
+    if (!usage || typeof usage !== "object" || Array.isArray(usage) || Object.keys(usage).some((key) => !["inputTokens", "outputTokens", "totalTokens"].includes(key)) || !Object.keys(usage).length || Object.values(usage).some((n) => !Number.isSafeInteger(n) || n < 0) || usage.totalTokens === void 0 && (usage.inputTokens === void 0 || usage.outputTokens === void 0))
+      throw new Error("Supply verified non-negative token usage; do not estimate unknown usage as zero");
+  } else if (!["failed", "cancelled"].includes(input.outcome))
+    throw new Error("Reconciliation cannot manufacture a successful answer/check");
   return input;
 }
 __name(readTeamResolution, "readTeamResolution");
 function teamReviewDigest(value) {
   const canonical = /* @__PURE__ */ __name((value2) => {
     if (Array.isArray(value2)) return `[${value2.map(canonical).join(",")}]`;
-    if (value2 && typeof value2 === "object") return `{${Object.entries(value2).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(",")}}`;
+    if (value2 && typeof value2 === "object")
+      return `{${Object.entries(value2).filter(([, v]) => v !== void 0).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([k, v]) => `${JSON.stringify(k)}:${canonical(v)}`).join(",")}}`;
     return JSON.stringify(value2);
   }, "canonical");
   return createHash2("sha256").update(canonical(value)).digest("hex");
@@ -938,10 +1155,11 @@ function retryImpact(state, taskId, finding) {
   const affected = /* @__PURE__ */ new Set([taskId]);
   for (let changed = true; changed; ) {
     changed = false;
-    for (const candidate of state.tasks) if (!affected.has(candidate.id) && candidate.dependsOn.some((id) => affected.has(id))) {
-      affected.add(candidate.id);
-      changed = true;
-    }
+    for (const candidate of state.tasks)
+      if (!affected.has(candidate.id) && candidate.dependsOn.some((id) => affected.has(id))) {
+        affected.add(candidate.id);
+        changed = true;
+      }
   }
   return {
     taskId,
@@ -967,23 +1185,31 @@ async function inspectTeam(directory, id, limits) {
     for (const task of state.tasks) {
       lines2.push(`${task.id}: ${task.status}; attempt ${task.attempt ?? 0}; session ${task.sessionId}`);
       if (task.detail) lines2.push(`  Reason: ${task.detail}`);
-      const blocked = task.dependsOn.filter((id2) => state.tasks.find((candidate) => candidate.id === id2)?.status !== "completed");
+      const blocked = task.dependsOn.filter(
+        (id2) => state.tasks.find((candidate) => candidate.id === id2)?.status !== "completed"
+      );
       if (blocked.length) lines2.push(`  Unsuccessful dependencies: ${blocked.join(", ")}`);
       if (["failed", "cancelled", "recovery-required", "cancelling"].includes(task.status)) {
         const events = await sessions.read(task.sessionId);
         const pending = /* @__PURE__ */ new Map();
         for (const event of events) {
-          if (event.type === "tool.started") pending.set(`${event.runId}:${event.step}:${event.call.id}`, event.call.name);
-          if (event.type === "tool.completed" || event.type === "tool.failed" && !/CANCEL|ABORT|UNKNOWN/iu.test(`${event.error.name} ${event.error.code ?? ""}`)) pending.delete(`${event.runId}:${event.step}:${event.call.id}`);
+          if (event.type === "tool.started")
+            pending.set(`${event.runId}:${event.step}:${event.call.id}`, event.call.name);
+          if (event.type === "tool.completed" || event.type === "tool.failed" && !/CANCEL|ABORT|UNKNOWN/iu.test(`${event.error.name} ${event.error.code ?? ""}`))
+            pending.delete(`${event.runId}:${event.step}:${event.call.id}`);
         }
-        for (const [key, name] of pending) lines2.push(`  Unsettled tool evidence: ${key} (${name}); inspect Session before reconciling task`);
+        for (const [key, name] of pending)
+          lines2.push(`  Unsettled tool evidence: ${key} (${name}); inspect Session before reconciling task`);
       }
     }
   }
   if (budget2) lines2.push(...budgetStatus(budget2));
   if (verification) {
     lines2.push(`Structured reports: ${verification.reports.length}; checks: ${verification.checks.length}`);
-    for (const check of verification.checks) lines2.push(`  Check ${check.spec.id} (${check.taskId}): ${check.status}; command ${check.commandId}${check.detail ? `; ${check.detail}` : ""}`);
+    for (const check of verification.checks)
+      lines2.push(
+        `  Check ${check.spec.id} (${check.taskId}): ${check.status}; command ${check.commandId}${check.detail ? `; ${check.detail}` : ""}`
+      );
   }
   lines2.push(
     "Recovery does not steal locks, erase unknown effects, reset budgets, or execute agents.",
@@ -994,7 +1220,12 @@ async function inspectTeam(directory, id, limits) {
 }
 __name(inspectTeam, "inspectTeam");
 function budgetStatus(budget2) {
-  return [`Shared budget: ${JSON.stringify(sharedBudgetTotals(budget2))}`, ...budget2.calls.filter((call) => call.status !== "settled" || call.exceededReservation).map((call) => `  Budget call ${call.id}: ${call.status}${call.exceededReservation ? ", exceeded reservation" : ""}; reserved ${call.reservation.totalTokens} tokens`)];
+  return [
+    `Shared budget: ${JSON.stringify(sharedBudgetTotals(budget2))}`,
+    ...budget2.calls.filter((call) => call.status !== "settled" || call.exceededReservation).map(
+      (call) => `  Budget call ${call.id}: ${call.status}${call.exceededReservation ? ", exceeded reservation" : ""}; reserved ${call.reservation.totalTokens} tokens`
+    )
+  ];
 }
 __name(budgetStatus, "budgetStatus");
 async function optional(read) {
@@ -1008,7 +1239,7 @@ async function optional(read) {
 __name(optional, "optional");
 
 // apps/maybecode/src/team-patches.ts
-import { acquireFileLock as acquireFileLock2, releaseFileLock as releaseFileLock2 } from "@sortedyuan/session/file-store";
+import { acquireFileLock as acquireFileLock2, hasErrorCode as hasErrorCode2 } from "@sortedyuan/may/storage";
 import { createHash as createHash3, randomUUID } from "node:crypto";
 import { constants as constants2 } from "node:fs";
 import { lstat as lstat2, mkdir as mkdir2, open as open4, realpath as realpath2, rename, unlink } from "node:fs/promises";
@@ -1020,15 +1251,17 @@ var MAX_FILE_BYTES = 262144;
 var MAX_TOTAL_BYTES = 2097152;
 async function createTeamPatch(options) {
   const bundle = bundleFrom(await options.workspaces.snapshotPatch(options.taskIds));
-  if (inside(bundle.sourceDirectory, resolve2(options.directory))) throw new Error("Patch storage must be outside the source workspace");
+  if (inside(bundle.sourceDirectory, resolve2(options.directory)))
+    throw new Error("Patch storage must be outside the source workspace");
   const patches = await privateDirectory(join3(resolve2(options.directory), "patches"));
   const path = join3(patches, `${bundle.id}.json`);
   try {
     await durableFile(path, `${JSON.stringify(bundle, null, 2)}
 `, "wx");
   } catch (error) {
-    if (!hasCode(error, "EEXIST")) throw error;
-    if (!isDeepStrictEqual2(await readTeamPatch(options.directory, bundle.id), bundle)) throw new Error("Patch id already exists with different content");
+    if (!hasErrorCode2(error, "EEXIST")) throw error;
+    if (!isDeepStrictEqual2(await readTeamPatch(options.directory, bundle.id), bundle))
+      throw new Error("Patch id already exists with different content");
   }
   return bundle;
 }
@@ -1045,11 +1278,16 @@ async function readTeamPatch(directory, patchId) {
 __name(readTeamPatch, "readTeamPatch");
 function renderTeamPatchDiff(bundle) {
   validateBundle(bundle, bundle.id);
-  const sections = [`Patch ${bundle.id}`, `Confirm digest: ${bundle.digest}`, `Tasks: ${bundle.taskSnapshots.map((task) => task.taskId).join(", ")}`];
+  const sections = [
+    `Patch ${bundle.id}`,
+    `Confirm digest: ${bundle.digest}`,
+    `Tasks: ${bundle.taskSnapshots.map((task) => task.taskId).join(", ")}`
+  ];
   for (const file of bundle.files) sections.push(fileDiff(file));
   for (const conflict of bundle.conflicts) {
     sections.push(`CONFLICT ${conflict.path}: different task results; apply is blocked.`);
-    for (const file of conflict.candidates) sections.push(`Candidate tasks: ${file.taskIds.join(", ")}
+    for (const file of conflict.candidates)
+      sections.push(`Candidate tasks: ${file.taskIds.join(", ")}
 ${fileDiff(file)}`);
   }
   if (bundle.files.length === 0 && bundle.conflicts.length === 0) sections.push("No source changes.");
@@ -1059,8 +1297,10 @@ ${fileDiff(file)}`);
 __name(renderTeamPatchDiff, "renderTeamPatchDiff");
 async function applyTeamPatch(options) {
   const bundle = await readTeamPatch(options.directory, options.patchId);
-  if (options.confirmDigest !== bundle.digest) throw new Error("Apply requires the exact digest from the reviewed patch");
-  if (bundle.conflicts.length > 0) throw new Error("Patch has conflicting task results; choose a non-conflicting task set");
+  if (options.confirmDigest !== bundle.digest)
+    throw new Error("Apply requires the exact digest from the reviewed patch");
+  if (bundle.conflicts.length > 0)
+    throw new Error("Patch has conflicting task results; choose a non-conflicting task set");
   const existing = await readTeamPatchApplication(options.directory, bundle.id);
   if (existing) return { ...existing, ...existing.status === "applied" ? { alreadyApplied: true } : {} };
   const source = await safeRoot(bundle.sourceDirectory);
@@ -1068,16 +1308,17 @@ async function applyTeamPatch(options) {
   const taskIds = bundle.taskSnapshots.map((task) => task.taskId);
   const checkTasks = /* @__PURE__ */ __name(async () => {
     const current = bundleFrom(await options.workspaces.snapshotPatch(taskIds));
-    if (current.digest !== bundle.digest) throw new Error("Task or baseline snapshot changed since review; create a new patch");
+    if (current.digest !== bundle.digest)
+      throw new Error("Task or baseline snapshot changed since review; create a new patch");
   }, "checkTasks");
   await checkTasks();
   await preflight(source, bundle.files);
   const lockDirectory = join3(homedir(), ".may", "maybecode", "apply-locks");
-  if (inside(source, resolve2(lockDirectory))) throw new Error("Apply lock directory must be outside the source workspace");
+  if (inside(source, resolve2(lockDirectory)))
+    throw new Error("Apply lock directory must be outside the source workspace");
   const locks = await privateDirectory(lockDirectory);
   if (inside(source, locks)) throw new Error("Apply lock directory must be outside the source workspace");
-  const lockPath = join3(locks, `${hash2(source)}.lock`);
-  const lock = await acquireFileLock2(lockPath);
+  const lock = await acquireFileLock2(join3(locks, `${hash2(source)}.lock`));
   let journal;
   let sequence = 0;
   const appliedPaths = [];
@@ -1091,9 +1332,6 @@ async function applyTeamPatch(options) {
     sequence++;
   }, "append");
   try {
-    await lock.writeFile(`${JSON.stringify({ pid: process.pid, patchId: bundle.id, source })}
-`);
-    await lock.sync();
     const prior = await readTeamPatchApplication(options.directory, bundle.id);
     if (prior) return { ...prior, ...prior.status === "applied" ? { alreadyApplied: true } : {} };
     await checkTasks();
@@ -1157,18 +1395,30 @@ async function applyTeamPatch(options) {
       }
       await syncDirectory(dirname(target));
       const after = await safeRead(source, target, MAX_FILE_BYTES);
-      if (file.afterSha256 === void 0 ? after !== void 0 : after === void 0 || hash2(after) !== file.afterSha256) throw new Error("Source changed before the patch result was acknowledged");
+      if (file.afterSha256 === void 0 ? after !== void 0 : after === void 0 || hash2(after) !== file.afterSha256)
+        throw new Error("Source changed before the patch result was acknowledged");
       await append({ type: "applied", path: file.path });
       appliedPaths.push(file.path);
       options.onProgress?.({ type: "file.applied", path: file.path });
     }
     await append({ type: "completed" });
-    return { status: "applied", patchId: bundle.id, digest: bundle.digest, appliedPaths, uncertainPaths: [], journalPath };
+    return {
+      status: "applied",
+      patchId: bundle.id,
+      digest: bundle.digest,
+      appliedPaths,
+      uncertainPaths: [],
+      journalPath
+    };
   } catch (error) {
     if (!begun) throw error;
     try {
       await append({ type: "unknown" });
-    } catch {
+    } catch (appendError) {
+      throw new AggregateError(
+        [error, appendError],
+        "Patch application failed and its unknown outcome could not be recorded"
+      );
     }
     return {
       status: "unknown",
@@ -1183,7 +1433,7 @@ async function applyTeamPatch(options) {
     try {
       await journal?.close();
     } finally {
-      await releaseFileLock2(lock, lockPath);
+      await lock.release();
     }
   }
 }
@@ -1203,9 +1453,11 @@ async function readTeamPatchApplication(directory, patchId) {
   for (const line of bytes.toString("utf8").split("\n").slice(0, -1)) {
     try {
       const entry = JSON.parse(line);
-      if (entry.revision !== ++revision || entry.digest !== bundle.digest || !["started", "intent", "applied", "completed", "unknown"].includes(entry.type) || (revision === 1 ? entry.type !== "started" : entry.type === "started") || ["completed", "unknown"].includes(last ?? "")) throw new Error("Invalid application sequence");
+      if (entry.revision !== ++revision || entry.digest !== bundle.digest || !["started", "intent", "applied", "completed", "unknown"].includes(entry.type) || (revision === 1 ? entry.type !== "started" : entry.type === "started") || ["completed", "unknown"].includes(last ?? ""))
+        throw new Error("Invalid application sequence");
       if (entry.type === "intent") {
-        if (!bundle.files.some((file) => file.path === entry.path) || pending.has(entry.path) || appliedPaths.includes(entry.path)) throw new Error("Invalid application intent");
+        if (!bundle.files.some((file) => file.path === entry.path) || pending.has(entry.path) || appliedPaths.includes(entry.path))
+          throw new Error("Invalid application intent");
         pending.add(entry.path);
       }
       if (entry.type === "applied") {
@@ -1213,7 +1465,8 @@ async function readTeamPatchApplication(directory, patchId) {
         appliedPaths.push(entry.path);
       }
       if (entry.type === "completed") {
-        if (pending.size || appliedPaths.length !== bundle.files.length) throw new Error("Application completed before all files");
+        if (pending.size || appliedPaths.length !== bundle.files.length)
+          throw new Error("Application completed before all files");
         completed = true;
       }
       last = entry.type;
@@ -1239,7 +1492,9 @@ function bundleFrom(snapshot) {
   for (const { taskId, ...change } of snapshot.changes) {
     assertRelativePath(change.path);
     const group = groups.get(change.path) ?? [];
-    const identical = group.find((file) => isDeepStrictEqual2({ ...file, taskIds: void 0 }, { ...change, taskIds: void 0 }));
+    const identical = group.find(
+      (file) => isDeepStrictEqual2({ ...file, taskIds: void 0 }, { ...change, taskIds: void 0 })
+    );
     if (identical) group[group.indexOf(identical)] = { ...identical, taskIds: [...identical.taskIds, taskId].sort() };
     else group.push({ ...change, taskIds: [taskId] });
     groups.set(change.path, group);
@@ -1271,12 +1526,14 @@ function bundleFrom(snapshot) {
 __name(bundleFrom, "bundleFrom");
 function validateBundle(bundle, expectedId) {
   assertPatchId(expectedId);
-  if (!bundle || bundle.format !== 1 || bundle.id !== expectedId || bundle.id !== `patch-${bundle.digest}` || !isAbsolute2(bundle.sourceDirectory) || !/^[a-f0-9]{64}$/u.test(bundle.baselineDigest) || !Array.isArray(bundle.taskSnapshots) || !bundle.taskSnapshots.length || !Array.isArray(bundle.files) || !Array.isArray(bundle.conflicts)) throw new Error("Invalid patch bundle");
+  if (!bundle || bundle.format !== 1 || bundle.id !== expectedId || bundle.id !== `patch-${bundle.digest}` || !isAbsolute2(bundle.sourceDirectory) || !/^[a-f0-9]{64}$/u.test(bundle.baselineDigest) || !Array.isArray(bundle.taskSnapshots) || !bundle.taskSnapshots.length || !Array.isArray(bundle.files) || !Array.isArray(bundle.conflicts))
+    throw new Error("Invalid patch bundle");
   const { id: _id, digest, ...body } = bundle;
   if (hash2(JSON.stringify(body)) !== digest) throw new Error("Patch digest does not match its content");
   const ids = /* @__PURE__ */ new Set();
   for (const task of bundle.taskSnapshots) {
-    if (typeof task.taskId !== "string" || !task.taskId || ids.has(task.taskId) || !/^[a-f0-9]{64}$/u.test(task.digest)) throw new Error("Invalid patch task identity");
+    if (typeof task.taskId !== "string" || !task.taskId || ids.has(task.taskId) || !/^[a-f0-9]{64}$/u.test(task.digest))
+      throw new Error("Invalid patch task identity");
     ids.add(task.taskId);
   }
   let total = 0;
@@ -1284,12 +1541,14 @@ function validateBundle(bundle, expectedId) {
   if (records.length > 128) throw new Error("Patch has too many file records");
   for (const file of records) {
     assertRelativePath(file.path);
-    if (!["added", "modified", "deleted"].includes(file.kind) || !Array.isArray(file.taskIds) || !file.taskIds.length || file.taskIds.some((id) => typeof id !== "string" || !ids.has(id))) throw new Error("Invalid patch file ownership");
+    if (!["added", "modified", "deleted"].includes(file.kind) || !Array.isArray(file.taskIds) || !file.taskIds.length || file.taskIds.some((id) => typeof id !== "string" || !ids.has(id)))
+      throw new Error("Invalid patch file ownership");
     for (const prefix of ["before", "after"]) {
       const text2 = file[`${prefix}Text`];
       const sha = file[`${prefix}Sha256`];
       const expected = prefix === "before" ? file.kind !== "added" : file.kind !== "deleted";
-      if (expected ? typeof text2 !== "string" || sha !== hash2(text2) || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u.test(text2) : text2 !== void 0 || sha !== void 0) throw new Error("Invalid patch file content/hash or unsafe display controls");
+      if (expected ? typeof text2 !== "string" || sha !== hash2(text2) || /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u.test(text2) : text2 !== void 0 || sha !== void 0)
+        throw new Error("Invalid patch file content/hash or unsafe display controls");
       if (text2 !== void 0) {
         const bytes = Buffer.byteLength(text2);
         if (bytes > MAX_FILE_BYTES) throw new Error("Patch file exceeds its byte limit");
@@ -1309,7 +1568,10 @@ function fileDiff(file) {
     `+++ ${file.afterText === void 0 ? "/dev/null" : `b/${file.path}`}`,
     `@@ -${old.length ? 1 : 0},${old.length} +${next.length ? 1 : 0},${next.length} @@`
   ];
-  for (const [prefix, entries, text2] of [["-", old, file.beforeText], ["+", next, file.afterText]]) {
+  for (const [prefix, entries, text2] of [
+    ["-", old, file.beforeText],
+    ["+", next, file.afterText]
+  ]) {
     for (const line of entries) rendered.push(`${prefix}${line}`);
     if (entries.length && !text2.endsWith("\n")) rendered.push("\");
   }
@@ -1326,7 +1588,9 @@ __name(lines, "lines");
 async function preflight(source, files) {
   const originals = /* @__PURE__ */ new Map();
   const paths = files.map((file) => file.path);
-  for (const path of paths) if (paths.some((other) => other !== path && other.startsWith(`${path}/`))) throw new Error("Patch contains overlapping file and directory paths");
+  for (const path of paths)
+    if (paths.some((other) => other !== path && other.startsWith(`${path}/`)))
+      throw new Error("Patch contains overlapping file and directory paths");
   for (const file of files) {
     const target = checkedPath(source, file.path);
     const current = await safeRead(source, target, MAX_FILE_BYTES);
@@ -1338,7 +1602,8 @@ async function preflight(source, files) {
 }
 __name(preflight, "preflight");
 function assertBefore(file, current) {
-  if (file.beforeSha256 === void 0 ? current !== void 0 : current === void 0 || hash2(current) !== file.beforeSha256) throw new Error(`Source changed since the baseline: ${file.path}`);
+  if (file.beforeSha256 === void 0 ? current !== void 0 : current === void 0 || hash2(current) !== file.beforeSha256)
+    throw new Error(`Source changed since the baseline: ${file.path}`);
 }
 __name(assertBefore, "assertBefore");
 async function safeRead(root, path, maxBytes) {
@@ -1347,14 +1612,16 @@ async function safeRead(root, path, maxBytes) {
   try {
     before = await lstat2(path);
   } catch (error) {
-    if (hasCode(error, "ENOENT")) return void 0;
+    if (hasErrorCode2(error, "ENOENT")) return void 0;
     throw error;
   }
-  if (!before.isFile() || before.isSymbolicLink() || before.nlink > 1 || before.size > maxBytes) throw new Error("Patch file is unsafe or exceeds its byte limit");
+  if (!before.isFile() || before.isSymbolicLink() || before.nlink > 1 || before.size > maxBytes)
+    throw new Error("Patch file is unsafe or exceeds its byte limit");
   const file = await open4(path, constants2.O_RDONLY | (process.platform === "win32" ? 0 : constants2.O_NOFOLLOW));
   try {
     const stat2 = await file.stat();
-    if (!stat2.isFile() || stat2.ino !== before.ino || stat2.dev !== before.dev || stat2.size !== before.size || stat2.nlink > 1) throw new Error("Patch file changed while opening");
+    if (!stat2.isFile() || stat2.ino !== before.ino || stat2.dev !== before.dev || stat2.size !== before.size || stat2.nlink > 1)
+      throw new Error("Patch file changed while opening");
     const bytes = Buffer.alloc(before.size + 1);
     let position = 0;
     while (position < bytes.length) {
@@ -1363,7 +1630,8 @@ async function safeRead(root, path, maxBytes) {
       position += result.bytesRead;
     }
     const after = await file.stat();
-    if (position !== before.size || after.size !== before.size || after.mtimeMs !== stat2.mtimeMs) throw new Error("Patch file changed while reading");
+    if (position !== before.size || after.size !== before.size || after.mtimeMs !== stat2.mtimeMs)
+      throw new Error("Patch file changed while reading");
     await assertParents(root, path);
     return bytes.subarray(0, position);
   } finally {
@@ -1381,7 +1649,7 @@ async function assertParents(root, path) {
       const info = await lstat2(cursor);
       if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Patch parent is not a safe directory");
     } catch (error) {
-      if (hasCode(error, "ENOENT")) return;
+      if (hasErrorCode2(error, "ENOENT")) return;
       throw error;
     }
   }
@@ -1397,7 +1665,7 @@ async function missingDirectories(root, path) {
       const info = await lstat2(cursor);
       if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("Patch parent is unsafe");
     } catch (error) {
-      if (!hasCode(error, "ENOENT")) throw error;
+      if (!hasErrorCode2(error, "ENOENT")) throw error;
       missing.push(cursor);
     }
   }
@@ -1426,7 +1694,7 @@ async function privateDirectory(path) {
       await safeRoot(parent);
       break;
     } catch (error) {
-      if (!hasCode(error, "ENOENT")) throw error;
+      if (!hasErrorCode2(error, "ENOENT")) throw error;
       missing.unshift(parent);
       parent = dirname(parent);
     }
@@ -1435,7 +1703,7 @@ async function privateDirectory(path) {
     try {
       await mkdir2(directory, { mode: 448 });
     } catch (error) {
-      if (!hasCode(error, "EEXIST")) throw error;
+      if (!hasErrorCode2(error, "EEXIST")) throw error;
     }
     await safeRoot(directory);
   }
@@ -1458,7 +1726,8 @@ async function syncDirectory(path) {
     directory = await open4(path, "r");
     await directory.sync();
   } catch (error) {
-    if (process.platform !== "win32" || !["EPERM", "EACCES", "EINVAL", "EISDIR"].some((code) => hasCode(error, code))) throw error;
+    if (process.platform !== "win32" || !["EPERM", "EACCES", "EINVAL", "EISDIR"].some((code) => hasErrorCode2(error, code)))
+      throw error;
   } finally {
     await directory?.close();
   }
@@ -1472,7 +1741,10 @@ function checkedPath(root, path) {
 }
 __name(checkedPath, "checkedPath");
 function assertRelativePath(path) {
-  if (typeof path !== "string" || !path || isAbsolute2(path) || /[\\:\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u.test(path) || path.split("/").some((part) => !part || part === "." || part === ".." || /[. ]$/u.test(part) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/iu.test(part))) throw new Error("Unsafe or nonportable patch path");
+  if (typeof path !== "string" || !path || isAbsolute2(path) || /[\\:\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/u.test(path) || path.split("/").some(
+    (part) => !part || part === "." || part === ".." || /[. ]$/u.test(part) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/iu.test(part)
+  ))
+    throw new Error("Unsafe or nonportable patch path");
 }
 __name(assertRelativePath, "assertRelativePath");
 function assertPatchId(id) {
@@ -1488,10 +1760,6 @@ function hash2(value) {
   return createHash3("sha256").update(value).digest("hex");
 }
 __name(hash2, "hash");
-function hasCode(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
-}
-__name(hasCode, "hasCode");
 
 // apps/maybecode/src/team-v2.ts
 var VERSION = "maybecode-team-v2";
@@ -1500,26 +1768,38 @@ var DEFAULT_RUN_BUDGET = { maxSteps: 10, maxModelCalls: 10, maxToolCalls: 24, ma
 async function runTeamV2Command(command, dependencies) {
   const id = command.action === "run" ? randomUUID2() : command.value;
   if (!/^[A-Za-z0-9_-]{1,128}$/u.test(id)) throw new Error("Invalid team id");
-  const directory = await canonicalPotentialPath(join4(resolve3(command.dataDirectory ?? getDefaultMaybeCodeDataDirectory()), "teams", id));
+  const directory = await canonicalPotentialPath(
+    join4(resolve3(command.dataDirectory ?? getDefaultMaybeCodeDataDirectory()), "teams", id)
+  );
   const write = /* @__PURE__ */ __name((text2) => dependencies.write(safeTerminal(text2)), "write");
   let config;
   let manifest;
   if (command.action === "run") {
-    if (!command.value.trim() || Buffer.byteLength(command.value) > 32768) throw new Error("Team prompt must contain 1-32768 bytes");
+    if (!command.value.trim() || Buffer.byteLength(command.value) > 32768)
+      throw new Error("Team prompt must contain 1-32768 bytes");
     const workspace = await realpath3(resolve3(command.workspace ?? process.cwd()));
-    if (!(await stat(workspace)).isDirectory() || inside2(workspace, directory) || inside2(directory, workspace)) throw new Error("Team data directory must be outside and not overlap the source workspace");
+    if (!(await stat(workspace)).isDirectory() || inside2(workspace, directory) || inside2(directory, workspace))
+      throw new Error("Team data directory must be outside and not overlap the source workspace");
     const mode = command.mode ?? "read-only";
-    const plan = command.planPath ? await loadTeamPlan(command.planPath, { mode }) : createTeamPreset(command.preset ?? "supervisor", command.value, { mode, ...command.model ? { model: command.model } : {} });
+    const plan = command.planPath ? await loadTeamPlan(command.planPath, { mode }) : createTeamPreset(command.preset ?? "supervisor", command.value, {
+      mode,
+      ...command.model ? { model: command.model } : {}
+    });
     config = await (dependencies.loadConfig ?? loadMayConfig)(command.configPath ? { path: command.configPath } : {});
     const fallback = command.model ?? (Object.values(plan.roles).every((role) => role.model !== void 0) ? Object.values(plan.roles)[0].model : void 0);
     const defaultModel = selectMaybeCodeModel(config, fallback ? { model: fallback } : {});
     const roleModels = {};
     for (const [name, role] of Object.entries(plan.roles)) {
       const selected = selectMaybeCodeModel(config, { model: role.model ?? defaultModel.profile });
-      const runBudget = resolveRunBudget2(resolveRunBudget2(config.apps?.maybecode?.runBudget, DEFAULT_RUN_BUDGET), role.runBudget);
+      const runBudget = resolveRunBudget2(
+        resolveRunBudget2(readMaybeCodeSettings(config).runBudget, DEFAULT_RUN_BUDGET),
+        role.runBudget
+      );
       roleModels[name] = { profile: selected.profile, fingerprint: modelFingerprint(selected), runBudget };
     }
     manifest = {
+      execution: readMaybeCodeSettings(config).execution ?? { mode: "host" },
+      fetch: readMaybeCodeSettings(config).fetch ?? {},
       format: 1,
       version: VERSION,
       id,
@@ -1540,7 +1820,8 @@ async function runTeamV2Command(command, dependencies) {
     await mkdir3(directory, { recursive: true, mode: 448 });
     await writeJson(join4(directory, "manifest.json"), manifest, true);
   } else manifest = await readManifest(directory, id);
-  if (inside2(manifest.workspace, directory) || inside2(directory, manifest.workspace)) throw new Error("Team data and source directories overlap");
+  if (inside2(manifest.workspace, directory) || inside2(directory, manifest.workspace))
+    throw new Error("Team data and source directories overlap");
   const authorityVersion = `${VERSION}-${teamReviewDigest({ mode: manifest.mode, allowChecks: manifest.allowChecks, plan: manifest.plan, roleModels: manifest.roleModels })}`;
   const budgetLimits = { maxModelCalls: manifest.maxModelCalls, maxTotalTokens: manifest.maxTotalTokens };
   if (command.action === "status") {
@@ -1551,10 +1832,12 @@ Records: ${directory}
     write(await inspectTeam(directory, id, budgetLimits));
     const path = join4(directory, "acceptance.json");
     try {
-      write(`Last acceptance projection (may be stale): ${await withFileAccess(path, "shared", () => readFile(path, "utf8"))}
-`);
+      write(
+        `Last acceptance projection (may be stale): ${await withFileAccess(path, "shared", () => readFile(path, "utf8"))}
+`
+      );
     } catch (error) {
-      if (!isMissing2(error)) throw error;
+      if (!hasErrorCode3(error, "ENOENT")) throw error;
     }
     return 0;
   }
@@ -1566,15 +1849,25 @@ Records: ${directory}
   }
   const executes = command.action === "run" || command.action === "resume";
   const selections = /* @__PURE__ */ new Map();
+  let recording;
   if (executes) {
     config ??= await (dependencies.loadConfig ?? loadMayConfig)({ path: manifest.configPath });
+    recording = resolveMaybeCodeRecording(config);
     for (const [name, binding] of Object.entries(manifest.roleModels)) {
       const selected = selectMaybeCodeModel(config, { model: binding.profile });
-      if (modelFingerprint(selected) !== binding.fingerprint) throw new Error(`Model configuration changed for role ${name}; restore it before resuming`);
+      if (modelFingerprint(selected) !== binding.fingerprint)
+        throw new Error(`Model configuration changed for role ${name}; restore it before resuming`);
       selections.set(name, selected);
     }
   }
   const ledger = await FileSharedBudget.open(join4(directory, "budget"), id, budgetLimits);
+  const settings = readMaybeCodeSettings({
+    providers: {},
+    models: {},
+    path: manifest.configPath,
+    apps: { maybecode: { execution: manifest.execution ?? { mode: "host" }, fetch: manifest.fetch ?? {} } }
+  });
+  const executionEnvironments = new TeamExecutionEnvironments(settings.execution);
   let workspaces;
   let artifacts;
   let verification;
@@ -1583,9 +1876,31 @@ Records: ${directory}
   let timer;
   let cancelling;
   let retryAuthorized = false;
+  const backgroundTasks = /* @__PURE__ */ new Set();
+  const backgroundErrors = [];
+  let failBackground;
+  const backgroundFailed = new Promise((resolve4) => {
+    failBackground = resolve4;
+  });
+  const trackBackground = /* @__PURE__ */ __name((operation) => {
+    const task = operation.then(
+      () => {
+        backgroundTasks.delete(task);
+      },
+      (error) => {
+        backgroundTasks.delete(task);
+        backgroundErrors.push(error);
+        failBackground(error);
+        cancel();
+      }
+    );
+    backgroundTasks.add(task);
+  }, "trackBackground");
   const cancel = /* @__PURE__ */ __name(() => {
-    if (runtime) cancelling ??= runtime.cancel(`cancel-${id}`);
-    void cancelling?.catch(() => void 0);
+    if (runtime && !cancelling) {
+      cancelling = runtime.cancel(`cancel-${id}`);
+      trackBackground(cancelling);
+    }
   }, "cancel");
   try {
     artifacts = await FileArtifactStore.open(join4(directory, "artifacts"), id, {
@@ -1595,8 +1910,15 @@ Records: ${directory}
       maxArtifactBytes: 262144,
       maxTotalBytes: 16777216
     });
-    workspaces = await TaskWorkspaceManager.open({ sourceDirectory: manifest.workspace, directory: join4(directory, "workspaces") });
-    verification = await TeamVerificationStore.open({ directory: join4(directory, "verification"), checks: manifest.plan.checks });
+    workspaces = await TaskWorkspaceManager.open({
+      sourceDirectory: manifest.workspace,
+      directory: join4(directory, "workspaces")
+    });
+    verification = await TeamVerificationStore.open({
+      directory: join4(directory, "verification"),
+      checks: manifest.plan.checks,
+      executionFor: /* @__PURE__ */ __name((workspace) => executionEnvironments.get(workspace), "executionFor")
+    });
     const sessionStore = new FileSessionStore2(join4(directory, "sessions"));
     const models = /* @__PURE__ */ new Map();
     const modelFor = /* @__PURE__ */ __name((name) => {
@@ -1607,68 +1929,97 @@ Records: ${directory}
         const maxOutputTokens = Math.min(
           4096,
           selected.limits?.maxOutputTokens ?? 4096,
-          ...[selected.options.maxTokens, selected.options.maxOutputTokens].filter((n) => typeof n === "number" && n > 0 && Number.isSafeInteger(n))
+          ...[selected.options.maxTokens, selected.options.maxOutputTokens].filter(
+            (n) => typeof n === "number" && n > 0 && Number.isSafeInteger(n)
+          )
         );
         const selection = {
           ...selected,
           options: { ...selected.options, maxTokens: maxOutputTokens, maxOutputTokens },
           limits: { ...selected.limits, maxOutputTokens }
         };
-        model = ledger.wrapModel((dependencies.createModel ?? createMaybeCodeModel)(selection), { reservation: { totalTokens: RESERVATION } });
+        model = ledger.wrapModel((dependencies.createModel ?? createMaybeCodeModel)(selection), {
+          reservation: { totalTokens: RESERVATION }
+        });
         models.set(name, model);
       }
       return model;
     }, "modelFor");
     const agents = {};
     for (const [name, role] of Object.entries(manifest.plan.roles)) {
-      const scoped = /* @__PURE__ */ __name((execution, workspace) => createApplicationAgent({
-        version: authorityVersion,
-        store: sessionStore,
-        delegation: role.delegateTo.length > 0,
-        messaging: role.messaging,
-        definition: /* @__PURE__ */ __name(({ tools }) => {
-          const available = [
-            createReadTool({ cwd: workspace, maxBytes: 262144, maxLines: 160 }),
-            createListTool(workspace),
-            ...artifacts.forTask(execution.task.id).tools(),
-            ...verification.forTask(execution, workspace, { allowCommands: manifest.allowChecks }).tools(),
-            ...manifest.mode === "coding" ? [createWriteTool({ cwd: workspace, maxBytes: 262144 }), createEditTool({ cwd: workspace, maxBytes: 262144 })] : []
-          ];
-          const selectedTools = available.filter((tool) => role.tools.includes(tool.name)).map((tool) => {
-            if (!["write", "edit"].includes(tool.name)) return tool;
-            return { ...tool, async execute(input, context) {
-              if ((await verification.snapshot()).checks.some((check) => check.status === "unknown" || check.taskId === execution.task.id && check.status === "pending")) throw new Error("Pending or unknown check effects block editing; stop and reconcile uncertain processes first");
-              return tool.execute(input, context);
-            } };
-          });
-          const allowed = new Set([...selectedTools, ...tools].map((tool) => tool.name));
-          const roleBudget = manifest.roleModels[name].runBudget;
-          const budget2 = config ? resolveRunBudget2(roleBudget, config.apps?.maybecode?.runBudget) : roleBudget;
-          return defineAgent({
-            model: modelFor(name),
-            tools: [...selectedTools, ...tools],
-            runBudget: budget2,
-            instructions: instructions(manifest, name, role),
-            toolScope: { workspaceId: workspace },
-            permissionPolicy: /* @__PURE__ */ __name((check) => allowed.has(check.tool.name) ? "allow" : "deny", "permissionPolicy")
-          });
-        }, "definition")
-      }), "scoped");
+      const scoped = /* @__PURE__ */ __name(async (execution, workspace) => {
+        const environment = await executionEnvironments.get(workspace);
+        return createApplicationAgent({
+          version: authorityVersion,
+          store: sessionStore,
+          delegation: role.delegateTo.length > 0,
+          messaging: role.messaging,
+          definition: /* @__PURE__ */ __name(({ tools }) => {
+            const available = [
+              createReadTool({ cwd: workspace, maxBytes: 262144, maxLines: 160 }),
+              createGlobTool({ cwd: workspace, execution: environment }),
+              createGrepTool({ cwd: workspace, execution: environment }),
+              createFetchTool(settings?.fetch ?? {}),
+              createListTool(workspace),
+              ...artifacts.forTask(execution.task.id).tools(),
+              ...verification.forTask(execution, workspace, { allowCommands: manifest.allowChecks }).tools(),
+              ...manifest.mode === "coding" ? [
+                createWriteTool({ cwd: workspace, maxBytes: 262144 }),
+                createEditTool({ cwd: workspace, maxBytes: 262144 })
+              ] : []
+            ];
+            const selectedTools = available.filter((tool) => role.tools.includes(tool.name)).map((tool) => {
+              if (!["write", "edit"].includes(tool.name)) return tool;
+              return {
+                ...tool,
+                async execute(input, context) {
+                  if ((await verification.snapshot()).checks.some(
+                    (check) => check.status === "unknown" || check.taskId === execution.task.id && check.status === "pending"
+                  ))
+                    throw new Error(
+                      "Pending or unknown check effects block editing; stop and reconcile uncertain processes first"
+                    );
+                  return tool.execute(input, context);
+                }
+              };
+            });
+            const allowed = new Set([...selectedTools, ...tools].map((tool) => tool.name));
+            const roleBudget = manifest.roleModels[name].runBudget;
+            const budget2 = config ? resolveRunBudget2(roleBudget, readMaybeCodeSettings(config).runBudget) : roleBudget;
+            if (!recording) throw new Error("A host control command cannot start a model");
+            return defineAgent({
+              ...recording,
+              model: modelFor(name),
+              tools: [...selectedTools, ...tools],
+              runBudget: budget2,
+              instructions: instructions(manifest, name, role),
+              toolScope: { workspaceId: workspace },
+              permissionPolicy: /* @__PURE__ */ __name((check) => allowed.has(check.tool.name) ? "allow" : "deny", "permissionPolicy")
+            });
+          }, "definition")
+        });
+      }, "scoped");
       const publish = /* @__PURE__ */ __name(async (execution, output) => {
-        await artifacts.forTask(execution.task.id).publish(
-          `${execution.task.dispatchId}-${execution.task.turn ?? 0}-final`,
-          { name: `${execution.task.id.slice(0, 100)}-result.md`, text: output.text, mimeType: "text/markdown" }
-        );
+        await artifacts.forTask(execution.task.id).publish(`${execution.task.dispatchId}-${execution.task.turn ?? 0}-final`, {
+          name: `${execution.task.id.slice(0, 100)}-result.md`,
+          text: output.text,
+          mimeType: "text/markdown"
+        });
       }, "publish");
       agents[name] = {
         version: authorityVersion,
         async execute(execution, context) {
-          if ((await verification.snapshot()).checks.some((check) => check.status === "unknown")) throw new Error("Unknown check effects block a new Agent Run; reconcile before retrying");
+          if ((await verification.snapshot()).checks.some((check) => check.status === "unknown"))
+            throw new Error("Unknown check effects block a new Agent Run; reconcile before retrying");
           const isolated = await workspaces.prepare(execution.task.id);
           const dependencyResults = [];
           for (const dependency of execution.dependencies) {
             const source = await workspaces.prepare(dependency.taskId);
-            const acceptance2 = await verification.acceptance(dependency.taskId, source.directory, executionOf(runtime.snapshot(), dependency.taskId));
+            const acceptance2 = await verification.acceptance(
+              dependency.taskId,
+              source.directory,
+              executionOf(runtime.snapshot(), dependency.taskId)
+            );
             const record = {
               taskId: dependency.taskId,
               status: acceptance2.status,
@@ -1678,26 +2029,36 @@ Records: ${directory}
               evidenceValid: acceptance2.report?.evidence.every((item) => item.valid) ?? false,
               detail: acceptance2.detail
             };
-            dependencyResults.push({ ...dependency, output: {
-              ...dependency.output,
-              text: `${dependency.output.text}
+            dependencyResults.push({
+              ...dependency,
+              output: {
+                ...dependency.output,
+                text: `${dependency.output.text}
 
 Host verification record (scoped to that task's private workspace, not the source checkout or every claim):
 ${JSON.stringify(record)}`
-            } });
+              }
+            });
           }
           const submitted = { ...execution, dependencies: dependencyResults };
-          const output = await scoped(submitted, isolated.directory).execute(submitted, context);
+          const output = await (await scoped(submitted, isolated.directory)).execute(submitted, context);
           if (!("yielded" in output)) {
             await publish(execution, output);
-            for (const check of manifest.plan.checks.filter((check2) => check2.taskId === execution.task.id && check2.type !== "command")) {
-              await verification.runCheck(teamReviewDigest({ auto: execution.task.dispatchId, turn: execution.task.turn ?? 0, check: check.id }), check, isolated.directory, { execution, signal: context.signal });
+            for (const check of manifest.plan.checks.filter(
+              (check2) => check2.taskId === execution.task.id && check2.type !== "command"
+            )) {
+              await verification.runCheck(
+                teamReviewDigest({ auto: execution.task.dispatchId, turn: execution.task.turn ?? 0, check: check.id }),
+                check,
+                isolated.directory,
+                { execution, signal: context.signal }
+              );
             }
           }
           return output;
         },
         async recover(execution) {
-          const output = await scoped(execution, manifest.workspace).recover(execution);
+          const output = await (await scoped(execution, manifest.workspace)).recover(execution);
           if (output.status === "completed") await publish(execution, output.output);
           return output;
         }
@@ -1716,7 +2077,8 @@ ${JSON.stringify(record)}`
           if (retryAuthorized) return true;
           const state = runtime?.snapshot(), current = state?.tasks.find((entry) => entry.id === task.id);
           const previous = current?.attempts?.at(-1);
-          if (current?.status !== "queued" || !previous || previous.task.dispatchId !== task.dispatchId || previous.task.sessionId !== task.sessionId || previous.finding !== finding || !/^retry-[a-f0-9]{64}$/u.test(previous.commandId)) return false;
+          if (current?.status !== "queued" || !previous || previous.task.dispatchId !== task.dispatchId || previous.task.sessionId !== task.sessionId || previous.finding !== finding || !/^retry-[a-f0-9]{64}$/u.test(previous.commandId))
+            return false;
           const receipt = state?.commands[previous.commandId];
           if (!receipt) return false;
           const value = JSON.parse(receipt);
@@ -1739,26 +2101,31 @@ ${JSON.stringify(record)}`
         maxConcurrent: manifest.maxConcurrent
       }
     }) : await CoordinationRuntime.resume(options);
-    write(`Team ${id}
+    write(
+      `Team ${id}
 Mode: ${manifest.mode}; source application requires a separate reviewed patch confirmation.
 Records: ${directory}
-`);
-    if (manifest.allowChecks) write("Configured test processes explicitly authorized; no OS sandbox or automatic dependency installation.\n");
+`
+    );
+    if (manifest.allowChecks)
+      write("Configured test processes explicitly authorized; no OS sandbox or automatic dependency installation.\n");
     relay = (async () => {
       const statuses = /* @__PURE__ */ new Map();
       for await (const event of runtime.events) {
         if (event.type === "state.changed") {
-          for (const task of event.snapshot.tasks) if (statuses.get(task.id) !== task.status) {
-            statuses.set(task.id, task.status);
-            write(`[${task.id}] ${task.status}${task.detail ? `: ${task.detail}` : ""}
+          for (const task of event.snapshot.tasks)
+            if (statuses.get(task.id) !== task.status) {
+              statuses.set(task.id, task.status);
+              write(`[${task.id}] ${task.status}${task.detail ? `: ${task.detail}` : ""}
 `);
-          }
-        } else if (event.type === "agent.event" && event.event.type === "run.event" && event.event.event.type === "tool.started") write(`[${event.taskId}] tool ${event.event.event.call.name}
+            }
+        } else if (event.type === "agent.event" && event.event.type === "run.event" && event.event.event.type === "tool.started")
+          write(`[${event.taskId}] tool ${event.event.event.call.name}
 `);
         else if (event.type === "runtime.failed") write("Team runtime failed; inspect recovery records.\n");
       }
     })();
-    void relay.catch(cancel);
+    trackBackground(relay);
     if (command.action === "retry" || command.action === "reconcile") {
       const state = runtime.snapshot(), budget2 = await ledger.snapshot(), checks = await verification.snapshot();
       const operation = command.action === "retry" ? retryImpact(state, command.task, command.finding) : await readTeamResolution(command.resolutionPath);
@@ -1768,58 +2135,85 @@ Records: ${directory}
 Review digest: ${digest}
 `);
       if (!command.confirm) {
-        write("Preview only. Verify recorded effects/usage, then repeat with --confirm and this digest. No agent has executed.\n");
+        write(
+          "Preview only. Verify recorded effects/usage, then repeat with --confirm and this digest. No agent has executed.\n"
+        );
         return 0;
       }
       if (command.confirm !== digest) throw new Error("Review digest changed or mismatched; inspect a fresh preview");
       if (command.action === "retry") {
-        if ((await ledger.totals()).blocked || checks.checks.some((check) => ["unknown", "pending"].includes(check.status))) throw new Error("Reconcile unknown usage/check effects before retrying; no reset or replay is allowed");
+        if ((await ledger.totals()).blocked || checks.checks.some((check) => ["unknown", "pending"].includes(check.status)))
+          throw new Error("Reconcile unknown usage/check effects before retrying; no reset or replay is allowed");
         retryAuthorized = true;
         await runtime.retryTask(`retry-${digest}`, command.task, command.finding);
       } else {
         const resolution = operation;
-        if (resolution.kind === "budget") await ledger.reconcile(resolution.callId, resolution.usage, resolution.finding);
-        else if (resolution.kind === "check") await verification.reconcile(resolution.commandId, { status: resolution.outcome }, resolution.finding);
-        else await runtime.resolveRecovery(`resolve-${digest}`, resolution.taskId, resolution.finding, { status: resolution.outcome, detail: resolution.finding });
+        if (resolution.kind === "budget")
+          await ledger.reconcile(resolution.callId, resolution.usage, resolution.finding);
+        else if (resolution.kind === "check")
+          await verification.reconcile(resolution.commandId, { status: resolution.outcome }, resolution.finding);
+        else
+          await runtime.resolveRecovery(`resolve-${digest}`, resolution.taskId, resolution.finding, {
+            status: resolution.outcome,
+            detail: resolution.finding
+          });
       }
       write("Recorded. No agents or checks executed. Use team resume explicitly when ready.\n");
       return 0;
     }
     if (command.action === "diff" || command.action === "apply") {
-      if (manifest.mode !== "coding") throw new Error("Patch controls require a team explicitly created with --mode coding");
+      if (manifest.mode !== "coding")
+        throw new Error("Patch controls require a team explicitly created with --mode coding");
       const state = runtime.snapshot();
-      if (state.tasks.some((task) => !["completed", "failed", "cancelled"].includes(task.status))) throw new Error("Settle all active/unknown team work before reviewing or applying a patch");
+      if (state.tasks.some((task) => !["completed", "failed", "cancelled"].includes(task.status)))
+        throw new Error("Settle all active/unknown team work before reviewing or applying a patch");
       if (command.action === "diff") {
         const taskIds = command.tasks.split(",");
-        if (!taskIds.length || new Set(taskIds).size !== taskIds.length || taskIds.some((id2) => state.tasks.find((task) => task.id === id2)?.status !== "completed")) throw new Error("Select distinct completed task ids for review");
+        if (!taskIds.length || new Set(taskIds).size !== taskIds.length || taskIds.some((id2) => state.tasks.find((task) => task.id === id2)?.status !== "completed"))
+          throw new Error("Select distinct completed task ids for review");
         const patch2 = await createTeamPatch({ directory, workspaces, taskIds });
         write(renderTeamPatchDiff(patch2));
-        write(`
+        write(
+          `
 Patch: ${patch2.id}
 Review digest: ${patch2.digest}
 Only use team apply after reviewing the diff and current acceptance.
-`);
+`
+        );
         return 0;
       }
       const patch = await readTeamPatch(directory, command.patch);
       const uncheckedTasks = patch.taskSnapshots.map((task) => task.taskId).filter((taskId) => !manifest.plan.checks.some((check) => check.taskId === taskId));
-      if (uncheckedTasks.length) write(`Unverified patch tasks (human review only): ${uncheckedTasks.join(", ")}. Other tasks' passing checks do not verify these edits.
-`);
-      if ((await ledger.totals()).blocked || (await verification.snapshot()).checks.some((check) => ["pending", "unknown"].includes(check.status))) throw new Error("Reconcile unknown team effects before applying source changes");
+      if (uncheckedTasks.length)
+        write(
+          `Unverified patch tasks (human review only): ${uncheckedTasks.join(", ")}. Other tasks' passing checks do not verify these edits.
+`
+        );
+      if ((await ledger.totals()).blocked || (await verification.snapshot()).checks.some((check) => ["pending", "unknown"].includes(check.status)))
+        throw new Error("Reconcile unknown team effects before applying source changes");
       for (const checkTaskId of new Set(manifest.plan.checks.map((check) => check.taskId))) {
         const task = state.tasks.find((task2) => task2.id === checkTaskId);
-        if (task?.status !== "completed") throw new Error("All configured acceptance tasks must complete before source application");
+        if (task?.status !== "completed")
+          throw new Error("All configured acceptance tasks must complete before source application");
         const workspace = await workspaces.prepare(checkTaskId);
-        if ((await verification.acceptance(checkTaskId, workspace.directory, executionOf(state, checkTaskId))).status !== "passed") throw new Error(`Acceptance is not passed/current for ${checkTaskId}; use team verify and inspect reports`);
+        if ((await verification.acceptance(checkTaskId, workspace.directory, executionOf(state, checkTaskId))).status !== "passed")
+          throw new Error(`Acceptance is not passed/current for ${checkTaskId}; use team verify and inspect reports`);
       }
-      if (!manifest.plan.checks.length) write("No configured acceptance checks: this is an explicit human-reviewed, unverified source application.\n");
-      const result2 = await applyTeamPatch({ directory, workspaces, patchId: patch.id, confirmDigest: command.confirm });
+      if (!manifest.plan.checks.length)
+        write("No configured acceptance checks: this is an explicit human-reviewed, unverified source application.\n");
+      const result2 = await applyTeamPatch({
+        directory,
+        workspaces,
+        patchId: patch.id,
+        confirmDigest: command.confirm
+      });
       write(`${JSON.stringify(result2, null, 2)}
 `);
       return result2.status === "applied" ? 0 : 1;
     }
     if (command.action === "verify") {
-      if ((await verification.snapshot()).checks.some((check) => ["unknown", "pending"].includes(check.status))) throw new Error("Reconcile unknown check effects before running new verification");
+      if ((await verification.snapshot()).checks.some((check) => ["unknown", "pending"].includes(check.status)))
+        throw new Error("Reconcile unknown check effects before running new verification");
       const controller = new AbortController();
       const signal = AbortSignal.any([controller.signal, ...dependencies.signal ? [dependencies.signal] : []]);
       const observeCancellation = /* @__PURE__ */ __name(async () => {
@@ -1828,7 +2222,7 @@ Only use team apply after reviewing the diff and current acceptance.
           await withFileAccess(path, "shared", () => stat(path));
           controller.abort("Team verification cancelled");
         } catch (error) {
-          if (!isMissing2(error)) {
+          if (!hasErrorCode3(error, "ENOENT")) {
             controller.abort("Cannot establish cancellation state");
             throw error;
           }
@@ -1836,7 +2230,7 @@ Only use team apply after reviewing the diff and current acceptance.
       }, "observeCancellation");
       await observeCancellation();
       timer = setInterval(() => {
-        void observeCancellation().catch(() => controller.abort("Cancellation monitoring failed"));
+        trackBackground(observeCancellation());
       }, 300);
       const state = runtime.snapshot();
       for (const check of manifest.plan.checks) {
@@ -1850,12 +2244,11 @@ Only use team apply after reviewing the diff and current acceptance.
           continue;
         }
         const workspace = await workspaces.prepare(check.taskId);
-        const result2 = await verification.runCheck(
-          `host-${randomUUID2()}`,
-          check,
-          workspace.directory,
-          { allowCommands: manifest.allowChecks, signal, execution: executionOf(state, check.taskId) }
-        );
+        const result2 = await verification.runCheck(`host-${randomUUID2()}`, check, workspace.directory, {
+          allowCommands: manifest.allowChecks,
+          signal,
+          execution: executionOf(state, check.taskId)
+        });
         write(`Check ${check.id}: ${result2.status}${result2.detail ? ` (${result2.detail})` : ""}
 `);
       }
@@ -1870,7 +2263,7 @@ Only use team apply after reviewing the diff and current acceptance.
         await withFileAccess(path, "shared", () => stat(path));
         cancel();
       } catch (error) {
-        if (!isMissing2(error)) {
+        if (!hasErrorCode3(error, "ENOENT")) {
           cancel();
           throw error;
         }
@@ -1880,14 +2273,21 @@ Only use team apply after reviewing the diff and current acceptance.
     await checkCancellation();
     if (dependencies.signal?.aborted) cancel();
     timer = setInterval(() => {
-      void checkCancellation().catch(cancel);
+      trackBackground(checkCancellation());
     }, 300);
     await cancelling;
     if ((await ledger.totals()).blocked || (await verification.snapshot()).checks.some((check) => check.status === "unknown")) {
-      write("Unknown usage/check effects or exceeded budget block execution. No new Run started; inspect and reconcile explicitly.\n");
+      write(
+        "Unknown usage/check effects or exceeded budget block execution. No new Run started; inspect and reconcile explicitly.\n"
+      );
       return 1;
     }
-    const result = await runtime.wait();
+    const result = await Promise.race([
+      runtime.wait(),
+      backgroundFailed.then((error) => {
+        throw error;
+      })
+    ]);
     await cancelling;
     const final = result.tasks.find((task) => task.id === manifest.plan.resultTaskId);
     if (final?.output?.text) write(`
@@ -1900,9 +2300,11 @@ Team ${complete ? "completed" : "stopped with unfinished or failed tasks"}.
     for (const task of result.tasks) write(`  ${task.id}: ${task.status}
 `);
     const acceptance = await summarizeAcceptance(directory, result, manifest, workspaces, verification);
-    write(`Acceptance: ${acceptance.status}. Completion is not a correctness guarantee.
+    write(
+      `Acceptance: ${acceptance.status}. Completion is not a correctness guarantee.
 Shared budget: ${JSON.stringify(await ledger.totals())}
-`);
+`
+    );
     for (const ref of await artifacts.snapshot()) write(`Artifact [${ref.ownerTaskId}]: ${JSON.stringify(ref)}
 `);
     if (!complete) write(`Inspect: team status ${id}; use explicit reconciliation/retry controls before resume.
@@ -1912,10 +2314,23 @@ Shared budget: ${JSON.stringify(await ledger.totals())}
     if (timer) clearInterval(timer);
     dependencies.signal?.removeEventListener("abort", cancel);
     try {
-      await runtime?.close();
-      await relay;
+      const results = await Promise.allSettled([...runtime ? [runtime.close()] : [], ...relay ? [relay] : []]);
+      while (backgroundTasks.size) await Promise.all(backgroundTasks);
+      const failures = [
+        .../* @__PURE__ */ new Set([
+          ...backgroundErrors,
+          ...results.flatMap((result) => result.status === "rejected" ? [result.reason] : [])
+        ])
+      ];
+      if (failures.length) throw new AggregateError(failures, "Team background operations failed");
     } finally {
-      await Promise.all([verification?.close(), workspaces?.close(), artifacts?.close(), ledger.close()]);
+      await Promise.all([
+        verification?.close(),
+        workspaces?.close(),
+        artifacts?.close(),
+        ledger.close(),
+        executionEnvironments.close()
+      ]);
     }
   }
 }
@@ -1936,15 +2351,26 @@ function executionOf(state, taskId) {
 __name(executionOf, "executionOf");
 async function summarizeAcceptance(directory, state, manifest, workspaces, verification) {
   const tasks = {};
-  for (const task of state.tasks) if (task.status === "completed") {
-    const workspace = await workspaces.prepare(task.id);
-    const { report: _report, ...acceptance } = await verification.acceptance(task.id, workspace.directory, executionOf(state, task.id));
-    tasks[task.id] = acceptance;
-  }
+  for (const task of state.tasks)
+    if (task.status === "completed") {
+      const workspace = await workspaces.prepare(task.id);
+      const { report: _report, ...acceptance } = await verification.acceptance(
+        task.id,
+        workspace.directory,
+        executionOf(state, task.id)
+      );
+      tasks[task.id] = acceptance;
+    }
   const required = [...new Set(manifest.plan.checks.map((check) => check.taskId))];
   const failed = Object.values(tasks).some((task) => task.status === "failed");
   const status = failed ? "failed" : required.length && state.tasks.every((task) => task.status === "completed") && required.every((id) => tasks[id]?.status === "passed") ? "passed" : "unverified";
-  const result = { format: 1, revision: state.revision, status, tasks, note: "Scoped configured checks only, not proof of every natural-language claim. Verify rechecks exact workspace fingerprints." };
+  const result = {
+    format: 1,
+    revision: state.revision,
+    status,
+    tasks,
+    note: "Scoped configured checks only, not proof of every natural-language claim. Verify rechecks exact workspace fingerprints."
+  };
   await writeJson(join4(directory, "acceptance.json"), result);
   return result;
 }
@@ -1972,29 +2398,33 @@ async function readManifest(directory, id) {
 }
 __name(readManifest, "readManifest");
 function validateManifest(value, id) {
-  if (!value || value.format !== 1 || value.version !== VERSION || value.id !== id || !isAbsolute3(value.workspace) || !isAbsolute3(value.configPath) || typeof value.prompt !== "string" || typeof value.model !== "string" || !["coding", "read-only"].includes(value.mode) || typeof value.allowChecks !== "boolean") throw new Error("Invalid v2 team manifest");
+  if (!value || value.format !== 1 || value.version !== VERSION || value.id !== id || !isAbsolute3(value.workspace) || !isAbsolute3(value.configPath) || typeof value.prompt !== "string" || typeof value.model !== "string" || !["coding", "read-only"].includes(value.mode) || typeof value.allowChecks !== "boolean")
+    throw new Error("Invalid v2 team manifest");
   parseTeamPlan(value.plan, { mode: value.mode });
-  if (![value.maxModelCalls, value.maxTotalTokens, value.maxConcurrent].every((n) => Number.isSafeInteger(n) && n > 0) || value.maxModelCalls > 1e4 || value.maxConcurrent > 8 || value.maxTotalTokens < RESERVATION) throw new Error("Invalid team limits; token budget must hold at least 32768 tokens");
-  if (!value.roleModels || Object.keys(value.roleModels).length !== Object.keys(value.plan.roles).length) throw new Error("Invalid role model bindings");
+  if (![value.maxModelCalls, value.maxTotalTokens, value.maxConcurrent].every((n) => Number.isSafeInteger(n) && n > 0) || value.maxModelCalls > 1e4 || value.maxConcurrent > 8 || value.maxTotalTokens < RESERVATION)
+    throw new Error("Invalid team limits; token budget must hold at least 32768 tokens");
+  if (!value.roleModels || Object.keys(value.roleModels).length !== Object.keys(value.plan.roles).length)
+    throw new Error("Invalid role model bindings");
   for (const name of Object.keys(value.plan.roles)) {
     const model = value.roleModels[name];
-    if (!model || typeof model.profile !== "string" || !/^[a-f0-9]{64}$/u.test(model.fingerprint)) throw new Error("Invalid role model binding");
+    if (!model || typeof model.profile !== "string" || !/^[a-f0-9]{64}$/u.test(model.fingerprint))
+      throw new Error("Invalid role model binding");
     resolveRunBudget2(model.runBudget);
   }
 }
 __name(validateManifest, "validateManifest");
 async function writeJson(path, value, exclusive = false) {
+  const contents = `${JSON.stringify(value, null, 2)}
+`;
   await withFileAccess(path, "exclusive", async () => {
-    const target = exclusive ? path : `${path}.${randomUUID2()}.tmp`;
-    const file = await open5(target, "wx", 384);
+    if (!exclusive) return (0, import_write_file_atomic.default)(path, contents, { mode: 384 });
+    const file = await open5(path, "wx", 384);
     try {
-      await file.writeFile(`${JSON.stringify(value, null, 2)}
-`);
+      await file.writeFile(contents);
       await file.sync();
     } finally {
       await file.close();
     }
-    if (!exclusive) await rename2(target, path);
   });
 }
 __name(writeJson, "writeJson");
@@ -2007,7 +2437,7 @@ async function canonicalPotentialPath(path) {
   try {
     return await realpath3(path);
   } catch (error) {
-    if (!isMissing2(error)) throw error;
+    if (!hasErrorCode3(error, "ENOENT")) throw error;
     const parent = dirname2(path);
     if (parent === path) throw error;
     return join4(await canonicalPotentialPath(parent), relative3(parent, path));
@@ -2018,11 +2448,7 @@ function safeTerminal(text2) {
   return text2.replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u009f]/gu, "");
 }
 __name(safeTerminal, "safeTerminal");
-function isMissing2(error) {
-  return !!error && typeof error === "object" && "code" in error && error.code === "ENOENT";
-}
-__name(isMissing2, "isMissing");
 export {
   runTeamV2Command
 };
-//# sourceMappingURL=team-v2-JGBBQ7FR.js.map
+//# sourceMappingURL=team-v2-YYO2G7DJ.js.map