@aigne/agent-runtime 1.12.0-beta.5

package/dist/program/scoped-afs.cjs

@@ -0,0 +1,538 @@
+const require_index = require('../providers/basic/ash/dist/index.cjs');
+const require_budget = require('../agent-runners/budget.cjs');
+const require_scratchpad_afs = require('../agent-runners/scratchpad-afs.cjs');
+const require_memory_afs = require('../agent-runners/memory-afs.cjs');
+const require_agent_messages_tools = require('./agent-messages-tools.cjs');
+let _aigne_afs = require("@aigne/afs");
+
+//#region src/program/scoped-afs.ts
+/**
+* Chain-depth hard cap. Mirrors `HARD_CAP` in
+* `providers/basic/ash/src/spawn-depth.ts`; kept in sync manually because
+* importing across package boundaries for a constant isn't worth the
+* dependency. Any change there must be reflected here.
+*
+* Semantics match `spawn-depth.ts`: a child whose post-increment depth
+* would be **>= HARD_CAP** is rejected with `CHAIN_DEPTH_EXCEEDED`. With
+* root.chainDepth = 0 this means the deepest reachable child is depth 9;
+* attempting to spawn depth 10 throws.
+*/
+const CHAIN_DEPTH_HARD_CAP = 10;
+/** Default ops applied when a manifest tool entry omits `ops`. */
+const DEFAULT_TOOL_OPS = [
+	"read",
+	"list",
+	"exec",
+	"query"
+];
+/**
+* Built-in messaging tool path — every scope surfaces
+* `/proc/messaging/tools/*`
+* so the LLM can call `agent_post_message` / `agent_read_messages` without
+* each manifest having to declare them. See B32 in
+* `providers/basic/ash/src/agent-run.ts`.
+*/
+const MESSAGING_TOOL_PATH = require_agent_messages_tools.MESSAGING_TOOLS_GLOB;
+/**
+* Budget mount — per-scope `/.meta/budget/{limit,remaining,consumed}` state
+* files driven by the exec middleware in `attachBudgetMount`. Path contract:
+*
+*   - `read("/.meta/budget/limit")`     → configured ceiling (tokens)
+*   - `read("/.meta/budget/remaining")` → `max(0, limit - consumed)`
+*   - `read("/.meta/budget/consumed")`  → tokens decremented so far
+*   - `write("/.meta/budget/*", ...)`   → always `PERMISSION_DENIED`; only
+*       the middleware may mutate state (via the internal `BudgetState` ref).
+*   - `list("/.meta/budget")`           → three-entry listing (above keys).
+*
+* The exec middleware wraps the underlying `afs.exec`:
+*   1. Pre-check `consumed < limit`; otherwise throw `BUDGET_EXHAUSTED`.
+*   2. Call underlying exec.
+*   3. Extract `tokens_used` from the result and serialize the increment
+*      against the rootSession mutex so concurrent sub-runs don't race.
+*
+* Child scopes created by `projectForChild` inherit via a new `BudgetState`
+* whose `parent` points back to the caller's state. Each scope's middleware
+* only decrements its *own* `consumed` — propagation to ancestors happens
+* naturally because `child.exec` delegates to `parent.exec` through the
+* prototype chain, so every ancestor's middleware runs once per call and
+* the rootSession mutex keeps the sequence of increments linear.
+*/
+const BUDGET_MOUNT_ROOT = "/.meta/budget";
+const BUDGET_KEY_LIMIT = "limit";
+const BUDGET_KEY_REMAINING = "remaining";
+const BUDGET_KEY_CONSUMED = "consumed";
+const BUDGET_KEYS = [
+	BUDGET_KEY_LIMIT,
+	BUDGET_KEY_REMAINING,
+	BUDGET_KEY_CONSUMED
+];
+/**
+* Process-local mutex map keyed on `rootSession`. Every decrement for a
+* given scope tree serializes against the same promise chain, so two
+* concurrent sub-runs sharing a rootSession cannot double-count or see a
+* mid-update view of `consumed`. Phase 2 will swap the Map for an AFS KV
+* provider so the guarantee holds across processes; the API shape stays.
+*/
+const rootBudgetLocks = /* @__PURE__ */ new Map();
+async function withRootBudgetLock(rootSession, fn) {
+	const stored = (rootBudgetLocks.get(rootSession) ?? Promise.resolve()).then(fn, fn);
+	rootBudgetLocks.set(rootSession, stored);
+	try {
+		return await stored;
+	} finally {
+		if (rootBudgetLocks.get(rootSession) === stored) rootBudgetLocks.delete(rootSession);
+	}
+}
+function createBudgetState(init) {
+	if (!init.rootSession || typeof init.rootSession !== "string") throw new Error(`BUDGET_INVALID: rootSession must be a non-empty string`);
+	if (typeof init.limit !== "number" || Number.isNaN(init.limit) || init.limit < 0) throw new Error(`BUDGET_INVALID: limit must be a non-negative number`);
+	return {
+		rootSession: init.rootSession,
+		limit: Math.floor(init.limit),
+		consumed: 0
+	};
+}
+function budgetRemaining(state) {
+	return Math.max(0, state.limit - state.consumed);
+}
+function isBudgetPath(path) {
+	return path === BUDGET_MOUNT_ROOT || path.startsWith(`${BUDGET_MOUNT_ROOT}/`);
+}
+function parseBudgetKey(path) {
+	if (!path.startsWith(`${BUDGET_MOUNT_ROOT}/`)) return null;
+	const key = path.slice(14);
+	return BUDGET_KEYS.includes(key) ? key : null;
+}
+function budgetValue(state, key) {
+	if (key === BUDGET_KEY_LIMIT) return state.limit;
+	if (key === BUDGET_KEY_CONSUMED) return state.consumed;
+	return budgetRemaining(state);
+}
+/**
+* Extract `tokens_used` from an exec result. Supports both legacy
+* `data.total_tokens` (the agent-run envelope) and `data._meta.tokens_used`
+* (team/orchestrator aggregate meta). Anything else → 0.
+*/
+function extractTokensUsed(result) {
+	const data = result?.data;
+	if (!data || typeof data !== "object") return 0;
+	const candidates = [data.total_tokens, data._meta?.tokens_used];
+	for (const value of candidates) if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
+	return 0;
+}
+/**
+* Overlay the budget mount on an AFS root:
+*   - `/.meta/budget/{limit,remaining,consumed}` → live reads
+*   - `/.meta/budget/*` writes → `PERMISSION_DENIED`
+*   - `exec(...)` → pre-check `BUDGET_EXHAUSTED`, then decrement by
+*     `tokens_used` under the rootSession mutex.
+*
+* The overlay is non-enumerable (matches the scratch/memory pattern) and
+* transparent for non-budget paths, which fall through via the prototype
+* chain. Every projected child attaches its own overlay backed by its own
+* `BudgetState`, so sibling scopes never see each other's `consumed`.
+*/
+function attachBudgetMount(afs, state) {
+	const child = Object.create(afs);
+	Object.defineProperty(child, "read", {
+		value: async (path, options) => {
+			const key = parseBudgetKey(path);
+			if (key) return {
+				success: true,
+				data: {
+					content: String(budgetValue(state, key)),
+					path
+				}
+			};
+			return afs.read.call(afs, path, options);
+		},
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	Object.defineProperty(child, "write", {
+		value: async (path, payload, options) => {
+			if (isBudgetPath(path)) {
+				const err = /* @__PURE__ */ new Error(`PERMISSION_DENIED: ${path} is managed by the budget exec middleware and cannot be written directly`);
+				err.code = "PERMISSION_DENIED";
+				throw err;
+			}
+			if (typeof afs.write !== "function") throw new Error(`BUDGET_NO_UNDERLYING_WRITE: afs.write not available for ${path}`);
+			return afs.write.call(afs, path, payload, options);
+		},
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	Object.defineProperty(child, "list", {
+		value: async (path, options) => {
+			if (path === BUDGET_MOUNT_ROOT || path === `${BUDGET_MOUNT_ROOT}/`) return {
+				success: true,
+				data: { list: BUDGET_KEYS.map((name) => ({
+					path: `${BUDGET_MOUNT_ROOT}/${name}`,
+					name,
+					type: "file"
+				})) }
+			};
+			return afs.list.call(afs, path, options);
+		},
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	Object.defineProperty(child, "exec", {
+		value: async (path, args, options) => {
+			if (state.consumed >= state.limit) {
+				const err = /* @__PURE__ */ new Error(`BUDGET_EXHAUSTED: scope budget exhausted (path=${path}, limit=${state.limit}, consumed=${state.consumed})`);
+				err.code = "BUDGET_EXHAUSTED";
+				throw err;
+			}
+			const result = await afs.exec.call(afs, path, args, options);
+			const used = extractTokensUsed(result);
+			if (used > 0) await withRootBudgetLock(state.rootSession, () => {
+				state.consumed += used;
+			});
+			return result;
+		},
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+	return child;
+}
+/**
+* Resolve a child scope's budget. The child's effective limit is the
+* result of `resolveBudget({manifest, parentRemaining})`; consumed starts
+* at 0. Ancestor updates are handled by the middleware chain itself
+* (each scope's middleware runs once per call via the prototype chain),
+* so the child's `BudgetState` is independent from the parent's.
+*
+* Returns `undefined` when the parent has no active budget — zero-overhead
+* path for legacy callers that never opt in.
+*
+* Inheritance rules (P5 deferred nit documented here for clarity):
+*
+*   - Parent has budget, child manifest declares one → `resolveBudget`
+*     clamps `min(childBudget.totalTokens, parentRemaining)`.
+*   - Parent has budget, child manifest omits budget → `resolveBudget` uses
+*     `DEFAULT_TOTAL_TOKENS` (80k) then clamps to `parentRemaining`. Net
+*     effect: an undeclared child never exceeds the parent's remaining
+*     window, which is the conservative default.
+*   - Parent has no budget → child is unbudgeted too; the whole
+*     `/.meta/budget/*` overlay is skipped (zero-overhead legacy path).
+*
+* The clamp is only a ceiling. Actual spend is still accounted per call
+* via the exec middleware (`afs.exec` → decrement under `rootSession`
+* mutex), so siblings can't double-spend the parent's remaining window.
+*/
+function deriveChildBudgetState(parent, childBudget) {
+	if (!parent) return void 0;
+	const resolved = require_budget.resolveBudget({
+		manifest: childBudget,
+		parentRemaining: budgetRemaining(parent)
+	});
+	return createBudgetState({
+		rootSession: parent.rootSession,
+		limit: resolved.totalTokens
+	});
+}
+function assertSession(session) {
+	if (session === void 0) return;
+	if (typeof session !== "string" || session.length === 0) throw new Error(`SCOPE_INVALID_INPUT: session must be a non-empty string`);
+	if (session.includes("/") || session.includes("\\")) throw new Error(`SCOPE_INVALID_INPUT: session must not contain path separators`);
+	if (session.includes("\0")) throw new Error(`SCOPE_INVALID_INPUT: session must not contain null bytes`);
+}
+function assertMemberPath(memberPath) {
+	if (typeof memberPath !== "string" || memberPath.length === 0) throw new Error(`SCOPE_INVALID_MEMBER: memberPath must be a non-empty string`);
+	if (memberPath.includes("\0")) throw new Error(`SCOPE_INVALID_MEMBER: memberPath must not contain null bytes`);
+	if (memberPath.split("/").some((s) => s === "..")) throw new Error(`SCOPE_INVALID_MEMBER: memberPath must not traverse parent directories`);
+}
+function assertChildManifest(manifest) {
+	if (!manifest || typeof manifest !== "object") throw new Error(`SCOPE_INVALID_INPUT: childManifest is required`);
+}
+/**
+* Normalize a manifest's `tools` field into `ToolEntry[]`, rejecting shapes
+* that would let a dispatcher smuggle traversal or typo past intersection:
+*   - non-string / empty path → TOOL_PATH_INVALID
+*   - path containing `..` or `\0` → TOOL_PATH_INVALID
+*   - ops must be a non-empty string[] when provided
+*
+* The Phase 1 contract: one call site (projectForChild) owns normalization;
+* older runner-local normalize helpers delegate here.
+*/
+function normalizeManifestTools(manifest) {
+	const raw = manifest.tools ?? [];
+	const result = [];
+	raw.forEach((t, idx) => {
+		const path = typeof t === "string" ? t : t?.path;
+		if (typeof path !== "string" || path.length === 0) throw new Error(`TOOL_PATH_INVALID: manifest.tools[${idx}].path must be a non-empty string`);
+		if (path.includes("\0")) throw new Error(`TOOL_PATH_INVALID: manifest.tools[${idx}].path must not contain null bytes`);
+		if (path.includes("..")) throw new Error(`TOOL_PATH_INVALID: manifest.tools[${idx}].path must not contain ".."`);
+		if (typeof t === "string") {
+			result.push({
+				path,
+				ops: [...DEFAULT_TOOL_OPS]
+			});
+			return;
+		}
+		const ops = t.ops ?? [...DEFAULT_TOOL_OPS];
+		if (!Array.isArray(ops) || ops.length === 0 || ops.some((op) => typeof op !== "string")) throw new Error(`TOOL_PATH_INVALID: manifest.tools[${idx}].ops must be a non-empty string[]`);
+		const entry = {
+			path,
+			ops: require_index.withQueryPairing(ops)
+		};
+		if (t.maxDepth != null) entry.maxDepth = t.maxDepth;
+		result.push(entry);
+	});
+	return result;
+}
+/**
+* Phase 5 canonical session accessor — runners must read the effective
+* session id from `ctx.afs.scope.session` rather than from the legacy
+* `context.session` field. This helper keeps back-compat while the four
+* runners are swapped: if the AFS already carries a scope, return
+* `scope.session`; otherwise fall back to the deprecated `fallback`
+* argument. P6 removes the fallback path once `RunnerContext.session` is
+* deleted.
+*/
+function runnerSession(afs, fallback) {
+	return afs.scope?.session ?? fallback;
+}
+/**
+* Phase 5 canonical parent-session accessor. Mirrors `runnerSession` but
+* surfaces the parent's session id so runners can tag sub-runs without
+* consulting the legacy `context.parentSession` field. Returns undefined
+* for root scopes (no parent) — callers must treat undefined as "root".
+*/
+function runnerParentSession(afs, fallback) {
+	return afs.scope?.parentSession ?? fallback;
+}
+/**
+* Shared session-resolution ladder for every runner. Reads session and
+* parentSession from scope first (legacy context fields only as fallback
+* until P6) and, when both are set, derives the child session id.
+*
+* Collapses the ai / ash / team / orchestrator entry blocks into one
+* place — any adjustment to the derivation rule now has a single owner.
+*/
+function resolveChildSession(afs, ctx, deriveChildSession) {
+	const parentSession = runnerParentSession(afs, ctx.parentSession);
+	let session = runnerSession(afs, ctx.session);
+	if (parentSession && session) session = deriveChildSession(parentSession);
+	return {
+		session,
+		parentSession
+	};
+}
+/**
+* Lift a raw `AFSRoot` into a root-level `AgentScope`. Root scopes are
+* unbounded by construction — `scope.allowedTools` is the caller's own
+* manifest tools (or fully permissive when omitted), and `chainDepth` is 0.
+*
+* Top-level runners (agent-run action handler, test harnesses) use this to
+* bootstrap the scope chain; downstream runners never construct a root
+* scope themselves. Omit `manifestTools` (or pass `[]`) to keep the root
+* fully permissive — useful for tests that don't declare tools.
+*/
+function rootAgentScope(afs, opts) {
+	assertSession(opts.session);
+	const allowedTools = opts.manifestTools && opts.manifestTools.length > 0 ? opts.manifestTools : [{
+		path: "/**",
+		ops: [
+			"read",
+			"list",
+			"exec",
+			"write",
+			"search",
+			"query"
+		]
+	}];
+	let withBudget = afs;
+	let budgetState;
+	if (opts.budget) {
+		const resolved = require_budget.resolveBudget({ manifest: opts.budget });
+		budgetState = createBudgetState({
+			rootSession: opts.session,
+			limit: resolved.totalTokens
+		});
+		withBudget = attachBudgetMount(afs, budgetState);
+	}
+	return attachScope(withBudget, {
+		session: opts.session,
+		rootSession: opts.session,
+		chainDepth: 0,
+		allowedPaths: allowedTools.map((t) => t.path),
+		allowedTools,
+		budget: budgetState,
+		memoryDomain: opts.memoryDomain
+	});
+}
+/**
+* Top-level runner bootstrap — if the caller's AFS is already a scope, use
+* it verbatim; otherwise synthesize a root scope and attach a fresh
+* `/scratch/*` mount. Team and orchestrator runners call this so hook
+* events and `state.yml` writes land in the scope-local scratch rather
+* than the legacy `/modules/memory/runs/` tree.
+*
+* Pass `manifestTools` + `session` to drive the synthetic root scope's
+* descriptor; the caller's own manifest is typically the source, and
+* `scratchRetention` follows `manifest.scratch` (run → session default).
+*/
+function ensureScopeWithMounts(afs, opts) {
+	if (afs.scope) return afs;
+	return require_scratchpad_afs.attachScratchMount(rootAgentScope(afs, {
+		session: opts.session,
+		manifestTools: opts.manifestTools,
+		budget: opts.budget,
+		memoryDomain: require_memory_afs.extractManifestDomain(opts.memory)
+	}), opts.scratchProvider ?? require_scratchpad_afs.createScratchProvider({
+		session: sanitizeSessionForScratch(opts.session),
+		retention: opts.scratchRetention ?? "session"
+	}));
+}
+/**
+* Resolve the `AgentScope` a parent runner projects children from.
+*
+* Phase 6 — if the caller already handed us a scoped AFS (via
+* `projectForChild` / `ensureScopeWithMounts`), reuse it: its `allowedTools`
+* is already the post-intersection view. Otherwise synthesize a root scope
+* from the caller's `manifest.tools`, normalized via `normalizeManifestTools`
+* for a single source of truth. Callers that want a tighter inherited
+* set must hand over a scoped AFS built via `projectForChild` or
+* `ensureScopeWithMounts`.
+*/
+function resolveParentAgentScope(opts) {
+	if (opts.afs.scope) return opts.afs;
+	const manifestTools = normalizeManifestTools(opts.manifest);
+	return rootAgentScope(opts.afs, {
+		session: opts.session ?? "root",
+		manifestTools: manifestTools.length > 0 ? manifestTools : void 0
+	});
+}
+function attachScope(afs, scope) {
+	const child = Object.create(afs);
+	Object.defineProperty(child, "scope", {
+		value: scope,
+		enumerable: true,
+		writable: false,
+		configurable: false
+	});
+	return child;
+}
+/**
+* Narrow down `parent` for a child agent:
+*   - path projection via existing `projectSubAgent` (rewrite + readonly)
+*   - tool ACL intersection via existing `intersectTools` (paths + ops)
+*   - scope descriptor: session / rootSession / chainDepth+1 / allowedPaths
+*
+* If the parent has a non-empty `scope.allowedTools` and the child declares
+* a non-empty `manifest.tools` that doesn't overlap (intersection empty),
+* we throw `TOOL_INTERSECTION_EMPTY` — an empty intersection means the
+* dispatcher has asked for an unreachable child scope, which is a hard
+* error rather than a silently-permissive default.
+*
+* See design.md §5 for the full six-step mount composition; P2–P5 add
+* scratch / memory / budget / session arms to the same function.
+*/
+function projectForChild(parent, options) {
+	assertChildManifest(options.childManifest);
+	assertMemberPath(options.memberPath);
+	assertSession(options.session);
+	if (!parent || typeof parent !== "object" || !parent.scope) throw new Error(`SCOPE_INVALID_INPUT: parent scope is required`);
+	const nextDepth = parent.scope.chainDepth + 1;
+	if (nextDepth >= CHAIN_DEPTH_HARD_CAP) throw new Error(`CHAIN_DEPTH_EXCEEDED: chainDepth ${nextDepth} reaches hard cap ${CHAIN_DEPTH_HARD_CAP}`);
+	const childDeclaredTools = normalizeManifestTools(options.childManifest);
+	const parentAllowed = parent.scope.allowedTools;
+	const intersected = childDeclaredTools.length === 0 ? [] : require_index.intersectTools([...parentAllowed], childDeclaredTools);
+	if (childDeclaredTools.length > 0 && intersected.length === 0) throw new Error(`TOOL_INTERSECTION_EMPTY: child manifest declares tools that don't intersect parent scope`);
+	const withMessaging = ensureMessagingTool(intersected);
+	const projectedAfs = (0, _aigne_afs.projectSubAgent)(parent, {
+		memberPath: options.memberPath,
+		mode: "readonly"
+	});
+	const childSession = options.session ?? deriveDefaultChildSession(parent.scope.session, options.memberPath);
+	const withScratch = require_scratchpad_afs.attachScratchMount(projectedAfs, require_scratchpad_afs.createScratchProvider({
+		session: sanitizeSessionForScratch(childSession),
+		retention: options.childManifest.scratch ? "session" : "run"
+	}));
+	const memoryDomain = isMemoryEnabled(options.childManifest.memory) ? require_memory_afs.resolveMemoryDomain({
+		manifestMemory: options.childManifest.memory,
+		parentDomain: parent.scope.memoryDomain,
+		memberPath: options.memberPath
+	}) : void 0;
+	const inheritsParentMemoryMount = memoryDomain !== void 0 && memoryDomain === parent.scope.memoryDomain;
+	const withMemory = memoryDomain && !inheritsParentMemoryMount ? require_memory_afs.attachMemoryMount(withScratch, require_memory_afs.createMemoryProvider({
+		domain: memoryDomain,
+		storage: require_memory_afs.buildMemoryStorageForAfs(parent),
+		...require_memory_afs.buildMemoryIndexOptsForAfs(parent)
+	})) : withScratch;
+	const finalTools = memoryDomain ? ensureMemoryTool(withMessaging) : withMessaging;
+	const childBudget = deriveChildBudgetState(parent.scope.budget, options.childManifest.budget);
+	return attachScope(childBudget ? attachBudgetMount(withMemory, childBudget) : withMemory, {
+		session: childSession,
+		parentSession: parent.scope.session,
+		rootSession: parent.scope.rootSession,
+		chainDepth: nextDepth,
+		allowedPaths: finalTools.map((t) => t.path),
+		allowedTools: finalTools,
+		memoryDomain,
+		budget: childBudget
+	});
+}
+/** `memory: true` | `memory: { … }` both count; `false`/`undefined` do not. */
+function isMemoryEnabled(value) {
+	return value === true || typeof value === "object" && value !== null;
+}
+const MEMORY_TOOL_PATH = "/memory/**";
+function ensureMemoryTool(tools) {
+	if (tools.some((t) => t.path === MEMORY_TOOL_PATH || t.path === "/memory")) return tools;
+	return [...tools, {
+		path: MEMORY_TOOL_PATH,
+		ops: [
+			"read",
+			"list",
+			"exec"
+		]
+	}];
+}
+/**
+* The scope descriptor's `session` may come from callers that tolerate path
+* segments (e.g. `.../planner-0`). The scratch provider rejects separators
+* and dots, so we collapse the caller-supplied id down to a bare token
+* before handing it over.
+*/
+function sanitizeSessionForScratch(session) {
+	const trimmed = (session ?? "").replace(/\/+$/, "");
+	const cleaned = trimmed.slice(trimmed.lastIndexOf("/") + 1).replace(/\.\./g, "").replace(/\0/g, "");
+	return cleaned.length > 0 ? cleaned : "scope";
+}
+function ensureMessagingTool(tools) {
+	if (tools.some((t) => t.path === MESSAGING_TOOL_PATH || t.path === require_agent_messages_tools.MESSAGING_TOOLS_ROOT)) return tools;
+	return [...tools, {
+		path: MESSAGING_TOOL_PATH,
+		ops: ["exec"]
+	}];
+}
+function deriveDefaultChildSession(parentSession, memberPath) {
+	return `${parentSession}.${memberPath.split("/").filter(Boolean).pop() ?? "child"}.${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+* Phase 2 target — serialize a scope for cross-process hand-off (MCP
+* sandbox worker, code-agent runner, …). Always throws in Phase 0/1 so
+* no caller is tempted to persist a partial descriptor before the sandbox
+* boundary exists.
+*/
+function toJSON(_scope) {
+	throw new Error("AGENT_SCOPE_TOJSON_PHASE_2: scope serialization lands with the MCP sandbox (Phase 2)");
+}
+
+//#endregion
+exports.CHAIN_DEPTH_HARD_CAP = CHAIN_DEPTH_HARD_CAP;
+exports.ensureScopeWithMounts = ensureScopeWithMounts;
+exports.normalizeManifestTools = normalizeManifestTools;
+exports.projectForChild = projectForChild;
+exports.resolveChildSession = resolveChildSession;
+exports.resolveParentAgentScope = resolveParentAgentScope;
+exports.rootAgentScope = rootAgentScope;
+exports.runnerSession = runnerSession;
+exports.toJSON = toJSON;