@geminixiang/mikan 1.0.0-beta.20 → 1.0.0-beta.21

package/dist/tools/sandbox.js.map

@@ -1 +1 @@
-{"version":3,"file":"sandbox.js","sourceRoot":"","sources":["../../src/tools/sandbox.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AgentTool } from \"@earendil-works/pi-agent-core\";\nimport { Type } from \"@sinclair/typebox\";\nimport type { SandboxConfig } from \"../sandbox/index.js\";\nimport type { ResourceLimits, SandboxResourceController } from \"../types.js\";\nimport { resolveActorVaultKey } from \"../vault/routing.js\";\n\nconst sandboxSchema = Type.Object({\n  action: Type.Union([Type.Literal(\"status\"), Type.Literal(\"set\")], {\n    description: \"Use status to inspect current limits, or set to apply temporary limits.\",\n  }),\n  cpus: Type.Optional(\n    Type.String({\n      description: \"CPU limit for action=set, for example '0.5', '1', or '2'.\",\n    }),\n  ),\n  memory: Type.Optional(\n    Type.String({\n      description: \"Docker memory limit for action=set, for example '512m', '1g', or '4g'.\",\n    }),\n  ),\n});\n\ntype SandboxToolParams = {\n  action: \"status\" | \"set\";\n  cpus?: string;\n  memory?: string;\n};\n\ninterface SandboxToolContext {\n  userId: string;\n  conversationId: string;\n}\n\ninterface SandboxToolController {\n  sandbox: SandboxConfig;\n  resourceController?: Pick<SandboxResourceController, \"getLimitStatus\" | \"setLimits\">;\n}\n\nexport function createSandboxTool(controller: SandboxToolController): {\n  tool: AgentTool<typeof sandboxSchema>;\n  setSandboxContext: (context: SandboxToolContext) => void;\n} {\n  let sandboxContext: SandboxToolContext | null = null;\n\n  const tool: AgentTool<typeof sandboxSchema> = {\n    name: \"sandbox\",\n    label: \"sandbox\",\n    description:\n      \"Inspect or temporarily set CPU/memory limits for the current managed sandbox. Limits apply to this conversation's runtime and are cleared when it stops.\",\n    parameters: sandboxSchema,\n    execute: async (_toolCallId: string, params: SandboxToolParams, signal?: AbortSignal) => {\n      if (signal?.aborted) {\n        throw new Error(\"Operation aborted\");\n      }\n      if (!sandboxContext) {\n        throw new Error(\"Sandbox context not configured\");\n      }\n      if (\n        (controller.sandbox.type !== \"image\" && controller.sandbox.type !== \"gondolin\") ||\n        !controller.resourceController\n      ) {\n        throw new Error(\"The sandbox tool only supports image:* and gondolin:* managed sandboxes\");\n      }\n\n      const containerKey = resolveActorVaultKey(\n        controller.sandbox,\n        sandboxContext.userId,\n        sandboxContext.conversationId,\n      );\n\n      if (params.action === \"set\") {\n        const limits = normalizeLimits(params);\n        const status = await controller.resourceController.setLimits(containerKey, limits);\n        return textResult(\n          `Updated sandbox limits for ${containerKey}: ${formatLimits(status.limits)}. These temporary limits are cleared when the sandbox runtime stops.`,\n        );\n      }\n\n      const status = controller.resourceController.getLimitStatus(containerKey);\n      return textResult(\n        `Sandbox limits for ${containerKey}: ${formatLimits(status.limits)}${status.boosted ? \" (boosted)\" : \"\"}.`,\n      );\n    },\n  };\n\n  return {\n    tool,\n    setSandboxContext: (context: SandboxToolContext) => {\n      sandboxContext = context;\n    },\n  };\n}\n\nfunction normalizeLimits(params: SandboxToolParams): ResourceLimits {\n  const cpus = normalizeLimitValue(\"cpus\", params.cpus);\n  const memory = normalizeLimitValue(\"memory\", params.memory);\n  if (!cpus && !memory) {\n    throw new Error(\"action=set requires cpus and/or memory\");\n  }\n  return { ...(cpus ? { cpus } : {}), ...(memory ? { memory } : {}) };\n}\n\nfunction normalizeLimitValue(name: string, value: string | undefined): string | undefined {\n  if (value === undefined) return undefined;\n  const trimmed = value.trim();\n  if (!trimmed) return undefined;\n  if (!/^[A-Za-z0-9_.-]+$/.test(trimmed)) {\n    throw new Error(`${name} must not contain whitespace or shell metacharacters`);\n  }\n  return trimmed;\n}\n\nfunction formatLimits(limits: ResourceLimits | undefined): string {\n  return `CPU ${limits?.cpus ?? \"unlimited\"} / Memory ${limits?.memory ?? \"unlimited\"}`;\n}\n\nfunction textResult(text: string): {\n  content: Array<{ type: \"text\"; text: string }>;\n  details: undefined;\n} {\n  return { content: [{ type: \"text\", text }], details: undefined };\n}\n"]}
+{"version":3,"file":"sandbox.js","sourceRoot":"","sources":["../../src/tools/sandbox.ts"],"names":[],"mappings":"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","sourcesContent":["import type { AgentTool } from \"@earendil-works/pi-agent-core\";\nimport { Type } from \"@sinclair/typebox\";\nimport type { SandboxConfig } from \"../sandbox/index.js\";\nimport type { ResourceLimits, SandboxResourceController } from \"../types.js\";\nimport { actorKey } from \"../sandbox/identity.js\";\n\nconst sandboxSchema = Type.Object({\n  action: Type.Union([Type.Literal(\"status\"), Type.Literal(\"set\")], {\n    description: \"Use status to inspect current limits, or set to apply temporary limits.\",\n  }),\n  cpus: Type.Optional(\n    Type.String({\n      description: \"CPU limit for action=set, for example '0.5', '1', or '2'.\",\n    }),\n  ),\n  memory: Type.Optional(\n    Type.String({\n      description: \"Docker memory limit for action=set, for example '512m', '1g', or '4g'.\",\n    }),\n  ),\n});\n\ntype SandboxToolParams = {\n  action: \"status\" | \"set\";\n  cpus?: string;\n  memory?: string;\n};\n\ninterface SandboxToolContext {\n  userId: string;\n  conversationId: string;\n}\n\ninterface SandboxToolController {\n  sandbox: SandboxConfig;\n  resourceController?: Pick<SandboxResourceController, \"getLimitStatus\" | \"setLimits\">;\n}\n\nexport function createSandboxTool(controller: SandboxToolController): {\n  tool: AgentTool<typeof sandboxSchema>;\n  setSandboxContext: (context: SandboxToolContext) => void;\n} {\n  let sandboxContext: SandboxToolContext | null = null;\n\n  const tool: AgentTool<typeof sandboxSchema> = {\n    name: \"sandbox\",\n    label: \"sandbox\",\n    description:\n      \"Inspect or temporarily set CPU/memory limits for the current managed sandbox. Limits apply to this conversation's runtime and are cleared when it stops.\",\n    parameters: sandboxSchema,\n    execute: async (_toolCallId: string, params: SandboxToolParams, signal?: AbortSignal) => {\n      if (signal?.aborted) {\n        throw new Error(\"Operation aborted\");\n      }\n      if (!sandboxContext) {\n        throw new Error(\"Sandbox context not configured\");\n      }\n      if (\n        (controller.sandbox.type !== \"image\" && controller.sandbox.type !== \"gondolin\") ||\n        !controller.resourceController\n      ) {\n        throw new Error(\"The sandbox tool only supports image:* and gondolin:* managed sandboxes\");\n      }\n\n      const containerKey = actorKey(controller.sandbox, {\n        userId: sandboxContext.userId,\n        conversationId: sandboxContext.conversationId,\n      });\n\n      if (params.action === \"set\") {\n        const limits = normalizeLimits(params);\n        const status = await controller.resourceController.setLimits(containerKey, limits);\n        return textResult(\n          `Updated sandbox limits for ${containerKey}: ${formatLimits(status.limits)}. These temporary limits are cleared when the sandbox runtime stops.`,\n        );\n      }\n\n      const status = controller.resourceController.getLimitStatus(containerKey);\n      return textResult(\n        `Sandbox limits for ${containerKey}: ${formatLimits(status.limits)}${status.boosted ? \" (boosted)\" : \"\"}.`,\n      );\n    },\n  };\n\n  return {\n    tool,\n    setSandboxContext: (context: SandboxToolContext) => {\n      sandboxContext = context;\n    },\n  };\n}\n\nfunction normalizeLimits(params: SandboxToolParams): ResourceLimits {\n  const cpus = normalizeLimitValue(\"cpus\", params.cpus);\n  const memory = normalizeLimitValue(\"memory\", params.memory);\n  if (!cpus && !memory) {\n    throw new Error(\"action=set requires cpus and/or memory\");\n  }\n  return { ...(cpus ? { cpus } : {}), ...(memory ? { memory } : {}) };\n}\n\nfunction normalizeLimitValue(name: string, value: string | undefined): string | undefined {\n  if (value === undefined) return undefined;\n  const trimmed = value.trim();\n  if (!trimmed) return undefined;\n  if (!/^[A-Za-z0-9_.-]+$/.test(trimmed)) {\n    throw new Error(`${name} must not contain whitespace or shell metacharacters`);\n  }\n  return trimmed;\n}\n\nfunction formatLimits(limits: ResourceLimits | undefined): string {\n  return `CPU ${limits?.cpus ?? \"unlimited\"} / Memory ${limits?.memory ?? \"unlimited\"}`;\n}\n\nfunction textResult(text: string): {\n  content: Array<{ type: \"text\"; text: string }>;\n  details: undefined;\n} {\n  return { content: [{ type: \"text\", text }], details: undefined };\n}\n"]}

