spawnfile 0.1.13 → 0.1.17

package/dist/compiler/upProjectHandoff.js

@@ -0,0 +1,204 @@
+import { createHash } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { createDockerOrganizationHandoffSession, initializeOrganizationHandoffAuthorityStore, parseCanonicalSha256Digest, } from "../deployment/index.js";
+import { createCanonicalSelectedTargetReceiptBytes, parseOpaqueTargetHandle, parseRunId, parseSelectedTargetReceipt, selectTarget, } from "../target/index.js";
+import { isTrustedUpLifecycleRecovery } from "../deployment/upLifecycleRecoveryState.js";
+import { SpawnfileError } from "../shared/index.js";
+import { executeDockerRunWithSupportCleanup } from "./runProjectLifecycle.js";
+import { recoverDetachedDockerRun, } from "./runProject.js";
+export const organizationHandoffInputError = () => new SpawnfileError("validation_error", "Organization handoff requires authorized run id, selected target receipt, descriptor digest, selected target receipt digest, network attachment handle, and world bindings");
+const recoveryError = () => new SpawnfileError("runtime_error", "Organization handoff recovery is incomplete; redeploy with explicit authorization");
+export const resolveRequestedOrganizationHandoff = (options) => {
+    const values = [
+        options.descriptorDigest,
+        options.organizationHandoffRunId,
+        options.selectedTargetReceiptDigest,
+        options.selectedTargetReceipt,
+        options.networkAttachmentHandle,
+        options.worldBindingsPath,
+    ];
+    if (values.every((value) => value === undefined))
+        return null;
+    if (values.some((value) => value === undefined) || !options.detach)
+        throw organizationHandoffInputError();
+    try {
+        const selectedTarget = parseSelectedTargetReceipt(options.selectedTargetReceipt);
+        const selectedDigest = parseCanonicalSha256Digest(options.selectedTargetReceiptDigest, "selected_target_receipt_digest");
+        const computedDigest = `sha256:${createHash("sha256").update(createCanonicalSelectedTargetReceiptBytes(selectedTarget), "utf8").digest("hex")}`;
+        if (selectedDigest !== computedDigest)
+            throw new Error("selected receipt digest mismatch");
+        return {
+            descriptorDigest: parseCanonicalSha256Digest(options.descriptorDigest, "descriptor_digest"),
+            runId: parseRunId(options.organizationHandoffRunId),
+            networkAttachmentHandle: parseOpaqueTargetHandle(options.networkAttachmentHandle),
+            selectedTarget,
+            selectedTargetReceiptDigest: selectedDigest,
+        };
+    }
+    catch {
+        throw organizationHandoffInputError();
+    }
+};
+export const verifyRequestedOrganizationHandoffTarget = async (requested, resolved, options) => {
+    if (!requested)
+        return;
+    if (typeof resolved.dockerContext !== "string" || resolved.dockerContext.length === 0
+        || resolved.dockerHost != null || process.env.DOCKER_HOST != null)
+        throw organizationHandoffInputError();
+    try {
+        const actual = await selectTarget({
+            context: resolved.dockerContext,
+            dockerCommand: options.dockerCommand,
+            execFile: options.targetExecFile,
+        });
+        if (createCanonicalSelectedTargetReceiptBytes(actual)
+            !== createCanonicalSelectedTargetReceiptBytes(requested.selectedTarget))
+            throw new Error("target mismatch");
+    }
+    catch {
+        throw organizationHandoffInputError();
+    }
+};
+export const compileOrganizationHandoff = (requested, buildResult) => {
+    if (!requested)
+        return undefined;
+    try {
+        const bindingDigest = buildResult.organizationReadinessEvidence.worldBindings?.digest;
+        if (!bindingDigest)
+            throw new Error("missing compiled binding evidence");
+        const parsedBindingDigest = parseCanonicalSha256Digest(bindingDigest, "binding_digest");
+        return {
+            authority: { ...requested, bindingDigest: parsedBindingDigest },
+            organizationHandoff: {
+                bindingDigest: parsedBindingDigest,
+                networkAttachmentHandle: requested.networkAttachmentHandle,
+                selectedTargetReceiptDigest: requested.selectedTargetReceiptDigest,
+            },
+        };
+    }
+    catch {
+        throw organizationHandoffInputError();
+    }
+};
+const canonical = (value) => value === null || typeof value !== "object"
+    ? JSON.stringify(value)
+    : Array.isArray(value) ? `[${value.map(canonical).join(",")}]`
+        : `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`).join(",")}}`;
+const same = (left, right) => canonical(left) === canonical(right);
+const exactRunMetadata = (value) => {
+    if (!value?.containerId || !value.containerName || !value.imageId || !value.deploymentLabels) {
+        throw organizationHandoffInputError();
+    }
+    return value;
+};
+const reattestRecoveredRun = async (invocation, expected) => {
+    const actual = exactRunMetadata(await recoverDetachedDockerRun(invocation, expected.containerId));
+    if (actual.containerName !== expected.containerName || actual.imageId !== expected.imageId
+        || !same(actual.deploymentLabels, expected.deploymentLabels))
+        throw recoveryError();
+    return actual;
+};
+const recovery = (value) => {
+    if (value !== undefined && !isTrustedUpLifecycleRecovery(value))
+        throw organizationHandoffInputError();
+    return value;
+};
+const reserveDetachedRun = async (invocation, reserve) => {
+    if (!reserve)
+        return;
+    if (!invocation.detach || !invocation.containerName || !invocation.deploymentLabels) {
+        throw new SpawnfileError("runtime_error", "Detached deployment authority is incomplete");
+    }
+    await reserve({
+        containerName: invocation.containerName,
+        deploymentLabels: invocation.deploymentLabels,
+        dockerCommand: invocation.command,
+        dockerContext: invocation.dockerContext ?? null,
+    });
+};
+/** Resumes only lifecycle-verified state, never stale authority observations. */
+export const executeOrganizationHandoff = async (input) => {
+    const { handoff, invocation } = input;
+    if (!invocation.deploymentLabels || !invocation.containerName)
+        throw organizationHandoffInputError();
+    const lifecycleRecovery = recovery(input.lifecycleRecovery);
+    const session = createDockerOrganizationHandoffSession({
+        bindingDigest: handoff.authority.bindingDigest,
+        containerName: invocation.containerName,
+        deploymentLabels: invocation.deploymentLabels,
+        descriptorDigest: handoff.authority.descriptorDigest,
+        organizationHandoff: handoff.organizationHandoff,
+        runId: handoff.authority.runId,
+        selectedTarget: handoff.authority.selectedTarget,
+        selectedTargetReceiptDigest: handoff.authority.selectedTargetReceiptDigest,
+    });
+    let authority;
+    let dockerLifecycleInvoked = false;
+    try {
+        // Persist the lifecycle reservation first. A post-begin crash can then be
+        // distinguished as no-start, exact-container, or ambiguous on restart.
+        if (lifecycleRecovery?.kind !== "deployment_record") {
+            await reserveDetachedRun(invocation, input.onDetachedReservation);
+        }
+        authority = await initializeOrganizationHandoffAuthorityStore();
+        const begun = await authority.begin(session.authorityInput);
+        let runMetadata;
+        if (begun.created) {
+            if (lifecycleRecovery?.kind === "detached_container"
+                || lifecycleRecovery?.kind === "deployment_record")
+                throw recoveryError();
+            dockerLifecycleInvoked = true;
+            runMetadata = exactRunMetadata(await executeDockerRunWithSupportCleanup(invocation, input.runRunner));
+        }
+        else {
+            const observed = await authority.readDockerMutation(begun.pending.pending_key);
+            if (observed) {
+                if (lifecycleRecovery?.kind === "no_docker_mutation")
+                    throw recoveryError();
+                const expected = {
+                    containerId: observed.container_id,
+                    containerName: invocation.containerName,
+                    deploymentLabels: observed.deployment_labels,
+                    imageId: observed.image_id,
+                };
+                if (lifecycleRecovery?.kind === "detached_container" && (lifecycleRecovery.containerId !== expected.containerId
+                    || lifecycleRecovery.containerName !== expected.containerName
+                    || lifecycleRecovery.imageId !== expected.imageId
+                    || !same(lifecycleRecovery.deploymentLabels, expected.deploymentLabels)))
+                    throw recoveryError();
+                runMetadata = await reattestRecoveredRun(invocation, expected);
+            }
+            else if (lifecycleRecovery?.kind === "detached_container") {
+                runMetadata = await reattestRecoveredRun(invocation, lifecycleRecovery);
+            }
+            else if (lifecycleRecovery?.kind === "no_docker_mutation") {
+                dockerLifecycleInvoked = true;
+                runMetadata = exactRunMetadata(await executeDockerRunWithSupportCleanup(invocation, input.runRunner));
+            }
+            else
+                throw recoveryError();
+        }
+        await authority.observeDockerMutation(begun.pending.pending_key, runMetadata);
+        const finalized = await authority.finalize(begun.pending.pending_key, runMetadata);
+        return { organizationHandoffHandle: finalized.organization_handoff_handle, runMetadata };
+    }
+    finally {
+        let cleanupError;
+        try {
+            if (invocation.detach && !dockerLifecycleInvoked)
+                await rm(invocation.envFilePath, { force: true });
+        }
+        catch (error) {
+            cleanupError = error;
+        }
+        try {
+            await authority?.dispose();
+        }
+        catch (error) {
+            if (cleanupError === undefined)
+                throw error;
+        }
+        if (cleanupError !== undefined)
+            throw cleanupError;
+    }
+};

package/dist/compiler/upReceipt.d.ts

@@ -0,0 +1,36 @@
+import { type CompiledEngineEntry, type CompiledScheduleEntry, type UpReceipt } from "../deployment/index.js";
+import type { CompilePlan } from "./types.js";
+import type { UpProjectResult } from "./upProject.js";
+/**
+ * Extracts the `{agent, cron}` pairs an up-receipt's `compiled_schedule` field carries
+ * (Decision 21 Piece 4) — the raw material for simfile's wake-diff denominator oracle.
+ * Only `kind: "cron"` schedules are represented; `every`/`disabled` schedules have no
+ * cron-fire cadence to diff against sim-time and are intentionally omitted, not zeroed.
+ */
+export declare const resolveCompiledSchedule: (plan: CompilePlan) => CompiledScheduleEntry[];
+/**
+ * Extracts `{agent, engine}` pairs (Piece 5, Slice B) — disclosure ground truth for the
+ * run-manifest's `pinned-engine` field, so a `scripted` (or any non-default) pi engine is
+ * visibly disclosed rather than an invisible test-only branch. Reads
+ * `report.container.runtime_instances[].engine_by_node_id`, the single source of truth
+ * `containerArtifacts.ts` already stamps from the pi adapter's own resolved engine kinds
+ * (see `src/runtime/pi/adapter.ts`'s `createContainerTargets`) — deliberately not
+ * re-derived from a fresh `buildCompilePlan` walk (unlike `resolveCompiledSchedule` above),
+ * since that would recompute the exact same fact from pi-adapter-internal logic
+ * (`resolvePiEngine`) that compiler code has no business reaching into directly.
+ */
+export declare const resolveCompiledEngines: (report: UpProjectResult["report"]) => CompiledEngineEntry[];
+/**
+ * Builds `spawnfile.up-receipt.v1` from a project-path `upProject()` result. Reads back
+ * the deployment record `upProject` already wrote (for `run_id`/deployment name/container
+ * id — the same record `spawnfile artifacts export`/`spawnfile down` resolve), and
+ * re-derives `compiled_schedule` from the resolved graph, since `compileProject` does not
+ * retain its own `CompilePlan` past the compile step.
+ *
+ * `readiness` reuses whatever signal `upProject` already has — a bare `docker run -d`
+ * that returned a container id, not a new health probe: `up` has never polled
+ * application-level readiness, and this receipt does not invent one. `moltnet_base_url`
+ * comes straight from the compiled container report's own managed/external server plan;
+ * no credentials ever land on this contract (contracts.md).
+ */
+export declare const buildUpReceipt: (inputPath: string, result: UpProjectResult) => Promise<UpReceipt>;

package/dist/compiler/upReceipt.js

@@ -0,0 +1,127 @@
+import { readDeploymentRecord, UP_RECEIPT_VERSION } from "../deployment/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { buildCompilePlan } from "./buildCompilePlan.js";
+/**
+ * Extracts the `{agent, cron}` pairs an up-receipt's `compiled_schedule` field carries
+ * (Decision 21 Piece 4) — the raw material for simfile's wake-diff denominator oracle.
+ * Only `kind: "cron"` schedules are represented; `every`/`disabled` schedules have no
+ * cron-fire cadence to diff against sim-time and are intentionally omitted, not zeroed.
+ */
+export const resolveCompiledSchedule = (plan) => plan.nodes
+    .filter((node) => node.kind === "agent")
+    .flatMap((node) => {
+    const schedule = node.value.schedule;
+    return schedule?.kind === "cron" ? [{ agent: node.id, cron: schedule.cron }] : [];
+})
+    .sort((left, right) => left.agent.localeCompare(right.agent));
+/**
+ * Extracts `{agent, engine}` pairs (Piece 5, Slice B) — disclosure ground truth for the
+ * run-manifest's `pinned-engine` field, so a `scripted` (or any non-default) pi engine is
+ * visibly disclosed rather than an invisible test-only branch. Reads
+ * `report.container.runtime_instances[].engine_by_node_id`, the single source of truth
+ * `containerArtifacts.ts` already stamps from the pi adapter's own resolved engine kinds
+ * (see `src/runtime/pi/adapter.ts`'s `createContainerTargets`) — deliberately not
+ * re-derived from a fresh `buildCompilePlan` walk (unlike `resolveCompiledSchedule` above),
+ * since that would recompute the exact same fact from pi-adapter-internal logic
+ * (`resolvePiEngine`) that compiler code has no business reaching into directly.
+ */
+export const resolveCompiledEngines = (report) => (report.container?.runtime_instances ?? [])
+    .flatMap((instance) => Object.entries(instance.engine_by_node_id ?? {}))
+    .map(([agent, engine]) => ({ agent, engine }))
+    .sort((left, right) => left.agent.localeCompare(right.agent));
+const createReceiptMoltnetIdentity = (release) => {
+    if (!release)
+        return undefined;
+    // Discriminate on PROVENANCE, never on capability count. A published release
+    // now advertises `daimon-bridge` too (moltnet v0.1.18), so `length === 1` would
+    // route it into the local-development branch and reject it for lacking a
+    // `development` marker it is never supposed to have.
+    //
+    // The canonical list lives in `moltnetReleaseAuthority.ts`, but the H2 boundary
+    // (`../deployment/organizationHandoffTypes.test.ts`) forbids this file from
+    // importing any `moltnet*` module, so the ordering is compared inline here the
+    // same way the local branch below already compares it. `upReceiptTypes.ts`'s
+    // schema is the authority that rejects any other list on parse.
+    const joined = release.capabilities.join("\0");
+    const receiptCapabilities = joined === "daimon-bridge\0pi-bridge"
+        ? ["daimon-bridge", "pi-bridge"]
+        : joined === "pi-bridge" ? ["pi-bridge"] : null;
+    if (receiptCapabilities === null) {
+        throw new SpawnfileError("runtime_error", "Moltnet receipt advertises unknown bridge capabilities");
+    }
+    if (!release.development) {
+        if (!release.release_version || !release.source_revision) {
+            throw new SpawnfileError("runtime_error", "Published Moltnet receipt lacks its pinned source identity");
+        }
+        return {
+            architecture: release.architecture,
+            asset: release.asset,
+            asset_sha256: release.asset_sha256,
+            capabilities: receiptCapabilities,
+            release_version: release.release_version,
+            source_revision: release.source_revision,
+            version: release.version
+        };
+    }
+    if (release.capabilities.join("\0") !== "daimon-bridge\0pi-bridge" ||
+        !release.source_sha256) {
+        throw new SpawnfileError("runtime_error", "Local Moltnet receipt lacks its development provenance");
+    }
+    return {
+        architecture: release.architecture,
+        asset: release.asset,
+        asset_sha256: release.asset_sha256,
+        capabilities: ["daimon-bridge", "pi-bridge"],
+        development: release.development,
+        source_sha256: release.source_sha256,
+        version: release.version
+    };
+};
+/**
+ * Builds `spawnfile.up-receipt.v1` from a project-path `upProject()` result. Reads back
+ * the deployment record `upProject` already wrote (for `run_id`/deployment name/container
+ * id — the same record `spawnfile artifacts export`/`spawnfile down` resolve), and
+ * re-derives `compiled_schedule` from the resolved graph, since `compileProject` does not
+ * retain its own `CompilePlan` past the compile step.
+ *
+ * `readiness` reuses whatever signal `upProject` already has — a bare `docker run -d`
+ * that returned a container id, not a new health probe: `up` has never polled
+ * application-level readiness, and this receipt does not invent one. `moltnet_base_url`
+ * comes straight from the compiled container report's own managed/external server plan;
+ * no credentials ever land on this contract (contracts.md).
+ */
+export const buildUpReceipt = async (inputPath, result) => {
+    const plan = await buildCompilePlan(inputPath);
+    const compiledSchedule = resolveCompiledSchedule(plan);
+    const compiledEngines = resolveCompiledEngines(result.report);
+    const record = result.deploymentRecordPath
+        ? await readDeploymentRecord(result.deploymentRecordPath)
+        : null;
+    const unit = record?.units[0] ?? null;
+    const containerIds = unit?.container_id ? [unit.container_id] : [];
+    const fingerprint = result.report.compile_fingerprint;
+    if (!fingerprint) {
+        throw new SpawnfileError("runtime_error", "Compiled output has no compile_fingerprint; cannot build an up-receipt");
+    }
+    return {
+        version: UP_RECEIPT_VERSION,
+        run_id: record?.run_id ?? null,
+        fingerprint,
+        deployment: {
+            name: record?.name ?? null,
+            container_ids: containerIds
+        },
+        readiness: {
+            state: containerIds.length > 0 ? "running" : "unknown",
+            moltnet_base_url: result.report.container?.moltnet?.server_plans?.[0]?.base_url ?? null
+        },
+        compiled_schedule: compiledSchedule,
+        engines: compiledEngines,
+        ...(result.report.container?.moltnet?.release
+            ? { moltnet_release: createReceiptMoltnetIdentity(result.report.container.moltnet.release) }
+            : {}),
+        ...(record?.organization_handoff ? { organization_handoff: record.organization_handoff } : {}),
+        ...(record?.organization_handoff_handle ? { organization_handoff_handle: record.organization_handoff_handle } : {}),
+        ...(record?.organization_ready ? { organization_ready: record.organization_ready } : {})
+    };
+};

package/dist/compiler/updateProjectModels.js

@@ -1,13 +1,15 @@
 import path from "node:path";
-import { getCanonicalManifestPath, getManifestPath, getProjectRoot, writeUtf8File } from "../filesystem/index.js";
+import { getManifestPath, writeUtf8File } from "../filesystem/index.js";
 import { loadManifest, renderSpawnfile } from "../manifest/index.js";
 import { SpawnfileError } from "../shared/index.js";
 import { resolveEffectiveModelTarget } from "./modelEnv.js";
+import { collectProjectManifestPaths, createInlineAgentSource, rewriteInlineAgentMembers } from "./projectManifestGraph.js";
 const TEAM_MODEL_COMMAND_ERROR = "spawnfile model commands only write agent manifests; use --recursive to update descendant agents of a team project";
 const AUTH_METHOD_PROVIDER_HINTS = {
     "api_key": "use a model provider like openai or anthropic, then pass --auth api_key",
     "claude-code": "use provider anthropic, then pass --auth claude-code",
     codex: "use provider openai, then pass --auth codex",
+    grok: "use provider xai with a Daimon grok engine agent, then pass --auth grok and declare reasoning_effort",
     none: "use a model provider like local, then pass --auth none"
 };
 const resolveTargetManifestPath = (inputPath) => getManifestPath(path.resolve(inputPath ?? process.cwd()));
@@ -74,22 +76,6 @@ const buildModelTarget = (options) => {
         provider: options.provider
     };
 };
-const collectManifestPaths = async (manifestPath, recursive, visited = new Set()) => {
-    const canonicalPath = getCanonicalManifestPath(manifestPath);
-    if (visited.has(canonicalPath)) {
-        return [];
-    }
-    visited.add(canonicalPath);
-    if (!recursive) {
-        return [canonicalPath];
-    }
-    const loadedManifest = await loadManifest(canonicalPath);
-    const childRefs = loadedManifest.manifest.kind === "team"
-        ? loadedManifest.manifest.members.map((member) => member.ref)
-        : (loadedManifest.manifest.subagents ?? []).map((subagent) => subagent.ref);
-    const nestedPaths = await Promise.all(childRefs.map((ref) => collectManifestPaths(getManifestPath(path.resolve(getProjectRoot(canonicalPath), ref)), true, visited)));
-    return [canonicalPath, ...nestedPaths.flat()];
-};
 const updateManifestExecution = (manifest, model) => ({
     ...manifest,
     execution: {
@@ -98,14 +84,14 @@ const updateManifestExecution = (manifest, model) => ({
     }
 });
 const manifestChanged = (current, next) => JSON.stringify(current) !== JSON.stringify(next);
-const assertModelMutationAllowed = (manifest, recursive) => {
+const mutateAgentDeclarations = (manifest, manifestPath, recursive, mutate) => {
     if (manifest.kind === "agent") {
-        return true;
+        return mutate(manifest, manifestPath);
     }
-    if (recursive) {
-        return false;
+    if (!recursive) {
+        throw new SpawnfileError("validation_error", TEAM_MODEL_COMMAND_ERROR);
     }
-    throw new SpawnfileError("validation_error", TEAM_MODEL_COMMAND_ERROR);
+    return rewriteInlineAgentMembers(manifest, (member) => mutate(member, createInlineAgentSource(manifestPath, member.id)) ?? member);
 };
 const rewriteTouchedManifests = async (manifestPaths, mutate) => {
     const updatedFiles = [];
@@ -123,59 +109,56 @@ const rewriteTouchedManifests = async (manifestPaths, mutate) => {
 export const setProjectPrimaryModel = async (options) => {
     const modelTarget = buildModelTarget(options);
     const recursive = options.recursive ?? false;
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
-    return rewriteTouchedManifests(manifestPaths, (manifest) => {
-        if (!assertModelMutationAllowed(manifest, recursive)) {
-            return null;
-        }
-        const normalizedModel = normalizeExecutionModel(manifest.execution);
-        return updateManifestExecution(manifest, {
-            ...(normalizedModel?.fallback ? { fallback: normalizedModel.fallback } : {}),
-            primary: modelTarget
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    return rewriteTouchedManifests(manifestPaths, (manifest, manifestPath) => {
+        return mutateAgentDeclarations(manifest, manifestPath, recursive, (declaration) => {
+            const normalizedModel = normalizeExecutionModel(declaration.execution);
+            return updateManifestExecution(declaration, {
+                ...(normalizedModel?.fallback ? { fallback: normalizedModel.fallback } : {}),
+                primary: modelTarget
+            });
         });
     });
 };
 export const addProjectModelFallback = async (options) => {
     const modelTarget = buildModelTarget(options);
     const recursive = options.recursive ?? false;
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), recursive);
     return rewriteTouchedManifests(manifestPaths, (manifest, manifestPath) => {
-        if (!assertModelMutationAllowed(manifest, recursive)) {
-            return null;
-        }
-        const normalizedModel = normalizeExecutionModel(manifest.execution);
-        if (!normalizedModel) {
-            if (recursive) {
-                return null;
+        return mutateAgentDeclarations(manifest, manifestPath, recursive, (declaration, source) => {
+            const normalizedModel = normalizeExecutionModel(declaration.execution);
+            if (!normalizedModel) {
+                if (recursive) {
+                    return null;
+                }
+                throw new SpawnfileError("validation_error", `Manifest at ${source} must declare a primary model before adding fallback models`);
             }
-            throw new SpawnfileError("validation_error", `Manifest at ${manifestPath} must declare a primary model before adding fallback models`);
-        }
-        const existingFallback = normalizedModel.fallback ?? [];
-        const nextFallback = existingFallback.some((entry) => JSON.stringify(entry) === JSON.stringify(modelTarget))
-            ? existingFallback
-            : [...existingFallback, modelTarget];
-        return updateManifestExecution(manifest, {
-            fallback: nextFallback,
-            primary: normalizedModel.primary
+            const existingFallback = normalizedModel.fallback ?? [];
+            const nextFallback = existingFallback.some((entry) => JSON.stringify(entry) === JSON.stringify(modelTarget))
+                ? existingFallback
+                : [...existingFallback, modelTarget];
+            return updateManifestExecution(declaration, {
+                fallback: nextFallback,
+                primary: normalizedModel.primary
+            });
         });
     });
 };
 export const clearProjectModelFallbacks = async (options = {}) => {
     const recursive = options.recursive ?? false;
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), recursive);
     return rewriteTouchedManifests(manifestPaths, (manifest, manifestPath) => {
-        if (!assertModelMutationAllowed(manifest, recursive)) {
-            return null;
-        }
-        const normalizedModel = normalizeExecutionModel(manifest.execution);
-        if (!normalizedModel) {
-            if (recursive) {
-                return null;
+        return mutateAgentDeclarations(manifest, manifestPath, recursive, (declaration, source) => {
+            const normalizedModel = normalizeExecutionModel(declaration.execution);
+            if (!normalizedModel) {
+                if (recursive) {
+                    return null;
+                }
+                throw new SpawnfileError("validation_error", `Manifest at ${source} does not declare any execution model`);
             }
-            throw new SpawnfileError("validation_error", `Manifest at ${manifestPath} does not declare any execution model`);
-        }
-        return updateManifestExecution(manifest, {
-            primary: normalizedModel.primary
+            return updateManifestExecution(declaration, {
+                primary: normalizedModel.primary
+            });
         });
     });
 };

package/dist/compiler/updateProjectRuntime.js

@@ -1,38 +1,14 @@
 import path from "node:path";
-import { getCanonicalManifestPath, getManifestPath, getProjectRoot, writeUtf8File } from "../filesystem/index.js";
-import { loadManifest, renderSpawnfile } from "../manifest/index.js";
+import { getManifestPath, writeUtf8File } from "../filesystem/index.js";
+import { loadManifest, materializeInlineAgentManifest, renderSpawnfile } from "../manifest/index.js";
 import { assertRuntimeCanCompile } from "../runtime/index.js";
 import { SpawnfileError } from "../shared/index.js";
 import { assertRuntimeSupportsExecutionModelAuth } from "./modelAuth.js";
+import { collectProjectManifestPaths, rewriteInlineAgentMembers } from "./projectManifestGraph.js";
 import { validateAgentSurfaceSupport } from "./surfaceDefinitions.js";
 const TEAM_RUNTIME_COMMAND_ERROR = "spawnfile runtime commands only write agent manifests; use --recursive to update descendant agents of a team project";
 const resolveTargetManifestPath = (inputPath) => getManifestPath(path.resolve(inputPath ?? process.cwd()));
-const collectManifestPaths = async (manifestPath, recursive, visited = new Set()) => {
-    const canonicalPath = getCanonicalManifestPath(manifestPath);
-    if (visited.has(canonicalPath)) {
-        return [];
-    }
-    visited.add(canonicalPath);
-    if (!recursive) {
-        return [canonicalPath];
-    }
-    const loadedManifest = await loadManifest(canonicalPath);
-    const childRefs = loadedManifest.manifest.kind === "team"
-        ? loadedManifest.manifest.members.map((member) => member.ref)
-        : (loadedManifest.manifest.subagents ?? []).map((subagent) => subagent.ref);
-    const nestedPaths = await Promise.all(childRefs.map((ref) => collectManifestPaths(getManifestPath(path.resolve(getProjectRoot(canonicalPath), ref)), true, visited)));
-    return [canonicalPath, ...nestedPaths.flat()];
-};
 const manifestChanged = (current, next) => JSON.stringify(current) !== JSON.stringify(next);
-const assertRuntimeMutationAllowed = (manifest, recursive) => {
-    if (manifest.kind === "agent") {
-        return true;
-    }
-    if (recursive) {
-        return false;
-    }
-    throw new SpawnfileError("validation_error", TEAM_RUNTIME_COMMAND_ERROR);
-};
 const validateAgentRuntimeMutation = (manifest) => {
     validateAgentSurfaceSupport(manifest);
     const runtimeName = typeof manifest.runtime === "string" ? manifest.runtime : manifest.runtime?.name;
@@ -41,22 +17,33 @@ const validateAgentRuntimeMutation = (manifest) => {
     }
     assertRuntimeSupportsExecutionModelAuth(runtimeName, manifest.execution, manifest.name);
 };
+const setInlineRuntime = (team, member, runtime) => {
+    const nextMember = { ...member, runtime };
+    validateAgentRuntimeMutation(materializeInlineAgentManifest(team, nextMember));
+    return nextMember;
+};
 export const setProjectRuntime = async (options) => {
     await assertRuntimeCanCompile(options.runtime);
     const recursive = options.recursive ?? false;
-    const manifestPaths = await collectManifestPaths(resolveTargetManifestPath(options.path), recursive);
+    const manifestPaths = await collectProjectManifestPaths(resolveTargetManifestPath(options.path), recursive);
     const updatedFiles = [];
     for (const manifestPath of manifestPaths) {
         const loadedManifest = await loadManifest(manifestPath);
         const manifest = loadedManifest.manifest;
-        if (!assertRuntimeMutationAllowed(manifest, recursive)) {
-            continue;
+        let nextManifest;
+        if (manifest.kind === "agent") {
+            nextManifest = {
+                ...manifest,
+                runtime: options.runtime
+            };
+            validateAgentRuntimeMutation(nextManifest);
+        }
+        else {
+            if (!recursive) {
+                throw new SpawnfileError("validation_error", TEAM_RUNTIME_COMMAND_ERROR);
+            }
+            nextManifest = rewriteInlineAgentMembers(manifest, (member) => setInlineRuntime(manifest, member, options.runtime));
         }
-        const nextManifest = {
-            ...manifest,
-            runtime: options.runtime
-        };
-        validateAgentRuntimeMutation(nextManifest);
         if (!manifestChanged(manifest, nextManifest)) {
             continue;
         }