@foldrun/core 2.7.0 → 2.9.0

package/src/store.ts

@@ -981,6 +981,8 @@ export interface AgentInfo {
   /** Colleagues this agent may DELEGATE to (`subagents:`) — each runs with
    *  its own context and its own tools, no wider than this agent's. */
   subagents: string[];
+  /** `sandbox: own` — delegated to, it runs each job in its own sandbox. */
+  sandbox?: "own";
   /** The `skills:` allowlist, or null when the field is absent — which is
    *  not the same thing: absent inherits every skill in scope, an empty
    *  list withholds all of them. */
@@ -1633,6 +1635,7 @@ export function listAgents(tenant: string, workspace: string): AgentInfo[] {
         retiredTools: retiredToolNames(data),
         consults: refNames(data.agents),
         subagents: refNames(data.subagents),
+        ...(data.sandbox === "own" ? { sandbox: "own" as const } : {}),
         skills: data.skills === undefined ? null : refNames(data.skills),
         secrets: Array.isArray(data.secrets) ? data.secrets.map(String) : [],
         budget: runBudget(data.budget),
@@ -3294,6 +3297,17 @@ export function sumAttempts(tries: StepAttempt[]): Pick<StepAttempt, "costUsd" |
 export { type TokenUsage, type PromptLayerRecord, tokensOf, sumTokens, cacheHitRate, measuredHitRate, runTokens, promptLayersChanged, promptCacheNote } from "./tokens.ts";
 import { sumTokens, type TokenUsage, type PromptLayerRecord } from "./tokens.ts";
 
+/** One job a step handed to an isolated sub-agent. `id` is the job's own
+ *  record's `delegation` — not an index, which moves when records are
+ *  spliced in before it. */
+export interface StepDelegation {
+  id: string;
+  agent: string;
+  status: "running" | "completed" | "failed" | "skipped";
+  costUsd?: number | null;
+  ms?: number | null;
+}
+
 /** The marker rescueStep puts in a rescue's instruction; how a rescue record
  *  written before `rescueOf` existed is still recognised. */
 export const RESCUE_MARKER = "<rescue>\nYou are taking this step over:";
@@ -3303,6 +3317,14 @@ export function isRescueRecord(step: { rescueOf?: string; instruction?: string |
   return !!step.rescueOf || (step.instruction ?? "").includes(RESCUE_MARKER);
 }
 
+/** Is this record put in by the runner rather than by the flow — an on-fail
+ *  rescue, or an isolated sub-agent's run (`subagentOf`)? Neither is launched
+ *  with a group, handed on as a group's output, reset by a loop, or copied by
+ *  a re-run as work. */
+export function isSplicedRecord(step: { rescueOf?: string; subagentOf?: string; instruction?: string | null }): boolean {
+  return !!step.subagentOf || isRescueRecord(step);
+}
+
 export interface StepRecord {
   agent: string;
   instruction: string;
@@ -3463,6 +3485,19 @@ export interface StepRecord {
    *  steps). Records written before this field are recognised by their
    *  instruction's `<rescue>` block instead — see isRescueRecord. */
   rescueOf?: string;
+  /** Set on an isolated sub-agent's run (`sandbox: own`, delegate-tools.ts):
+   *  the agent of the step that delegated to it. It ran in its own sandbox
+   *  inside that step; only its reply went back. Like a rescue it is not a
+   *  step of the flow — see isSplicedRecord. */
+  subagentOf?: string;
+  /** On an isolated sub-agent's run: its job's id, as the delegating step's
+   *  `delegations[].id` names it. */
+  delegation?: string;
+  /** On a step that delegated to isolated sub-agents: each job, in order. */
+  delegations?: StepDelegation[];
+  /** On an isolated sub-agent's run: the workspace paths its sandbox's
+   *  changes were applied to — what its delegating step is told it wrote. */
+  wrote?: string[];
   /**
    * Sandbox seconds this step rented, and how many of them were cold start.
    * Set only on the isolated path — an in-process step rents nothing, so
@@ -4254,6 +4289,9 @@ export function runVerdict(run: Pick<RunRecord, "verdict" | "summary">): Verdict
 
 export function runSummary(run: RunRecord): string | null {
   for (let i = run.steps.length - 1; i >= 0; i--) {
+    // A sandbox: own job is appended after every step of the flow; its reply
+    // went to the step that asked, which speaks for the run.
+    if (run.steps[i].subagentOf) continue;
     const line = stepHeadline(run.steps[i]);
     if (line) return line;
   }

package/src/subagents.ts

@@ -42,6 +42,25 @@ export interface SubagentSpec {
   model: string;
 }
 
+/** An isolated sub-agent (`sandbox: own` on its own agent.md): what the
+ *  parent's sandbox needs to offer it as a tool. Everything else — its tools,
+ *  secrets, network, size — is resolved on the worker when the job arrives,
+ *  from its own file, and never enters the parent's sandbox. */
+export interface DelegateSpec {
+  name: string;
+  description: string;
+}
+
+/** Does this agent run in its own sandbox when delegated to? */
+export function ownSandbox(front: { sandbox?: unknown }): boolean {
+  return front.sandbox === "own";
+}
+
+/** The tool the parent calls to hand an isolated sub-agent a job. */
+export function delegateToolName(agent: string): string {
+  return `delegate_${agent.replaceAll("-", "_")}`;
+}
+
 /** The SDK's delegation tool, under both names it has had. Never granted to a
  *  sub-agent: that is what makes the depth one. */
 export const DELEGATE_TOOLS = ["Agent", "Task"] as const;