package/dist/tools/subagent-slots.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Process-wide subagent fan-out account. The per-conversation queues
+ * serialize agent runs, and each run's subagent tool bounds its own fan-out
+ * — but without a shared ceiling, N busy conversations hold N × per-run-cap
+ * live subagent sessions. Every subagent launch draws a slot from one shared
+ * pool; the per-run cap and this global ceiling are the two bounds, both
+ * enforced at the same seam (the tool's slot acquisition).
+ */
+/** Default process-wide ceiling on concurrently live subagent sessions. */
+export declare const DEFAULT_GLOBAL_SUBAGENT_SLOTS = 8;
+/** Async slot pool: at most `capacity` concurrent holders, FIFO waiters. */
+export declare class SubagentSlotPool {
+    readonly capacity: number;
+    private held;
+    private waiters;
+    constructor(capacity: number);
+    /** Currently held slots (for tests and capacity reporting). */
+    get inFlight(): number;
+    /**
+     * Resolve with a release function once a slot frees up. Call the release
+     * exactly once; releasing hands the slot to the oldest waiter.
+     */
+    acquire(): Promise<() => void>;
+    private releaser;
+}
+/** A pool that never blocks — the default when no shared ceiling is wired. */
+export declare function unboundedSlotPool(): SubagentSlotPool;
+//# sourceMappingURL=subagent-slots.d.ts.map

package/dist/tools/subagent-slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-slots.d.ts","sourceRoot":"","sources":["../../src/tools/subagent-slots.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,6BAA6B,IAAI,CAAC;AAE/C,4EAA4E;AAC5E,qBAAa,gBAAgB;IAIf,QAAQ,CAAC,QAAQ,EAAE,MAAM;IAHrC,OAAO,CAAC,IAAI,CAAK;IACjB,OAAO,CAAC,OAAO,CAAyB;IAExC,YAAqB,QAAQ,EAAE,MAAM,EAIpC;IAED,+DAA+D;IAC/D,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;;;OAGG;IACG,OAAO,IAAI,OAAO,CAAC,MAAM,IAAI,CAAC,CAUnC;IAED,OAAO,CAAC,QAAQ;CAUjB;AAED,8EAA8E;AAC9E,wBAAgB,iBAAiB,IAAI,gBAAgB,CAEpD"}

package/dist/tools/subagent-slots.js

@@ -0,0 +1,57 @@
+/**
+ * Process-wide subagent fan-out account. The per-conversation queues
+ * serialize agent runs, and each run's subagent tool bounds its own fan-out
+ * — but without a shared ceiling, N busy conversations hold N × per-run-cap
+ * live subagent sessions. Every subagent launch draws a slot from one shared
+ * pool; the per-run cap and this global ceiling are the two bounds, both
+ * enforced at the same seam (the tool's slot acquisition).
+ */
+/** Default process-wide ceiling on concurrently live subagent sessions. */
+export const DEFAULT_GLOBAL_SUBAGENT_SLOTS = 8;
+/** Async slot pool: at most `capacity` concurrent holders, FIFO waiters. */
+export class SubagentSlotPool {
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.held = 0;
+        this.waiters = [];
+        if (!(capacity >= 1)) {
+            throw new Error(`SubagentSlotPool capacity must be >= 1, got ${capacity}`);
+        }
+    }
+    /** Currently held slots (for tests and capacity reporting). */
+    get inFlight() {
+        return this.held;
+    }
+    /**
+     * Resolve with a release function once a slot frees up. Call the release
+     * exactly once; releasing hands the slot to the oldest waiter.
+     */
+    async acquire() {
+        if (this.held < this.capacity) {
+            this.held += 1;
+            return this.releaser();
+        }
+        await new Promise((resolve) => {
+            this.waiters.push(resolve);
+        });
+        this.held += 1;
+        return this.releaser();
+    }
+    releaser() {
+        let released = false;
+        return () => {
+            if (released)
+                return;
+            released = true;
+            this.held -= 1;
+            const next = this.waiters.shift();
+            if (next)
+                next();
+        };
+    }
+}
+/** A pool that never blocks — the default when no shared ceiling is wired. */
+export function unboundedSlotPool() {
+    return new SubagentSlotPool(Number.MAX_SAFE_INTEGER);
+}
+//# sourceMappingURL=subagent-slots.js.map

