spawnfile 0.1.13 → 0.1.14

package/dist/compiler/upProject.d.ts

@@ -14,6 +14,11 @@ export interface UpProjectOptions extends CompileProjectOptions {
     envFilePath?: string;
     imageTag?: string;
     runRunner?: DockerRunRunner;
+    networkAttachmentHandle?: string;
+    organizationHandoffRunId?: string;
+    descriptorDigest?: string;
+    selectedTargetReceipt?: unknown;
+    selectedTargetReceiptDigest?: string;
     targetExecFile?: DockerTargetExecFile;
 }
 export interface UpProjectResult extends BuildProjectResult {

package/dist/compiler/upProject.js

@@ -1,11 +1,110 @@
 import path from "node:path";
-import { removeDirectory } from "../filesystem/index.js";
-import { writeDockerDeploymentRecordForRun } from "../deployment/index.js";
+import { createHash } from "node:crypto";
+import { rm } from "node:fs/promises";
+import { createOrganizationReadinessPending, createDockerOrganizationHandoffSession, createDockerDeploymentRecord, initializeOrganizationHandoffAuthorityStore, parseCanonicalSha256Digest, probeDockerOrganizationReadiness, readDeploymentRecord, resolveDockerDeploymentTarget, resolveDeploymentRecordPath, writeDeploymentRecord, writeDockerDeploymentRecordForRun } from "../deployment/index.js";
+import { createCanonicalSelectedTargetReceiptBytes, parseOpaqueTargetHandle, parseRunId, parseSelectedTargetReceipt, selectTarget } from "../target/index.js";
 import { buildProject } from "./buildProject.js";
 import { createDockerRunInvocation, resolveDetachedDeploymentOptions, runDockerContainer } from "./runProject.js";
+import { executeDockerRunWithSupportCleanup } from "./runProjectLifecycle.js";
 import { requireAuthProfile } from "../auth/index.js";
-import { DEFAULT_OUTPUT_DIRECTORY } from "../shared/index.js";
+import { DEFAULT_OUTPUT_DIRECTORY, SpawnfileError } from "../shared/index.js";
+import { ensureNoopolisRunId, resolveNoopolisRunId } from "../runtime/index.js";
+import { fileExists } from "../filesystem/index.js";
+import { resolveHostCliCredential } from "./runProjectAuth.js";
+const handoffInputError = () => 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 handoffRecoveryIncompleteError = () => new SpawnfileError("runtime_error", "Organization handoff recovery is incomplete; redeploy with explicit authorization");
+const stableRecord = (record) => {
+    const { created_at: _createdAt, export_index: _exportIndex, organization_ready: _organizationReady, ...stable } = record;
+    return stable;
+};
+const canonicalJson = (value) => {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(",")}]`;
+    if (value !== null && typeof value === "object") {
+        const record = value;
+        return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(record[key])}`).join(",")}}`;
+    }
+    const serialized = JSON.stringify(value);
+    if (serialized === undefined)
+        throw handoffInputError();
+    return serialized;
+};
+const resolveRequestedHandoff = (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 handoffInputError();
+    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 handoffInputError();
+    }
+};
+const verifyRequestedHandoffTarget = 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 handoffInputError();
+    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 handoffInputError();
+    }
+};
+const resolveCompiledHandoff = (requested, buildResult) => {
+    if (!requested)
+        return undefined;
+    try {
+        const bindingDigest = buildResult.organizationReadinessEvidence.worldBindings?.digest;
+        if (!bindingDigest)
+            throw new Error("missing compiled binding evidence");
+        const bindingDigestParsed = parseCanonicalSha256Digest(bindingDigest, "binding_digest");
+        return { authority: { ...requested, bindingDigest: bindingDigestParsed }, organizationHandoff: {
+                bindingDigest: bindingDigestParsed, networkAttachmentHandle: requested.networkAttachmentHandle,
+                selectedTargetReceiptDigest: requested.selectedTargetReceiptDigest
+            } };
+    }
+    catch {
+        throw handoffInputError();
+    }
+};
 export const upProject = async (inputPath, options = {}) => {
+    // Parse caller authority before any target or build work. Target identity is
+    // verified below from the resolved detached options, including exact record reuse.
+    const requestedHandoff = resolveRequestedHandoff(options);
+    // Handoff reservation identity must survive a process crash.  Unlike an
+    // ordinary deployment run, it may never silently mint a fresh run id.
+    if (requestedHandoff && resolveNoopolisRunId(process.env) !== requestedHandoff.runId)
+        throw handoffInputError();
     const resolvedOptions = await resolveDetachedDeploymentOptions(path.resolve(options.outputDirectory ?? DEFAULT_OUTPUT_DIRECTORY), {
         authProfile: options.authProfile,
         containerName: options.containerName,
@@ -18,20 +117,37 @@ export const upProject = async (inputPath, options = {}) => {
         imageTag: options.imageTag,
         targetExecFile: options.targetExecFile
     });
+    await verifyRequestedHandoffTarget(requestedHandoff, resolvedOptions, options);
+    // Every authority container compiled for this deployment must stamp
+    // causal events under the same real run id (see specs/CAUSAL.md).
+    // buildProject/compileProject stay deterministic functions of the host
+    // env; this only fills in a generated id when the host did not already
+    // provide one, before the build step that bakes it into the
+    // entrypoint/recipe env.
+    if (!requestedHandoff)
+        ensureNoopolisRunId();
     const buildResult = await buildProject(inputPath, {
         buildRunner: options.buildRunner,
         clean: options.clean,
+        containerArchitecture: options.containerArchitecture,
         dockerContext: resolvedOptions.dockerContext,
         dockerCommand: options.dockerCommand,
         imageTag: resolvedOptions.imageTag,
-        outputDirectory: options.outputDirectory
+        outputDirectory: options.outputDirectory,
+        runtimePackageOverrides: options.runtimePackageOverrides,
+        ...(options.worldBindingsPath !== undefined
+            ? { worldBindingsPath: options.worldBindingsPath }
+            : {})
     });
+    const handoff = resolveCompiledHandoff(requestedHandoff, buildResult);
     const authProfile = resolvedOptions.authProfile
         ? await requireAuthProfile(resolvedOptions.authProfile)
         : null;
+    const cliCredential = await resolveHostCliCredential(buildResult.report.container);
     const imageTag = resolvedOptions.imageTag ?? buildResult.imageTag;
     const invocation = await createDockerRunInvocation(buildResult, imageTag, {
         authProfile,
+        ...(cliCredential ? { cliCredential: { name: cliCredential.name, value: cliCredential.value } } : {}),
         containerName: resolvedOptions.containerName,
         detach: options.detach,
         deploymentName: resolvedOptions.deploymentName,
@@ -40,27 +156,147 @@ export const upProject = async (inputPath, options = {}) => {
         dockerHost: resolvedOptions.dockerHost,
         envFilePath: resolvedOptions.envFilePath
     });
-    let runMetadata;
+    let authority;
+    let deploymentRecordPath;
+    let recovered = false;
+    let dockerLifecycleInvoked = false;
     try {
-        runMetadata = await (options.runRunner ?? runDockerContainer)(invocation);
+        let pending;
+        if (handoff) {
+            if (!invocation.deploymentLabels || !invocation.containerName)
+                throw handoffInputError();
+            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
+            });
+            authority = await initializeOrganizationHandoffAuthorityStore();
+            const begun = await authority.begin(session.authorityInput);
+            pending = begun.pending;
+            recovered = !begun.created;
+        }
+        let runMetadata = undefined;
+        if (!recovered) {
+            dockerLifecycleInvoked = true;
+            runMetadata = await executeDockerRunWithSupportCleanup(invocation, options.runRunner ?? runDockerContainer);
+        }
+        const observed = recovered && authority && pending
+            ? await authority.readDockerMutation(pending.pending_key)
+            : undefined;
+        if (recovered && !observed)
+            throw handoffRecoveryIncompleteError();
+        const recoveredMetadata = observed
+            ? { containerId: observed.container_id, deploymentLabels: observed.deployment_labels, imageId: observed.image_id }
+            : undefined;
+        const exactRunMetadata = runMetadata ?? recoveredMetadata;
+        let organizationHandoffHandle;
+        if (handoff) {
+            if (!exactRunMetadata?.containerId || !exactRunMetadata.deploymentLabels || !exactRunMetadata.imageId || !authority || !pending)
+                throw handoffInputError();
+            if (!recovered)
+                await authority.observeDockerMutation(pending.pending_key, {
+                    containerId: exactRunMetadata.containerId, deploymentLabels: exactRunMetadata.deploymentLabels, imageId: exactRunMetadata.imageId
+                });
+            const finalized = await authority.finalize(pending.pending_key, { containerId: exactRunMetadata.containerId, deploymentLabels: exactRunMetadata.deploymentLabels });
+            organizationHandoffHandle = finalized.organization_handoff_handle;
+            const existingRecordPath = invocation.detach && invocation.deploymentName
+                ? resolveDeploymentRecordPath(buildResult.outputDirectory, invocation.deploymentName)
+                : null;
+            if (existingRecordPath && await fileExists(existingRecordPath)) {
+                const existing = await readDeploymentRecord(existingRecordPath);
+                const target = await resolveDockerDeploymentTarget({
+                    context: invocation.dockerContext ?? undefined,
+                    dockerCommand: invocation.command,
+                    dockerHost: invocation.dockerHost ?? undefined,
+                    execFile: options.targetExecFile
+                });
+                const expected = createDockerDeploymentRecord({
+                    authProfileName: authProfile?.name ?? null,
+                    compileFingerprint: buildResult.report.compile_fingerprint ?? "",
+                    containerName: invocation.containerName,
+                    deploymentName: invocation.deploymentName ?? undefined,
+                    envFilePath: resolvedOptions.envFilePath,
+                    imageTag,
+                    networkIds: buildResult.report.container?.moltnet?.server_plans
+                        .filter((server) => server.mode === "managed").map((server) => server.network_id),
+                    nodes: buildResult.report.nodes,
+                    organizationHandoff: handoff.organizationHandoff,
+                    organizationHandoffHandle,
+                    outputDirectory: buildResult.outputDirectory,
+                    projectRoot: buildResult.report.root,
+                    runId: handoff.authority.runId,
+                    runMetadata: exactRunMetadata,
+                    runtimeInstanceIds: buildResult.report.container?.runtime_instances.map((instance) => instance.id) ?? [],
+                    target
+                });
+                if (canonicalJson(stableRecord(existing)) !== canonicalJson(stableRecord(expected)))
+                    throw handoffInputError();
+                deploymentRecordPath = existingRecordPath;
+            }
+            else
+                deploymentRecordPath = invocation.detach && invocation.deploymentName
+                    ? await writeDockerDeploymentRecordForRun({ authProfileName: authProfile?.name ?? null, envFilePath: resolvedOptions.envFilePath,
+                        imageTag, invocation, outputDirectory: buildResult.outputDirectory,
+                        organizationHandoff: handoff.organizationHandoff, organizationHandoffHandle, report: buildResult.report,
+                        runMetadata: exactRunMetadata, targetExecFile: options.targetExecFile })
+                    : null;
+        }
+        else
+            deploymentRecordPath = invocation.detach && invocation.deploymentName
+                ? await writeDockerDeploymentRecordForRun({ authProfileName: authProfile?.name ?? null, envFilePath: resolvedOptions.envFilePath,
+                    imageTag, invocation, outputDirectory: buildResult.outputDirectory, report: buildResult.report,
+                    runMetadata: runMetadata ?? undefined, targetExecFile: options.targetExecFile })
+                : null;
     }
     finally {
-        if (!invocation.detach) {
-            await removeDirectory(invocation.supportDirectory);
+        // Replay creates a fresh support directory but does not invoke the normal
+        // Docker lifecycle wrapper. Preserve its detached credential cleanup
+        // semantics without deleting bind-mount support files.
+        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;
+    }
+    if (deploymentRecordPath && buildResult.organizationReadinessEvidence) {
+        const record = await readDeploymentRecord(deploymentRecordPath);
+        const pending = createOrganizationReadinessPending(buildResult.organizationReadinessEvidence, {
+            compileFingerprint: record.compile_fingerprint,
+            deploymentName: record.name,
+            runId: record.run_id ?? null,
+            unitCount: record.units.length,
+            unitId: record.units[0]?.id ?? "invalid-unit"
+        });
+        const pendingRecord = { ...record, organization_ready: pending };
+        await writeDeploymentRecord(buildResult.outputDirectory, pendingRecord);
+        const organizationReady = await probeDockerOrganizationReadiness({
+            dockerCommand: options.dockerCommand,
+            evidence: buildResult.organizationReadinessEvidence,
+            execFile: options.targetExecFile,
+            record: pendingRecord
+        });
+        await writeDeploymentRecord(buildResult.outputDirectory, {
+            ...pendingRecord,
+            organization_ready: organizationReady
+        });
     }
-    const deploymentRecordPath = invocation.detach && invocation.deploymentName
-        ? await writeDockerDeploymentRecordForRun({
-            authProfileName: authProfile?.name ?? null,
-            envFilePath: resolvedOptions.envFilePath,
-            imageTag,
-            invocation,
-            outputDirectory: buildResult.outputDirectory,
-            report: buildResult.report,
-            runMetadata: runMetadata ?? undefined,
-            targetExecFile: options.targetExecFile
-        })
-        : null;
     return {
         ...buildResult,
         authProfileName: authProfile?.name ?? null,

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,82 @@
+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));
+/**
+ * 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: {
+                    ...result.report.container.moltnet.release,
+                    capabilities: ["pi-bridge"]
+                } }
+            : {}),
+        ...(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,8 +1,9 @@
 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",
@@ -74,22 +75,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 +83,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 +108,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
+            });
         });
     });
 };