@full-self-browsing/lattice 1.3.0-rc.0 → 1.4.0

package/dist/run-crew-CKdBjh5P.js

@@ -0,0 +1,1010 @@
+import { t as __exportAll } from "./rolldown-runtime-CiIaOW0V.js";
+import { O as isArtifactRef, a as createNoopAgentHost, f as validateSchemaOutput, k as toArtifactRef, n as runAgentInternal, p as formatToolsForProvider, u as createNoopSurvivabilityAdapter, y as createReceipt } from "./runtime-D25ehzCj.js";
+import canonicalize from "canonicalize";
+//#region src/receipts/cid.ts
+/**
+* Derive the content-addressed CID of a receipt envelope.
+*
+* Returns `sha256:<hex>` where `<hex>` is the 64-char lowercase SHA-256
+* digest of the decoded DSSE payload bytes. No KeySet, signer, or other
+* key material is required — callers chaining receipts (parentReceiptCid)
+* compute this from the parent envelope alone.
+*/
+async function receiptCid(envelope) {
+	const bytes = Uint8Array.from(atob(envelope.payload), (c) => c.charCodeAt(0));
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	const digest = await crypto.subtle.digest("SHA-256", copy.buffer);
+	return `sha256:${Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+//#endregion
+//#region src/agent/infra/cost-tracker.ts
+const WARNING_THRESHOLD = .8;
+function createCostTracker() {
+	let promptTokens = 0;
+	let completionTokens = 0;
+	let costUsd = null;
+	return {
+		kind: "cost-tracker",
+		recordIteration(usage) {
+			promptTokens += usage.promptTokens;
+			completionTokens += usage.completionTokens;
+			if (usage.costUsd !== null) costUsd = (costUsd ?? 0) + usage.costUsd;
+		},
+		total() {
+			return {
+				promptTokens,
+				completionTokens,
+				costUsd
+			};
+		},
+		budgetStatus(budget) {
+			const max = budget?.maxCostUsd;
+			if (max === void 0 || costUsd === null) return "ok";
+			if (costUsd >= max) return "exceeded";
+			if (costUsd >= max * WARNING_THRESHOLD) return "warning";
+			return "ok";
+		}
+	};
+}
+//#endregion
+//#region src/receipts/lineage.ts
+const encoder = new TextEncoder();
+const LEAF_DOMAIN = encoder.encode("lattice-lineage-leaf-v1:");
+const NODE_DOMAIN = encoder.encode("lattice-lineage-node-v1:");
+/**
+* Compute a deterministic descriptor-only merkle root for artifact lineage.
+*
+* The root commits to `ArtifactRef` descriptors and nested lineage graphs, not
+* raw artifact values. Returns undefined when no lineage metadata exists.
+*/
+async function computeArtifactLineageMerkleRoot(artifacts) {
+	const leaves = artifacts.filter((artifact) => artifact.lineage !== void 0).map((artifact) => canonicalLineageLeaf(artifact));
+	if (leaves.length === 0) return void 0;
+	let level = (await Promise.all(leaves.map((leaf) => sha256(concatBytes(LEAF_DOMAIN, leaf))))).sort(compareBytes);
+	while (level.length > 1) {
+		const next = [];
+		for (let i = 0; i < level.length; i += 2) {
+			const left = level[i];
+			const right = level[i + 1] ?? left;
+			next.push(await sha256(concatBytes(NODE_DOMAIN, left, right)));
+		}
+		level = next.sort(compareBytes);
+	}
+	return `sha256:${bytesToHex(level[0])}`;
+}
+function canonicalLineageLeaf(artifact) {
+	const json = canonicalize(sanitizeArtifactRef(artifact));
+	if (json === void 0) throw new Error("computeArtifactLineageMerkleRoot: lineage descriptor is not canonicalizable.");
+	return encoder.encode(json);
+}
+function sanitizeArtifactRef(input) {
+	const ref = toArtifactRef(input);
+	return compactObject({
+		id: ref.id,
+		kind: ref.kind,
+		source: ref.source,
+		privacy: ref.privacy,
+		mediaType: ref.mediaType,
+		label: ref.label,
+		metadata: sanitizeUnknown(ref.metadata),
+		size: sanitizeUnknown(ref.size),
+		fingerprint: sanitizeUnknown(ref.fingerprint),
+		storage: sanitizeUnknown(ref.storage),
+		lineage: ref.lineage !== void 0 ? sanitizeLineage(ref.lineage) : void 0
+	});
+}
+function sanitizeLineage(lineage) {
+	return compactObject({
+		parents: lineage.parents.map((parent) => sanitizeArtifactRef(parent)).sort(compareCanonicalJson),
+		transform: compactObject({
+			kind: lineage.transform.kind,
+			name: lineage.transform.name,
+			metadata: sanitizeUnknown(lineage.transform.metadata)
+		})
+	});
+}
+function sanitizeUnknown(value) {
+	if (value === void 0) return void 0;
+	if (value === null) return null;
+	switch (typeof value) {
+		case "string":
+		case "boolean": return value;
+		case "number": return Number.isFinite(value) ? value : void 0;
+		case "bigint": return value.toString();
+		case "object": {
+			if (Array.isArray(value)) return value.map((item) => sanitizeUnknown(item)).filter((item) => item !== void 0);
+			const out = {};
+			for (const key of Object.keys(value).sort()) {
+				const child = sanitizeUnknown(value[key]);
+				if (child !== void 0) out[key] = child;
+			}
+			return out;
+		}
+		default: return;
+	}
+}
+function compactObject(input) {
+	const out = {};
+	for (const key of Object.keys(input).sort()) {
+		const value = input[key];
+		if (value !== void 0) out[key] = value;
+	}
+	return out;
+}
+function compareCanonicalJson(a, b) {
+	const aJson = canonicalize(a) ?? "";
+	const bJson = canonicalize(b) ?? "";
+	return aJson.localeCompare(bJson);
+}
+async function sha256(bytes) {
+	const digest = await crypto.subtle.digest("SHA-256", toArrayBuffer(bytes));
+	return new Uint8Array(digest);
+}
+function concatBytes(...chunks) {
+	const total = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+	const out = new Uint8Array(total);
+	let offset = 0;
+	for (const chunk of chunks) {
+		out.set(chunk, offset);
+		offset += chunk.byteLength;
+	}
+	return out;
+}
+function compareBytes(a, b) {
+	return bytesToHex(a).localeCompare(bytesToHex(b));
+}
+function bytesToHex(bytes) {
+	return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function toArrayBuffer(bytes) {
+	const copy = new Uint8Array(bytes.byteLength);
+	copy.set(bytes);
+	return copy.buffer;
+}
+//#endregion
+//#region src/agent/infra/action-history.ts
+/**
+* ActionHistory — Phase 21 (v1.2).
+*
+* Detects stuck patterns in the agent loop's tool-call sequence:
+*   - "consecutive-identical-tool-call" — same (toolName, argsHash) N+ times in a row
+*   - "ping-pong" — last 4 records alternate between 2 distinct (toolName, argsHash) pairs
+*   - "no-progress" — reserved for callers wiring goal-progress feedback here
+*
+* Standalone (no dependency on the agent runtime); callers register the
+* primitive externally and pump `recordAction` from their loop or hook.
+*/
+const STUCK_REASONS = [
+	"consecutive-identical-tool-call",
+	"no-progress",
+	"ping-pong"
+];
+function actionKey(record) {
+	return `${record.toolName}::${record.argsHash}`;
+}
+function createActionHistory(options = {}) {
+	const consecutiveLimit = options.consecutiveLimit ?? 3;
+	const records = [];
+	return {
+		kind: "action-history",
+		recordAction(action) {
+			records.push(action);
+			if (records.length >= consecutiveLimit) {
+				const tail = records.slice(-consecutiveLimit);
+				const firstKey = actionKey(tail[0]);
+				if (tail.every((r) => actionKey(r) === firstKey)) return "consecutive-identical-tool-call";
+			}
+			if (records.length >= 4) {
+				const keys = records.slice(-4).map(actionKey);
+				if (Array.from(new Set(keys)).length === 2 && keys[0] === keys[2] && keys[1] === keys[3] && keys[0] !== keys[1]) return "ping-pong";
+			}
+			return null;
+		},
+		history() {
+			return Object.freeze([...records]);
+		}
+	};
+}
+//#endregion
+//#region src/agent/crew/dispatcher.ts
+/**
+* Create the crew dispatch chokepoint for one agent spec.
+*
+* `spec` is the agent whose loop this dispatcher serves (its `childAgents`
+* are the dispatchable targets); `ctx` carries every crew-level concern.
+*/
+function createCrewDispatcher(spec, ctx) {
+	return createDispatcherNode(spec, ctx, {
+		exhausted: false,
+		runId: `lattice-crew-${crypto.randomUUID()}`
+	});
+}
+function createDispatcherNode(spec, ctx, shared) {
+	const children = spec.childAgents ?? [];
+	const terminalBlock = /* @__PURE__ */ new Map();
+	const childHost = ctx.sharedPrefix.length > 0 ? {
+		...ctx.childHost,
+		transport: withCachePrefixHoist(ctx.sharedPrefix, ctx.childHost.transport)
+	} : ctx.childHost;
+	async function dispatchToolUse(req, _loopCtx) {
+		const childSpec = children.find((child) => child.id === req.name);
+		if (childSpec === void 0) return;
+		const blocked = terminalBlock.get(childSpec.id);
+		if (blocked !== void 0) return { content: blocked };
+		if (req.name === spec.id || ctx.ancestry.includes(req.name)) return errorResult({
+			kind: "crew-cycle-rejected",
+			reason: `Dispatch of "${req.name}" rejected: the id already appears in the crew ancestry chain (D-05 cycle prevention).`,
+			terminal: false
+		});
+		if (ctx.ancestry.length >= ctx.policy.maxDepth) return errorResult({
+			kind: "crew-depth-exceeded",
+			reason: `Dispatch of "${req.name}" rejected: crew maxDepth ${ctx.policy.maxDepth} reached (ancestry depth ${ctx.ancestry.length}).`,
+			terminal: false
+		});
+		const pool = ctx.remainingBudget();
+		if (isPoolExhausted(pool)) {
+			shared.exhausted = true;
+			return errorResult({
+				kind: "crew-budget-exceeded",
+				reason: "Crew budget pool exhausted — the crew run must end (D-10).",
+				terminal: true
+			});
+		}
+		const task = extractTaskArg(req.args);
+		if (task === null) return errorResult({
+			kind: "invalid-dispatch-args",
+			reason: `Dispatch args for child agent "${childSpec.id}" must be { "task": string }.`,
+			terminal: false
+		});
+		const effectiveBudget = deriveChildBudget(childSpec.contract?.budget, pool, ctx.policy.maxIterationsPerAgent);
+		const childAncestry = [...ctx.ancestry, spec.id];
+		const childNode = childSpec.childAgents !== void 0 && childSpec.childAgents.length > 0 ? createDispatcherNode(childSpec, {
+			...ctx,
+			ancestry: childAncestry
+		}, shared) : void 0;
+		const childResult = await runAgentInternal({
+			task,
+			tools: childNode !== void 0 ? [...childSpec.tools, ...childNode.childToolDeclarations] : childSpec.tools,
+			host: childHost,
+			survivabilityAdapter: withAncestrySnapshot(createNoopSurvivabilityAdapter(), [...childAncestry, childSpec.id]),
+			...effectiveBudget !== void 0 ? { contract: {
+				kind: "capability-contract",
+				budget: effectiveBudget
+			} } : {},
+			...ctx.signer !== void 0 ? { signer: ctx.signer } : {},
+			...ctx.tracer !== void 0 ? { tracer: ctx.tracer } : {},
+			...ctx.pipeline !== void 0 ? { pipeline: ctx.pipeline } : {}
+		}, ctx.config, childNode !== void 0 ? { dispatchToolUse: childNode.dispatchToolUse } : {});
+		ctx.recordUsage(childSpec.id, childResult.usage);
+		ctx.recordAgentResult?.(childSpec.id, childResult);
+		if (childResult.kind !== "success") {
+			const classified = classifyChildFailure(childSpec.id, childResult);
+			const result = errorResult(classified);
+			if (classified.terminal) {
+				terminalBlock.set(childSpec.id, result.content);
+				if (classified.kind === "crew-budget-exceeded") shared.exhausted = true;
+			}
+			return result;
+		}
+		const receipts = [];
+		const childArtifacts = extractArtifacts(childResult);
+		if (ctx.signer !== void 0) try {
+			const lineageMerkleRoot = await computeArtifactLineageMerkleRoot(childArtifacts);
+			const envelope = await createReceipt({
+				runId: shared.runId,
+				model: {
+					requested: "lattice-crew/agent-completion",
+					observed: null
+				},
+				route: {
+					providerId: "lattice-crew",
+					capabilityId: "lattice-crew/agent-completion",
+					attemptNumber: 1
+				},
+				...ctx.crewRootCid !== void 0 ? { parentReceiptCid: ctx.crewRootCid } : {},
+				usage: childResult.usage,
+				...lineageMerkleRoot !== void 0 ? { lineageMerkleRoot } : {},
+				contractVerdict: "success",
+				contractHash: null,
+				inputHashes: [],
+				outputHash: null,
+				stepName: `crew-agent-completion:${childSpec.id}`
+			}, ctx.signer);
+			ctx.mintedReceipts(envelope);
+			receipts.push(await receiptCid(envelope));
+		} catch {}
+		const envelope = {
+			summary: extractSummary(childResult.output),
+			artifacts: childArtifacts,
+			receipts
+		};
+		const validation = await validateSchemaOutput(childSpec.id, childSpec.summaryReturnSchema, envelope);
+		if (!validation.ok) return errorResult({
+			kind: "summary-validation-failed",
+			reason: validation.issue.issues.map((issue) => issue.message).join("; "),
+			terminal: false
+		});
+		return { content: JSON.stringify(envelope) };
+	}
+	return {
+		dispatchToolUse,
+		childToolDeclarations: synthesizeChildDeclarations(children),
+		crewBudgetExhausted: () => shared.exhausted
+	};
+}
+/**
+* Per-dimension `min(spec.contract?.budget, remaining crew pool)` with the
+* iteration dimension additionally capped by `maxIterationsPerAgent`.
+*
+* Cost-dimension min applies ONLY when both sides are numbers — a pool
+* derived from null-cost (unmeasured) usage omits `maxCostUsd`, and even a
+* literal `null` never poisons the arithmetic (Pitfall 4).
+*/
+function deriveChildBudget(specBudget, pool, maxIterationsPerAgent) {
+	const maxIterations = minDefined$1(minDefined$1(specBudget?.maxIterations, pool?.maxIterations), maxIterationsPerAgent);
+	const maxWallTimeMs = minDefined$1(specBudget?.maxWallTimeMs, pool?.maxWallTimeMs);
+	const maxCostUsd = minDefined$1(specBudget?.maxCostUsd, pool?.maxCostUsd);
+	if (maxIterations === void 0 && maxWallTimeMs === void 0 && maxCostUsd === void 0) return;
+	return {
+		...maxIterations !== void 0 ? { maxIterations } : {},
+		...maxWallTimeMs !== void 0 ? { maxWallTimeMs } : {},
+		...maxCostUsd !== void 0 ? { maxCostUsd } : {}
+	};
+}
+/** min() that only applies when BOTH sides are real numbers (Pitfall 4). */
+function minDefined$1(a, b) {
+	const aNum = typeof a === "number" && Number.isFinite(a) ? a : void 0;
+	const bNum = typeof b === "number" && Number.isFinite(b) ? b : void 0;
+	if (aNum !== void 0 && bNum !== void 0) return Math.min(aNum, bNum);
+	return aNum ?? bNum;
+}
+/**
+* Crew-ceiling predicate (D-10): the pool is exhausted when ANY bounded
+* dimension is at/below zero. Null/absent dimensions (unmeasured cost)
+* never count as exhausted (Pitfall 4).
+*/
+function isPoolExhausted(pool) {
+	if (pool === void 0) return false;
+	return typeof pool.maxIterations === "number" && pool.maxIterations <= 0 || typeof pool.maxWallTimeMs === "number" && pool.maxWallTimeMs <= 0 || typeof pool.maxCostUsd === "number" && pool.maxCostUsd <= 0;
+}
+/**
+* Compose the byte-stable crew cache prefix for one tool surface: the
+* `describeForSystem()` block (tool descriptions + envelope instructions),
+* derived from deterministic, version-pinned inputs ONLY — no timestamps,
+* random ids, or unsorted keys (Phase 35 scaffold discipline; any
+* non-byte-stable fragment silently zeroes the cache-hit rate).
+*
+* The 39-06 orchestrator composes this ONCE per crew at crew start and
+* threads it as `CrewDispatchContext.sharedPrefix`. All members sharing a
+* tool surface share byte-identical prefix bytes across dispatches.
+*/
+function composeCrewCachePrefix(tools) {
+	return formatToolsForProvider("lattice-crew", tools).describeForSystem();
+}
+/**
+* Transport wrapper implementing the quirks-gated prefix hoist:
+*
+* - Adapter discloses `quirks.promptCachingSupported === true` (Anthropic
+*   block-granular caching) AND the outgoing task starts with the shared
+*   prefix → the prefix is hoisted to `cacheSystemPrefix` and `task`
+*   carries ONLY the conversation body. The 39-03 byte-equality invariant
+*   (`describeForSystem() + "\n" + buildTaskBody(conv) === buildTask(conv)`)
+*   guarantees the stripped remainder IS the body-only rendering — the
+*   prefix is never duplicated.
+* - Any other adapter → the request passes through UNTOUCHED: no
+*   `cacheSystemPrefix` own-property is ever created (Pitfall 6) and the
+*   prefix stays at the head of `task` (OpenAI automatic token-prefix path).
+*
+* Composes over an existing `AgentTransport` (FSB offscreen bridge etc.);
+* when `inner` is absent it dispatches `provider.execute()` directly,
+* matching the runtime's default transport behavior.
+*/
+function withCachePrefixHoist(sharedPrefix, inner) {
+	const marker = `${sharedPrefix}\n`;
+	return { async call(provider, request) {
+		const outbound = sharedPrefix.length > 0 && supportsPromptCaching(provider) && request.task.startsWith(marker) ? {
+			...request,
+			task: request.task.slice(marker.length),
+			cacheSystemPrefix: sharedPrefix
+		} : request;
+		if (inner !== void 0) return inner.call(provider, outbound);
+		if (provider.execute === void 0) throw new Error(`CrewDispatcher: provider "${provider.id}" has no execute() method.`);
+		return provider.execute(outbound);
+	} };
+}
+/** Quirks gate: only adapters that disclose block-granular prompt caching. */
+function supportsPromptCaching(provider) {
+	return provider.quirks?.promptCachingSupported === true;
+}
+/**
+* Map a child `AgentFailure` to the structured tool-result error body.
+*
+* Terminal (D-10): tripwire violations and contract no-match (the
+* `isTerminal()` kinds in results/errors.ts — the agent loop reuses
+* `no-contract-match` for child cost-budget exhaustion), crew-ceiling
+* breaches, and non-stuck SAFETY-band denials (AgentDeniedError aligns
+* with TripwireViolationError terminal semantics). Recoverable (D-09):
+* iteration/wall-time exhaustion and STUCK_REASONS stalls — the parent
+* MAY re-dispatch.
+*/
+function classifyChildFailure(childId, failure) {
+	return {
+		kind: failure.kind,
+		reason: failure.reason ?? `Child agent "${childId}" failed with kind "${failure.kind}".`,
+		terminal: isTerminalChildFailure(failure)
+	};
+}
+function isTerminalChildFailure(failure) {
+	if (failure.kind === "tripwire-violated" || failure.kind === "no-contract-match" || failure.kind === "crew-budget-exceeded") return true;
+	if (failure.kind === "agent-iteration-denied") {
+		const reason = failure.reason ?? "";
+		return !STUCK_REASONS.some((stuck) => reason.includes(stuck));
+	}
+	return false;
+}
+function errorResult(body) {
+	return { content: JSON.stringify({ error: {
+		kind: body.kind,
+		reason: body.reason,
+		terminal: body.terminal
+	} }) };
+}
+function extractTaskArg(args) {
+	if (typeof args !== "object" || args === null) return null;
+	const task = args["task"];
+	return typeof task === "string" ? task : null;
+}
+function extractSummary(output) {
+	if (typeof output === "object" && output !== null) {
+		const answer = output["answer"];
+		if (typeof answer === "string") return answer;
+	}
+	if (typeof output === "string") return output;
+	try {
+		return JSON.stringify(output);
+	} catch {
+		return String(output);
+	}
+}
+function extractArtifacts(result) {
+	const artifacts = result.artifacts;
+	return Array.isArray(artifacts) ? artifacts.filter(isArtifactRef).map(toArtifactRef) : [];
+}
+/**
+* Wrap a survivability adapter so serialized child snapshots carry the
+* root-first ancestry chain (D-05; AgentSnapshot.ancestry from 39-03).
+* The `agent-snapshot/v1` version literal is unchanged — the field is
+* additive-optional (Pitfall 8).
+*/
+function withAncestrySnapshot(base, ancestry) {
+	return {
+		...base,
+		serialize: (state) => base.serialize({
+			...state,
+			ancestry
+		})
+	};
+}
+function synthesizeChildDeclarations(children) {
+	return children.map((child) => ({
+		kind: "tool",
+		name: child.id,
+		description: `Delegate a task to the "${child.id}" child agent. Agent intent: ${child.intent} Returns a JSON summary envelope { "summary": string, "artifacts": array, "receipts": array } validated against the agent's summaryReturnSchema.`,
+		inputSchema: makeDispatchArgsSchema(child.id),
+		execute: () => {
+			throw new Error(`Child agent "${child.id}" must be dispatched through the CrewDispatcher (kind:"agent" branch) — direct tool execution is forbidden (D-01/D-02).`);
+		}
+	}));
+}
+/**
+* Deterministic `~standard` schema for `{ task: string }` dispatch args.
+* Carries a fixed `toJSONSchema()` so `formatToolsForProvider` renders a
+* meaningful args_schema (byte-stable — no timestamps/random ids; the
+* declarations feed the shared cache prefix).
+*/
+function makeDispatchArgsSchema(childId) {
+	return {
+		"~standard": {
+			version: 1,
+			vendor: "lattice-crew",
+			validate: (value) => {
+				if (typeof value === "object" && value !== null && typeof value["task"] === "string") return { value };
+				return { issues: [{ message: `Dispatch args for child agent "${childId}" must be { "task": string }.` }] };
+			}
+		},
+		toJSONSchema: () => ({
+			type: "object",
+			properties: { task: {
+				type: "string",
+				description: "The task to delegate to this child agent."
+			} },
+			required: ["task"],
+			additionalProperties: false
+		})
+	};
+}
+//#endregion
+//#region src/agent/crew/crew-policy.ts
+/**
+* Validates and normalizes a `CrewPolicy`.
+*
+* - Applies defaults: `maxDepth: 1`, `maxConcurrentChildren: 1`,
+*   `coordination: "managed"`.
+* - Throws `TypeError` when `maxConcurrentChildren > 1` (serial-only v1.3
+*   limit, D-11) or when any structural cap is a non-integer or < 1.
+* - Returns a frozen normalized policy; the input is never mutated.
+*/
+function validateCrewPolicy(policy = {}) {
+	assertStructuralCap("maxConcurrentChildren", policy.maxConcurrentChildren);
+	if (policy.maxConcurrentChildren !== void 0 && policy.maxConcurrentChildren > 1) throw new TypeError("CrewPolicy.maxConcurrentChildren > 1 is not supported in v1.3 — children execute serially (D-11).");
+	assertStructuralCap("maxDepth", policy.maxDepth);
+	assertStructuralCap("maxTotalIterations", policy.maxTotalIterations);
+	assertStructuralCap("maxIterationsPerAgent", policy.maxIterationsPerAgent);
+	return Object.freeze({
+		...policy.budget !== void 0 ? { budget: Object.freeze({ ...policy.budget }) } : {},
+		...policy.maxTotalIterations !== void 0 ? { maxTotalIterations: policy.maxTotalIterations } : {},
+		...policy.maxIterationsPerAgent !== void 0 ? { maxIterationsPerAgent: policy.maxIterationsPerAgent } : {},
+		maxConcurrentChildren: policy.maxConcurrentChildren ?? 1,
+		maxDepth: policy.maxDepth ?? 1,
+		...policy.limits !== void 0 ? { limits: Object.freeze(Object.fromEntries(Object.entries(policy.limits).map(([adapterId, override]) => [adapterId, Object.freeze({ ...override })]))) } : {},
+		coordination: policy.coordination ?? "managed"
+	});
+}
+function assertStructuralCap(field, value) {
+	if (value === void 0) return;
+	if (!Number.isInteger(value) || value < 1) throw new TypeError(`CrewPolicy.${field} must be a positive integer (>= 1); received ${String(value)}.`);
+}
+//#endregion
+//#region src/agent/infra/rate-limit-group.ts
+/** Anthropic Tier 1 requests/minute (fetched 2026-06-10). */
+const DEFAULT_REQUESTS_PER_MINUTE = 50;
+/** Anthropic Tier 1 input tokens/minute, Sonnet-class (fetched 2026-06-10). */
+const DEFAULT_TOKENS_PER_MINUTE = 3e4;
+const MS_PER_MINUTE = 6e4;
+/**
+* Absorbs floating-point drift in two places: bucket-level comparisons
+* (`available >= need`) and deficit-wait rounding. 1e-6 of a token/request
+* (or millisecond) is far above accumulated IEEE-754 error at these
+* magnitudes and far below anything rate-limit-relevant.
+*/
+const FLOAT_EPSILON = 1e-6;
+function createBucket(perMinute, label) {
+	if (!Number.isFinite(perMinute) || perMinute <= 0) throw new TypeError(`createRateLimitGroup: ${label} must be a positive finite number, got ${perMinute}.`);
+	return {
+		available: perMinute,
+		capacity: perMinute,
+		perMsRate: perMinute / MS_PER_MINUTE
+	};
+}
+function createRateLimitGroup(options = {}) {
+	const now = options.now ?? Date.now;
+	const requests = createBucket(options.requestsPerMinute ?? DEFAULT_REQUESTS_PER_MINUTE, "requestsPerMinute");
+	const tokens = createBucket(options.tokensPerMinute ?? DEFAULT_TOKENS_PER_MINUTE, "tokensPerMinute");
+	let lastRefillAt = now();
+	const waiters = [];
+	let timer = null;
+	/** Lazy continuous refill from the clock delta — never a recurring timer. */
+	function refill() {
+		const t = now();
+		const elapsed = t - lastRefillAt;
+		if (elapsed <= 0) return;
+		lastRefillAt = t;
+		requests.available = Math.min(requests.capacity, requests.available + elapsed * requests.perMsRate);
+		tokens.available = Math.min(tokens.capacity, tokens.available + elapsed * tokens.perMsRate);
+	}
+	/**
+	* Token requirement for availability checks, clamped to capacity so an
+	* oversized estimate (> bucket capacity) proceeds at full bucket instead
+	* of deadlocking; the full amount is still debited (the bucket goes into
+	* debt and recovers via drain).
+	*/
+	function tokenNeed(inputTokens) {
+		return Math.min(inputTokens, tokens.capacity);
+	}
+	function tryDebit(inputTokens) {
+		if (requests.available + FLOAT_EPSILON >= 1 && tokens.available + FLOAT_EPSILON >= tokenNeed(inputTokens)) {
+			requests.available -= 1;
+			tokens.available -= inputTokens;
+			return true;
+		}
+		return false;
+	}
+	/** Exact wait (ms) until both dimensions can cover the head waiter. */
+	function deficitWaitMs(inputTokens) {
+		const requestDeficit = Math.max(0, 1 - requests.available);
+		const tokenDeficit = Math.max(0, tokenNeed(inputTokens) - tokens.available);
+		const requestWait = requestDeficit / requests.perMsRate;
+		const tokenWait = tokenDeficit / tokens.perMsRate;
+		return Math.max(requestWait, tokenWait);
+	}
+	function scheduleNext() {
+		if (timer !== null) return;
+		const head = waiters[0];
+		if (head === void 0) return;
+		const waitMs = Math.max(1, Math.ceil(deficitWaitMs(head.inputTokens) - FLOAT_EPSILON));
+		timer = setTimeout(() => {
+			timer = null;
+			pump();
+		}, waitMs);
+	}
+	/** Refill, resolve as many FIFO waiters as capacity allows, reschedule. */
+	function pump() {
+		if (timer !== null) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		refill();
+		while (waiters.length > 0) {
+			const head = waiters[0];
+			if (head === void 0 || !tryDebit(head.inputTokens)) break;
+			waiters.shift();
+			head.resolve(createLease(head.inputTokens));
+		}
+		scheduleNext();
+	}
+	function createLease(estimateTokens) {
+		let released = false;
+		return { release(actual) {
+			if (released) return;
+			released = true;
+			refill();
+			const actualTokens = typeof actual.promptTokens === "number" && Number.isFinite(actual.promptTokens) ? actual.promptTokens : estimateTokens;
+			tokens.available = Math.min(tokens.capacity, tokens.available + (estimateTokens - actualTokens));
+			pump();
+		} };
+	}
+	return {
+		kind: "rate-limit-group",
+		async acquire(estimate) {
+			refill();
+			if (waiters.length === 0 && tryDebit(estimate.inputTokens)) return createLease(estimate.inputTokens);
+			return new Promise((resolve) => {
+				waiters.push({
+					inputTokens: estimate.inputTokens,
+					resolve
+				});
+				scheduleNext();
+			});
+		}
+	};
+}
+/**
+* chars/4 heuristic for lease reservation (matches the transcript-store
+* default `TokenEstimator`). Persistent estimation error is benign: `release`
+* reconciles every lease against the actual `Usage.promptTokens` (A2).
+*/
+function estimateInputTokens(task) {
+	return Math.ceil(task.length / 4);
+}
+/**
+* Wrap an `AgentTransport` so every provider call is gated through `group`.
+*
+* Every transport wrapped with the SAME group instance shares one bucket —
+* `runAgentCrew` (39-06) wraps parent + child hosts with one shared group per
+* adapter instance, structurally guaranteeing crew-wide coordination (D-13).
+* `ProviderAdapter` is never modified (INV-03 parity invariant intact).
+*
+* - `inner` provided → dispatch nests through `inner.call(provider, request)`,
+*   composing with consumer transports (e.g. cross-process bridges).
+* - `inner` undefined → falls through to `provider.execute(request)`, guarded
+*   the same way as `createNoopAgentHost` (error names the provider id only).
+*
+* Release policy:
+* - Success → release with `normalizedUsage.promptTokens`; when usage is
+*   missing or non-finite, fall back to the estimate (no NaN arithmetic —
+*   the `costUsd: null` "unmeasured" discipline analog).
+* - Throw → release with the ORIGINAL estimate (burn — no refund; the
+*   provider may have consumed quota despite the error) and rethrow the
+*   same error unchanged. Request objects and headers are never serialized
+*   into error paths.
+*/
+function withRateLimit(group, inner) {
+	return { async call(provider, request) {
+		const estimate = estimateInputTokens(request.task);
+		const lease = await group.acquire({ inputTokens: estimate });
+		try {
+			let response;
+			if (inner !== void 0) response = await inner.call(provider, request);
+			else {
+				if (provider.execute === void 0) throw new Error(`AgentTransport: provider ${provider.id} has no execute() method.`);
+				response = await provider.execute(request);
+			}
+			const actual = response.normalizedUsage?.promptTokens;
+			lease.release({ promptTokens: typeof actual === "number" && Number.isFinite(actual) ? actual : estimate });
+			return response;
+		} catch (error) {
+			lease.release({ promptTokens: estimate });
+			throw error;
+		}
+	} };
+}
+//#endregion
+//#region src/agent/crew/run-crew.ts
+var run_crew_exports = /* @__PURE__ */ __exportAll({ runAgentCrew: () => runAgentCrew });
+const ZERO_USAGE = {
+	promptTokens: 0,
+	completionTokens: 0,
+	costUsd: null
+};
+/**
+* Execute a crew rooted at `options.root`.
+*/
+async function runAgentCrew(options, config = {}) {
+	const policy = validateCrewPolicy(options.policy);
+	const runId = `runAgentCrew-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+	const startedAt = Date.now();
+	const accounting = /* @__PURE__ */ new Map();
+	const receipts = [];
+	const receiptCidsByAgent = /* @__PURE__ */ new Map();
+	const crewRoot = await maybeMintCrewRoot({
+		runId,
+		root: options.root,
+		...options.signer !== void 0 ? { signer: options.signer } : {}
+	});
+	if (crewRoot !== void 0) receipts.push(crewRoot.envelope);
+	const groupForProvider = createRateLimitGroupResolver(policy);
+	const childHost = wrapHostWithRateLimits(options.hosts.childHost, groupForProvider);
+	function recordUsage(agentId, usage) {
+		entryFor(accounting, agentId).tracker.recordIteration(usage);
+	}
+	function recordAgentResult(agentId, result) {
+		const entry = entryFor(accounting, agentId);
+		entry.iterations += result.iterations.length;
+	}
+	function remainingBudget() {
+		return deriveRemainingBudget({
+			policy,
+			usage: totalUsage(accounting),
+			iterations: totalIterations(accounting),
+			startedAt
+		});
+	}
+	const dispatcher = createCrewDispatcher(options.root, {
+		policy,
+		childHost,
+		ancestry: [],
+		recordUsage,
+		recordAgentResult,
+		remainingBudget,
+		sharedPrefix: composeSharedPrefix(options.root),
+		mintedReceipts(envelope) {
+			receipts.push(envelope);
+		},
+		config,
+		...crewRoot !== void 0 ? { crewRootCid: crewRoot.cid } : {},
+		...options.signer !== void 0 ? { signer: options.signer } : {},
+		...options.tracer !== void 0 ? { tracer: options.tracer } : {},
+		...options.pipeline !== void 0 ? { pipeline: options.pipeline } : {}
+	});
+	const parentResult = await runAgentInternal({
+		task: options.root.intent,
+		tools: [...options.root.tools, ...dispatcher.childToolDeclarations],
+		host: wrapHostWithRateLimits(createNoopAgentHost(), groupForProvider),
+		...options.root.contract !== void 0 ? { contract: options.root.contract } : {},
+		...options.signer !== void 0 ? { signer: options.signer } : {},
+		...options.tracer !== void 0 ? { tracer: options.tracer } : {},
+		...options.pipeline !== void 0 ? { pipeline: options.pipeline } : {}
+	}, config, { dispatchToolUse: dispatcher.dispatchToolUse });
+	recordUsage(options.root.id, parentResult.usage);
+	recordAgentResult(options.root.id, parentResult);
+	if (options.signer !== void 0 && crewRoot !== void 0) {
+		const parentEnvelope = await createAgentCompletionReceipt({
+			runId,
+			agentId: options.root.id,
+			usage: parentResult.usage,
+			signer: options.signer,
+			parentReceiptCid: crewRoot.cid,
+			success: parentResult.kind === "success",
+			artifacts: parentResult.kind === "success" ? parentResult.artifacts ?? [] : []
+		});
+		receipts.push(parentEnvelope);
+	}
+	await populateReceiptCidIndex(receipts, receiptCidsByAgent);
+	return freezeCrewResult({
+		result: dispatcher.crewBudgetExhausted() || crewBudgetViolated({
+			policy,
+			usage: totalUsage(accounting),
+			iterations: totalIterations(accounting),
+			startedAt
+		}) ? buildCrewBudgetFailure(parentResult) : parentResult,
+		perAgent: buildPerAgent(accounting, receiptCidsByAgent),
+		usage: totalUsage(accounting),
+		totalIterations: totalIterations(accounting),
+		receipts,
+		...crewRoot !== void 0 ? { crewRootCid: crewRoot.cid } : {}
+	});
+}
+function entryFor(accounting, agentId) {
+	let entry = accounting.get(agentId);
+	if (entry === void 0) {
+		entry = {
+			tracker: createCostTracker(),
+			iterations: 0
+		};
+		accounting.set(agentId, entry);
+	}
+	return entry;
+}
+function totalUsage(accounting) {
+	const total = {
+		promptTokens: 0,
+		completionTokens: 0,
+		costUsd: null
+	};
+	for (const entry of accounting.values()) accumulate(total, entry.tracker.total());
+	return snapshot(total);
+}
+function totalIterations(accounting) {
+	let total = 0;
+	for (const entry of accounting.values()) total += entry.iterations;
+	return total;
+}
+function accumulate(total, usage) {
+	total.promptTokens += usage.promptTokens;
+	total.completionTokens += usage.completionTokens;
+	if (usage.costUsd !== null) total.costUsd = (total.costUsd ?? 0) + usage.costUsd;
+}
+function snapshot(usage) {
+	return {
+		promptTokens: usage.promptTokens,
+		completionTokens: usage.completionTokens,
+		costUsd: usage.costUsd
+	};
+}
+function deriveRemainingBudget(input) {
+	const remaining = {};
+	const budget = input.policy.budget;
+	const iterationCeiling = minDefined(budget?.maxIterations, input.policy.maxTotalIterations);
+	if (iterationCeiling !== void 0) remaining.maxIterations = iterationCeiling - input.iterations;
+	if (budget?.maxWallTimeMs !== void 0) remaining.maxWallTimeMs = budget.maxWallTimeMs - (Date.now() - input.startedAt);
+	if (budget?.maxCostUsd !== void 0 && input.usage.costUsd !== null) remaining.maxCostUsd = budget.maxCostUsd - input.usage.costUsd;
+	else if (budget?.maxCostUsd !== void 0 && input.usage.costUsd === null) remaining.maxCostUsd = budget.maxCostUsd;
+	if (budget?.p95LatencyMs !== void 0) remaining.p95LatencyMs = budget.p95LatencyMs;
+	return Object.keys(remaining).length > 0 ? remaining : void 0;
+}
+function crewBudgetViolated(input) {
+	const iterationCeiling = minDefined(input.policy.budget?.maxIterations, input.policy.maxTotalIterations);
+	if (iterationCeiling !== void 0 && input.iterations > iterationCeiling) return true;
+	const maxWallTimeMs = input.policy.budget?.maxWallTimeMs;
+	if (maxWallTimeMs !== void 0 && Date.now() - input.startedAt > maxWallTimeMs) return true;
+	const maxCostUsd = input.policy.budget?.maxCostUsd;
+	return maxCostUsd !== void 0 && input.usage.costUsd !== null && input.usage.costUsd > maxCostUsd;
+}
+function minDefined(a, b) {
+	if (a !== void 0 && b !== void 0) return Math.min(a, b);
+	return a ?? b;
+}
+function createRateLimitGroupResolver(policy) {
+	if (policy.coordination === "unmanaged") return () => void 0;
+	const groups = /* @__PURE__ */ new Map();
+	return (provider) => {
+		let group = groups.get(provider);
+		if (group === void 0) {
+			group = createRateLimitGroup(rateLimitOptionsFor(policy, provider));
+			groups.set(provider, group);
+		}
+		return group;
+	};
+}
+function rateLimitOptionsFor(policy, provider) {
+	const override = policy.limits?.[provider.id];
+	return {
+		...override?.requestsPerMinute !== void 0 ? { requestsPerMinute: override.requestsPerMinute } : {},
+		...override?.tokensPerMinute !== void 0 ? { tokensPerMinute: override.tokensPerMinute } : {}
+	};
+}
+function wrapHostWithRateLimits(host, groupForProvider) {
+	return {
+		...host,
+		transport: wrapTransport(host.transport, groupForProvider)
+	};
+}
+function wrapTransport(inner, groupForProvider) {
+	return { call(provider, request) {
+		const group = groupForProvider(provider);
+		if (group !== void 0) return withRateLimit(group, inner).call(provider, request);
+		if (inner !== void 0) return inner.call(provider, request);
+		if (provider.execute === void 0) throw new Error(`AgentTransport: provider ${provider.id} has no execute() method.`);
+		return provider.execute(request);
+	} };
+}
+function composeSharedPrefix(root) {
+	const firstChild = root.childAgents?.[0];
+	return composeCrewCachePrefix(firstChild?.tools ?? root.tools);
+}
+async function maybeMintCrewRoot(input) {
+	if (input.signer === void 0) return void 0;
+	const envelope = await createReceipt({
+		runId: input.runId,
+		model: {
+			requested: "lattice-crew/root",
+			observed: null
+		},
+		route: {
+			providerId: "lattice-crew",
+			capabilityId: "lattice-crew/run",
+			attemptNumber: 1
+		},
+		usage: ZERO_USAGE,
+		contractVerdict: "success",
+		contractHash: null,
+		inputHashes: [],
+		outputHash: null,
+		stepName: `crew-start:${input.root.id}`
+	}, input.signer);
+	return {
+		envelope,
+		cid: await receiptCid(envelope)
+	};
+}
+async function createAgentCompletionReceipt(input) {
+	const lineageMerkleRoot = await computeArtifactLineageMerkleRoot(input.artifacts ?? []);
+	return createReceipt({
+		runId: input.runId,
+		model: {
+			requested: "lattice-crew/agent-completion",
+			observed: null
+		},
+		route: {
+			providerId: "lattice-crew",
+			capabilityId: "lattice-crew/agent-completion",
+			attemptNumber: 1
+		},
+		parentReceiptCid: input.parentReceiptCid,
+		...lineageMerkleRoot !== void 0 ? { lineageMerkleRoot } : {},
+		usage: input.usage,
+		contractVerdict: input.success ? "success" : "execution-failed",
+		contractHash: null,
+		inputHashes: [],
+		outputHash: null,
+		stepName: `crew-agent-completion:${input.agentId}`
+	}, input.signer);
+}
+async function populateReceiptCidIndex(receipts, byAgent) {
+	for (const envelope of receipts) {
+		const agentId = parseCompletionAgentId(decodeReceiptBody(envelope).stepName);
+		if (agentId === null) continue;
+		const cids = byAgent.get(agentId) ?? [];
+		cids.push(await receiptCid(envelope));
+		byAgent.set(agentId, cids);
+	}
+}
+function decodeReceiptBody(envelope) {
+	return JSON.parse(atob(envelope.payload));
+}
+function parseCompletionAgentId(stepName) {
+	if (stepName?.startsWith("crew-agent-completion:") !== true) return null;
+	return stepName.slice(22);
+}
+function buildPerAgent(accounting, receiptCidsByAgent) {
+	return Object.freeze(Array.from(accounting.entries(), ([id, entry]) => Object.freeze({
+		id,
+		usage: Object.freeze(entry.tracker.total()),
+		iterations: entry.iterations,
+		receiptCids: Object.freeze([...receiptCidsByAgent.get(id) ?? []])
+	})));
+}
+function freezeCrewResult(result) {
+	return Object.freeze({
+		result: result.result,
+		perAgent: Object.freeze([...result.perAgent]),
+		usage: Object.freeze({ ...result.usage }),
+		totalIterations: result.totalIterations,
+		receipts: Object.freeze([...result.receipts]),
+		...result.crewRootCid !== void 0 ? { crewRootCid: result.crewRootCid } : {}
+	});
+}
+function buildCrewBudgetFailure(parentResult) {
+	return {
+		kind: "crew-budget-exceeded",
+		reason: "Crew budget pool exhausted — the crew run ended with terminal semantics.",
+		usage: parentResult.usage,
+		iterations: Object.freeze([...parentResult.iterations]),
+		...parentResult.receipt !== void 0 ? { receipt: parentResult.receipt } : {}
+	};
+}
+//#endregion
+export { STUCK_REASONS as a, createCostTracker as c, withRateLimit as i, receiptCid as l, run_crew_exports as n, createActionHistory as o, createRateLimitGroup as r, computeArtifactLineageMerkleRoot as s, runAgentCrew as t };
+
+//# sourceMappingURL=run-crew-CKdBjh5P.js.map