package/dist/tools/subagent-slots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subagent-slots.js","sourceRoot":"","sources":["../../src/tools/subagent-slots.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,2EAA2E;AAC3E,MAAM,CAAC,MAAM,6BAA6B,GAAG,CAAC,CAAC;AAE/C,4EAA4E;AAC5E,MAAM,OAAO,gBAAgB;IAI3B,YAAqB,QAAgB;QAAhB,aAAQ,GAAR,QAAQ,CAAQ;QAH7B,SAAI,GAAG,CAAC,CAAC;QACT,YAAO,GAAsB,EAAE,CAAC;QAGtC,IAAI,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,+CAA+C,QAAQ,EAAE,CAAC,CAAC;QAC7E,CAAC;IACH,CAAC;IAED,+DAA+D;IAC/D,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,OAAO;QACX,IAAI,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YAC9B,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC;YACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;QACzB,CAAC;QACD,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YAClC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC;QACf,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC;IACzB,CAAC;IAEO,QAAQ;QACd,IAAI,QAAQ,GAAG,KAAK,CAAC;QACrB,OAAO,GAAG,EAAE;YACV,IAAI,QAAQ;gBAAE,OAAO;YACrB,QAAQ,GAAG,IAAI,CAAC;YAChB,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC;YACf,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;YAClC,IAAI,IAAI;gBAAE,IAAI,EAAE,CAAC;QACnB,CAAC,CAAC;IACJ,CAAC;CACF;AAED,8EAA8E;AAC9E,MAAM,UAAU,iBAAiB;IAC/B,OAAO,IAAI,gBAAgB,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC;AACvD,CAAC","sourcesContent":["/**\n * Process-wide subagent fan-out account. The per-conversation queues\n * serialize agent runs, and each run's subagent tool bounds its own fan-out\n * — but without a shared ceiling, N busy conversations hold N × per-run-cap\n * live subagent sessions. Every subagent launch draws a slot from one shared\n * pool; the per-run cap and this global ceiling are the two bounds, both\n * enforced at the same seam (the tool's slot acquisition).\n */\n\n/** Default process-wide ceiling on concurrently live subagent sessions. */\nexport const DEFAULT_GLOBAL_SUBAGENT_SLOTS = 8;\n\n/** Async slot pool: at most `capacity` concurrent holders, FIFO waiters. */\nexport class SubagentSlotPool {\n  private held = 0;\n  private waiters: Array<() => void> = [];\n\n  constructor(readonly capacity: number) {\n    if (!(capacity >= 1)) {\n      throw new Error(`SubagentSlotPool capacity must be >= 1, got ${capacity}`);\n    }\n  }\n\n  /** Currently held slots (for tests and capacity reporting). */\n  get inFlight(): number {\n    return this.held;\n  }\n\n  /**\n   * Resolve with a release function once a slot frees up. Call the release\n   * exactly once; releasing hands the slot to the oldest waiter.\n   */\n  async acquire(): Promise<() => void> {\n    if (this.held < this.capacity) {\n      this.held += 1;\n      return this.releaser();\n    }\n    await new Promise<void>((resolve) => {\n      this.waiters.push(resolve);\n    });\n    this.held += 1;\n    return this.releaser();\n  }\n\n  private releaser(): () => void {\n    let released = false;\n    return () => {\n      if (released) return;\n      released = true;\n      this.held -= 1;\n      const next = this.waiters.shift();\n      if (next) next();\n    };\n  }\n}\n\n/** A pool that never blocks — the default when no shared ceiling is wired. */\nexport function unboundedSlotPool(): SubagentSlotPool {\n  return new SubagentSlotPool(Number.MAX_SAFE_INTEGER);\n}\n"]}

package/dist/tools/subagent.d.ts

@@ -1,6 +1,7 @@
 import type { AgentTool } from "@earendil-works/pi-agent-core";
 import { type TSchema } from "@sinclair/typebox";
 import type { SubagentRunOutput, SubagentRunRequest, SubagentRunResult } from "../harness/types.js";
+import { type SubagentSlotPool } from "./subagent-slots.js";
 declare const subagentSchema: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
     task: import("@sinclair/typebox").TString;
     label: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
@@ -63,7 +64,11 @@ declare const subagentSchema: import("@sinclair/typebox").TUnion<[import("@sincl
     }>;
 }>]>;
 type RunSubagent = <TOutputSchema extends TSchema | undefined = undefined>(request: SubagentRunRequest<TOutputSchema>) => Promise<SubagentRunResult<SubagentRunOutput<TOutputSchema>>>;
-/** Create the normal agent's bounded subagent delegation and DAG tool. */
-export declare function createSubagentTool(runSubagent: RunSubagent): AgentTool<typeof subagentSchema>;
+/**
+ * Create the normal agent's bounded subagent delegation and DAG tool.
+ * `globalSlots` is the process-wide fan-out account shared across every
+ * conversation's tool instance; omitted, fan-out is bounded per run only.
+ */
+export declare function createSubagentTool(runSubagent: RunSubagent, globalSlots?: SubagentSlotPool): AgentTool<typeof subagentSchema>;
 export {};
 //# sourceMappingURL=subagent.d.ts.map

package/dist/tools/subagent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"subagent.d.ts","sourceRoot":"","sources":["../../src/tools/subagent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAA2B,MAAM,+BAA+B,CAAC;AACxF,OAAO,EAAqB,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAqDpG,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAoBlB,CAAC;AAMH,KAAK,WAAW,GAAG,CAAC,aAAa,SAAS,OAAO,GAAG,SAAS,GAAG,SAAS,EACvE,OAAO,EAAE,kBAAkB,CAAC,aAAa,CAAC,KACvC,OAAO,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;AA6MlE,0EAA0E;AAC1E,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,WAAW,GAAG,SAAS,CAAC,OAAO,cAAc,CAAC,CAyF7F"}
+{"version":3,"file":"subagent.d.ts","sourceRoot":"","sources":["../../src/tools/subagent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAA2B,MAAM,+BAA+B,CAAC;AACxF,OAAO,EAAqB,KAAK,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,iBAAiB,EAElB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAqD/E,QAAA,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAwBlB,CAAC;AAMH,KAAK,WAAW,GAAG,CAAC,aAAa,SAAS,OAAO,GAAG,SAAS,GAAG,SAAS,EACvE,OAAO,EAAE,kBAAkB,CAAC,aAAa,CAAC,KACvC,OAAO,CAAC,iBAAiB,CAAC,iBAAiB,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC;AA8RlE;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,WAAW,EACxB,WAAW,GAAE,gBAAsC,GAClD,SAAS,CAAC,OAAO,cAAc,CAAC,CAgElC"}

package/dist/tools/subagent.js

@@ -1,11 +1,12 @@
 import { Type } from "@sinclair/typebox";
+import { unboundedSlotPool } from "./subagent-slots.js";
 const MAX_DAG_NODES = 8;
 const MAX_DAG_EDGES = 16;
 const MAX_DAG_DEPTH = 4;
-const MAX_DAG_CONCURRENCY = 4;
+const MAX_CONCURRENT_SUBAGENTS = 4;
 const MAX_DEPENDENCY_OUTPUT_CHARS = 4000;
 const taskProperties = {
-    task: Type.String({ description: "Self-contained task for a fresh subagent." }),
+    task: Type.String({ minLength: 1, description: "Self-contained task for a fresh subagent." }),
     label: Type.Optional(Type.String({ maxLength: 64, description: "Short progress label for this subagent." })),
     systemPrompt: Type.Optional(Type.String({ description: "Optional role or behavior instructions for the subagent." })),
     input: Type.Optional(Type.Unknown({ description: "Optional JSON-serializable structured input for the task." })),
@@ -48,11 +49,26 @@ const subagentSchema = Type.Union([
     Type.Object({
         dag: Type.Object({
             nodes: Type.Array(dagNodeSchema, { minItems: 1, maxItems: MAX_DAG_NODES }),
-            maxConcurrency: Type.Optional(Type.Integer({ minimum: 1, maximum: MAX_DAG_CONCURRENCY, default: MAX_DAG_CONCURRENCY })),
+            maxConcurrency: Type.Optional(Type.Integer({
+                minimum: 1,
+                maximum: MAX_CONCURRENT_SUBAGENTS,
+                default: MAX_CONCURRENT_SUBAGENTS,
+            })),
         }),
         ...sharedProperties,
     }),
 ]);
+const STATUS_MARKER = {
+    pending: "○",
+    running: "●",
+    completed: "✓",
+    failed: "✗",
+    cancelled: "✗",
+    timeout: "✗",
+    budget_exceeded: "✗",
+    invalid_output: "✗",
+    skipped: "⊘",
+};
 class SubagentProgressTracker {
     constructor(mode, items, onUpdate) {
         this.mode = mode;
@@ -73,18 +89,11 @@ class SubagentProgressTracker {
             ...item,
             status: this.states.get(item.id) ?? "pending",
         }));
-        const settled = nodes.filter((node) => ["completed", "failed", "skipped"].includes(node.status)).length;
-        const marker = {
-            pending: "○",
-            running: "●",
-            completed: "✓",
-            failed: "✗",
-            skipped: "⊘",
-        };
+        const settled = nodes.filter((node) => node.status !== "pending" && node.status !== "running").length;
         const modeLabel = this.mode === "dag" ? "DAG" : this.mode === "parallel" ? "parallel" : "run";
         const progressLabel = [
             `Subagent ${modeLabel} ${settled}/${nodes.length}`,
-            ...nodes.map((node) => `${marker[node.status]} ${node.label}`),
+            ...nodes.map((node) => `${STATUS_MARKER[node.status]} ${node.label}`),
         ].join(" · ");
         this.onUpdate({
             content: [],
@@ -95,14 +104,13 @@ class SubagentProgressTracker {
 function taskLabel(task, fallback) {
     return task.label?.trim() || task.task.trim().slice(0, 48) || fallback;
 }
-function resultProgressStatus(result) {
-    return result.status === "completed" ? "completed" : "failed";
-}
-function formatResult(result) {
-    if (result.status !== "completed") {
-        return `Subagent ${result.status}${result.error ? `: ${result.error}` : ""}`;
+function formatOutcome(outcome) {
+    if (outcome.status !== "completed") {
+        return `Subagent ${outcome.status}${outcome.error ? `: ${outcome.error}` : ""}`;
     }
-    return typeof result.output === "string" ? result.output : JSON.stringify(result.output, null, 2);
+    return typeof outcome.output === "string"
+        ? outcome.output
+        : JSON.stringify(outcome.output, null, 2);
 }
 function buildRequest(task, shared, signal) {
     const outputSchema = shared.outputSchema;
@@ -166,6 +174,48 @@ function buildDagWaves(nodes) {
     }
     return waves;
 }
+function itemForNode(node) {
+    return {
+        id: node.id,
+        label: node.label?.trim() || node.id,
+        task: node,
+        dependsOn: node.dependsOn ?? [],
+    };
+}
+/** Normalize every tool mode into one plan: nodes, waves, concurrency. */
+function buildPlan(params) {
+    if ("dag" in params) {
+        const waves = buildDagWaves(params.dag.nodes).map((wave) => wave.map(itemForNode));
+        const requested = params.dag.maxConcurrency ?? MAX_CONCURRENT_SUBAGENTS;
+        return {
+            mode: "dag",
+            items: params.dag.nodes.map(itemForNode),
+            waves,
+            concurrency: Math.max(1, Math.min(MAX_CONCURRENT_SUBAGENTS, Math.floor(requested))),
+        };
+    }
+    if ("tasks" in params) {
+        const items = params.tasks.map((task, index) => ({
+            id: String(index),
+            label: taskLabel(task, String(index + 1)),
+            task,
+            dependsOn: [],
+        }));
+        return { mode: "parallel", items, waves: [items], concurrency: MAX_CONCURRENT_SUBAGENTS };
+    }
+    const item = { id: "0", label: taskLabel(params, "subagent"), task: params, dependsOn: [] };
+    return { mode: "single", items: [item], waves: [[item]], concurrency: 1 };
+}
+/** Run `worker` over every item with at most `limit` in flight. */
+async function forEachConcurrent(items, limit, worker) {
+    let cursor = 0;
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, async () => {
+        while (cursor < items.length) {
+            const index = cursor++;
+            await worker(items[index], index);
+        }
+    }));
+}
 function dependencyOutput(outcome) {
     if (outcome.status !== "completed")
         return undefined;
@@ -175,111 +225,110 @@ function dependencyOutput(outcome) {
         return null;
     if (serialized.length <= MAX_DEPENDENCY_OUTPUT_CHARS)
         return value;
+    // Oversized structured output becomes a marked string — the shape is lost,
+    // which the tool description warns downstream consumers about.
     return `${serialized.slice(0, MAX_DEPENDENCY_OUTPUT_CHARS)}\n[truncated]`;
 }
-function dagRequest(node, shared, outcomes, signal) {
-    const dependencies = Object.fromEntries((node.dependsOn ?? []).map((id) => [id, dependencyOutput(outcomes.get(id))]));
-    const input = node.dependsOn && node.dependsOn.length > 0
-        ? { ...(node.input !== undefined ? { input: node.input } : {}), dependencies }
-        : node.input;
-    return buildRequest({ ...node, ...(input !== undefined ? { input } : {}) }, shared, signal);
+function planRequest(item, shared, outcomes, signal) {
+    if (item.dependsOn.length === 0)
+        return buildRequest(item.task, shared, signal);
+    const dependencies = Object.fromEntries(item.dependsOn.map((id) => [id, dependencyOutput(outcomes.get(id))]));
+    const input = {
+        ...(item.task.input !== undefined ? { input: item.task.input } : {}),
+        dependencies,
+    };
+    return buildRequest({ ...item.task, input }, shared, signal);
 }
-async function runDag(nodes, maxConcurrency, shared, runSubagent, progress, signal) {
-    const waves = buildDagWaves(nodes);
-    const concurrency = Math.max(1, Math.min(MAX_DAG_CONCURRENCY, Math.floor(maxConcurrency)));
+/**
+ * One executor for every mode: wave barriers, a bounded slot pool inside
+ * each wave, and one global slot per actual subagent launch — the seam where
+ * both the per-run cap and the process-wide ceiling are enforced.
+ */
+async function runWaves(plan, shared, runSubagent, progress, globalSlots, signal) {
     const outcomes = new Map();
-    for (const wave of waves) {
-        for (let offset = 0; offset < wave.length; offset += concurrency) {
-            const chunk = wave.slice(offset, offset + concurrency);
-            for (const node of chunk)
-                progress.update(node.id, "running");
-            await Promise.all(chunk.map(async (node) => {
-                const failedDependency = (node.dependsOn ?? []).find((id) => outcomes.get(id)?.status !== "completed");
-                if (failedDependency) {
-                    outcomes.set(node.id, {
-                        id: node.id,
-                        status: "skipped",
-                        error: `Dependency ${failedDependency} did not complete`,
-                    });
-                    progress.update(node.id, "skipped");
-                    return;
-                }
-                const result = await runSubagent(dagRequest(node, shared, outcomes, signal));
-                outcomes.set(node.id, { id: node.id, ...result });
-                progress.update(node.id, resultProgressStatus(result));
-            }));
-        }
+    for (const wave of plan.waves) {
+        await forEachConcurrent(wave, plan.concurrency, async (item) => {
+            const failedDependency = item.dependsOn.find((id) => outcomes.get(id)?.status !== "completed");
+            if (failedDependency) {
+                outcomes.set(item.id, {
+                    id: item.id,
+                    status: "skipped",
+                    error: `Dependency ${failedDependency} did not complete`,
+                });
+                progress.update(item.id, "skipped");
+                return;
+            }
+            const release = await globalSlots.acquire();
+            let result;
+            try {
+                progress.update(item.id, "running");
+                result = await runSubagent(planRequest(item, shared, outcomes, signal));
+            }
+            finally {
+                release();
+            }
+            outcomes.set(item.id, { id: item.id, ...result });
+            progress.update(item.id, result.status);
+        });
     }
-    return {
-        waves: waves.map((wave) => wave.map((node) => node.id)),
-        results: nodes.map((node) => outcomes.get(node.id)),
-    };
-}
-function formatDagOutcome(outcome) {
-    if (outcome.status === "skipped")
-        return `Subagent skipped: ${outcome.error}`;
-    return formatResult(outcome);
+    return plan.items.map((item) => outcomes.get(item.id));
 }
-/** Create the normal agent's bounded subagent delegation and DAG tool. */
-export function createSubagentTool(runSubagent) {
+/**
+ * Create the normal agent's bounded subagent delegation and DAG tool.
+ * `globalSlots` is the process-wide fan-out account shared across every
+ * conversation's tool instance; omitted, fan-out is bounded per run only.
+ */
+export function createSubagentTool(runSubagent, globalSlots = unboundedSlotPool()) {
     return {
         name: "subagent",
         label: "Subagent",
-        description: "Run fresh isolated subagents. Use task for one subagent, tasks for independent concurrent work, or dag.nodes for a bounded dependency graph. DAG limits: 8 nodes, 16 edges, depth 4, concurrency 4; failed dependencies skip descendants. Subagents have no history or tools unless explicitly provided; nested subagents are not allowed.",
+        description: `Run fresh isolated subagents. Use task for one subagent, tasks for independent concurrent work, or dag.nodes for a bounded dependency graph. At most ${MAX_CONCURRENT_SUBAGENTS} subagents run concurrently. DAG limits: ${MAX_DAG_NODES} nodes, ${MAX_DAG_EDGES} edges, depth ${MAX_DAG_DEPTH}; failed dependencies skip descendants, and dependency outputs larger than ${MAX_DEPENDENCY_OUTPUT_CHARS} characters reach downstream nodes as a truncated string. ` +
+            "Subagents have no history or tools unless explicitly provided; nested subagents are not allowed.",
         parameters: subagentSchema,
         execute: async (_toolCallId, params, signal, onUpdate) => {
-            if ("dag" in params) {
-                const progress = new SubagentProgressTracker("dag", params.dag.nodes.map((node) => ({
-                    id: node.id,
-                    label: node.label?.trim() || node.id,
-                })), onUpdate);
-                progress.emit();
-                const result = await runDag(params.dag.nodes, params.dag.maxConcurrency ?? MAX_DAG_CONCURRENCY, params, runSubagent, progress, signal);
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: result.results
-                                .map((outcome) => `[${outcome.id}] ${formatDagOutcome(outcome)}`)
-                                .join("\n\n"),
-                        },
-                    ],
-                    details: { mode: "dag", ...result },
-                };
-            }
-            if ("tasks" in params) {
-                const progress = new SubagentProgressTracker("parallel", params.tasks.map((task, index) => ({
-                    id: String(index),
-                    label: taskLabel(task, String(index + 1)),
-                })), onUpdate);
-                progress.emit();
-                const results = await Promise.all(params.tasks.map(async (task, index) => {
-                    const id = String(index);
-                    progress.update(id, "running");
-                    const result = await runSubagent(buildRequest(task, params, signal));
-                    progress.update(id, resultProgressStatus(result));
-                    return result;
-                }));
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: results
-                                .map((result, index) => `[${index + 1}] ${formatResult(result)}`)
-                                .join("\n\n"),
+            const plan = buildPlan(params);
+            const progress = new SubagentProgressTracker(plan.mode, plan.items.map(({ id, label }) => ({ id, label })), onUpdate);
+            progress.emit();
+            const ordered = await runWaves(plan, params, runSubagent, progress, globalSlots, signal);
+            switch (plan.mode) {
+                case "dag":
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: ordered
+                                    .map((outcome) => `[${outcome.id}] ${formatOutcome(outcome)}`)
+                                    .join("\n\n"),
+                            },
+                        ],
+                        details: {
+                            mode: "dag",
+                            waves: plan.waves.map((wave) => wave.map((item) => item.id)),
+                            results: ordered,
                         },
-                    ],
-                    details: { mode: "parallel", results },
-                };
+                    };
+                case "parallel": {
+                    const results = ordered.map(({ id: _id, ...result }) => result);
+                    return {
+                        content: [
+                            {
+                                type: "text",
+                                text: results
+                                    .map((result, index) => `[${index + 1}] ${formatOutcome(result)}`)
+                                    .join("\n\n"),
+                            },
+                        ],
+                        details: { mode: "parallel", results },
+                    };
+                }
+                case "single": {
+                    const { id: _id, ...result } = ordered[0];
+                    return {
+                        content: [{ type: "text", text: formatOutcome(result) }],
+                        details: result,
+                    };
+                }
             }
-            const progress = new SubagentProgressTracker("single", [{ id: "0", label: taskLabel(params, "subagent") }], onUpdate);
-            progress.update("0", "running");
-            const result = await runSubagent(buildRequest(params, params, signal));
-            progress.update("0", resultProgressStatus(result));
-            return {
-                content: [{ type: "text", text: formatResult(result) }],
-                details: result,
-            };
         },
     };
 }