spawnfile 0.1.12 → 0.1.14

package/dist/cli/upLifecycleRecovery.js

@@ -0,0 +1,53 @@
+import path from "node:path";
+import { findLifecycleOutcomeEvidence, createDeploymentInstanceDigest, readDeploymentRecord, resolveDeploymentRecordPath, } from "../deployment/index.js";
+import { resolveProjectOutputDirectory } from "../filesystem/index.js";
+import { DEFAULT_OUTPUT_DIRECTORY, REPORT_FILENAME } from "../shared/index.js";
+import { readUtf8File } from "../filesystem/index.js";
+const ambiguous = (reason) => ({
+    reason,
+    status: "ambiguous",
+});
+const exactHandoff = (record, options) => record.organization_handoff !== undefined &&
+    record.organization_handoff_handle !== undefined &&
+    record.organization_handoff.network_attachment_handle ===
+        options.networkAttachmentHandle &&
+    record.organization_handoff.selected_target_receipt_digest ===
+        options.selectedTargetReceiptDigest;
+export const reconcileUpLifecycle = async (inputPath, options, invocation) => {
+    const outputDirectory = resolveProjectOutputDirectory(inputPath, options.out, DEFAULT_OUTPUT_DIRECTORY);
+    const deployment = options.deployment;
+    if (!deployment)
+        return ambiguous("up_deployment_not_bound");
+    const recordPath = resolveDeploymentRecordPath(outputDirectory, deployment);
+    try {
+        const record = await readDeploymentRecord(recordPath);
+        const report = JSON.parse(await readUtf8File(path.join(outputDirectory, REPORT_FILENAME)));
+        const requestedRoot = path.resolve(inputPath);
+        if (record.name !== deployment ||
+            record.output_directory !== outputDirectory ||
+            record.source.kind !== "project" ||
+            path.resolve(record.source.root) !== requestedRoot ||
+            record.compile_fingerprint !== report.compile_fingerprint ||
+            record.auth_profile !== (options.authProfile ?? null) ||
+            (options.context !== undefined &&
+                (record.target.kind !== "context" ||
+                    record.target.name !== options.context)) ||
+            (options.name !== undefined &&
+                record.units[0]?.container_name !== options.name) ||
+            !exactHandoff(record, options))
+            return ambiguous("up_durable_evidence_drifted");
+        const evidence = await findLifecycleOutcomeEvidence(invocation);
+        if (!evidence)
+            return ambiguous("up_receipt_evidence_absent");
+        if (evidence.deployment_instance_digest !==
+            createDeploymentInstanceDigest(record))
+            return ambiguous("up_deployment_instance_changed");
+        return {
+            outcomeBytes: evidence.completion.outcome_bytes,
+            status: "completed",
+        };
+    }
+    catch {
+        return ambiguous("up_durable_evidence_absent_or_invalid");
+    }
+};

package/dist/compiler/agentNodeMerge.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedAgentNode } from "./types.js";
+export declare const mergeCompatibleAgentNode: (existing: ResolvedAgentNode, next: ResolvedAgentNode) => void;

package/dist/compiler/agentNodeMerge.js

@@ -0,0 +1,79 @@
+import path from "node:path";
+import { SpawnfileError } from "../shared/index.js";
+import { stableStringify } from "./helpers.js";
+import { mergeWorkspaceResources } from "./workspaceResources.js";
+const assertSame = (field, existing, next, nodeName) => {
+    if (stableStringify(existing) === stableStringify(next)) {
+        return;
+    }
+    throw new SpawnfileError("compile_error", `Agent ${nodeName} resolves with incompatible ${field} across team imports`);
+};
+const mergeEnvStrict = (existing, next, nodeName) => {
+    const merged = { ...existing };
+    for (const [key, value] of Object.entries(next)) {
+        if (merged[key] !== undefined && merged[key] !== value) {
+            throw new SpawnfileError("validation_error", `Agent ${nodeName} receives conflicting environment variable ${key} across team imports`);
+        }
+        merged[key] = value;
+    }
+    return merged;
+};
+const mergeByKeyStrict = (existing, next, getKey, label, nodeName) => {
+    const merged = new Map();
+    for (const value of existing ?? []) {
+        merged.set(getKey(value), value);
+    }
+    for (const value of next ?? []) {
+        const key = getKey(value);
+        const previous = merged.get(key);
+        if (previous && stableStringify(previous) !== stableStringify(value)) {
+            throw new SpawnfileError("validation_error", `Agent ${nodeName} receives conflicting ${label} ${key} across team imports`);
+        }
+        merged.set(key, value);
+    }
+    return merged.size > 0 ? [...merged.values()] : undefined;
+};
+const mergeDocuments = (existing, next, agentSourcePath) => {
+    const agentDirectory = path.dirname(agentSourcePath);
+    const isAgentLocalDoc = (doc) => {
+        const sourcePath = path.resolve(doc.sourcePath);
+        return sourcePath === agentDirectory || sourcePath.startsWith(`${agentDirectory}${path.sep}`);
+    };
+    const merged = new Map(existing.filter(isAgentLocalDoc).map((doc) => [doc.role, doc]));
+    for (const doc of next.filter(isAgentLocalDoc)) {
+        if (!merged.has(doc.role)) {
+            merged.set(doc.role, doc);
+        }
+    }
+    return [...merged.values()];
+};
+const packageKey = (pkg) => `${pkg.manager}::${pkg.name}`;
+const skillKey = (skill) => skill.ref;
+export const mergeCompatibleAgentNode = (existing, next) => {
+    assertSame("description", existing.description, next.description, existing.name);
+    assertSame("execution", existing.execution, next.execution, existing.name);
+    assertSame("expose", existing.expose, next.expose, existing.name);
+    assertSame("memory", existing.memory, next.memory, existing.name);
+    assertSame("name", existing.name, next.name, existing.name);
+    assertSame("policy mode", existing.policyMode, next.policyMode, existing.name);
+    assertSame("policy on_degrade", existing.policyOnDegrade, next.policyOnDegrade, existing.name);
+    assertSame("runtime", existing.runtime, next.runtime, existing.name);
+    assertSame("schedule", existing.schedule, next.schedule, existing.name);
+    assertSame("source", existing.source, next.source, existing.name);
+    assertSame("source path", existing.sourcePath, next.sourcePath, existing.name);
+    assertSame("surfaces", existing.surfaces, next.surfaces, existing.name);
+    existing.docs = mergeDocuments(existing.docs, next.docs, existing.sourcePath ?? existing.source);
+    existing.env = mergeEnvStrict(existing.env, next.env, existing.name);
+    existing.mcpServers = mergeByKeyStrict(existing.mcpServers, next.mcpServers, (server) => server.name, "MCP server", existing.name) ?? [];
+    existing.packages = mergeByKeyStrict(existing.packages, next.packages, packageKey, "package", existing.name);
+    existing.secrets = mergeByKeyStrict(existing.secrets, next.secrets, (secret) => secret.name, "secret", existing.name) ?? [];
+    existing.skills = mergeByKeyStrict(existing.skills, next.skills, skillKey, "skill", existing.name) ?? [];
+    existing.workspaceResources = mergeWorkspaceResources([
+        ...(existing.workspaceResources ?? []),
+        ...(next.workspaceResources ?? [])
+    ], [], existing.name, {
+        kind: "agent",
+        key: existing.source,
+        name: existing.name
+    });
+};

package/dist/compiler/agentSurfaces.js

@@ -23,11 +23,21 @@ export const resolveAgentSurfaces = (surfaces) => {
     }
     if (surfaces.moltnet) {
         resolved.moltnet = surfaces.moltnet.map((attachment) => ({
+            ...(attachment.auth
+                ? {
+                    auth: {
+                        tokenId: attachment.auth.token_id
+                    }
+                }
+                : {}),
             ...(attachment.dms
                 ? {
                     dms: {
                         enabled: attachment.dms.enabled,
-                        ...(attachment.dms.wake ? { wake: attachment.dms.wake } : {})
+                        ...(attachment.dms.wake ? { wake: attachment.dms.wake } : {}),
+                        ...(attachment.dms.allowed_wake_senders !== undefined
+                            ? { allowedWakeSenders: [...attachment.dms.allowed_wake_senders] }
+                            : {})
                     }
                 }
                 : {}),

package/dist/compiler/buildCompilePlan.js

@@ -2,9 +2,12 @@ import { getCanonicalManifestPath, getManifestPath } from "../filesystem/index.j
 import { loadManifest, isAgentManifest } from "../manifest/index.js";
 import { assignStableNodeIds } from "./helpers.js";
 import { resolvePlanMoltnetAttachments } from "./moltnetResolution.js";
+import { resolvePlanMemoryAccess } from "./memoryResolution.js";
 import { resolveMoltnetRoomMemberships } from "./moltnetRoomMemberships.js";
 import { createRuntimeGroups } from "./buildCompilePlanRuntime.js";
+import { validateAllowedWakeSenders } from "./moltnetAllowedWakeSendersValidation.js";
 import { createCompilePlanTraversal } from "./buildCompilePlanTraversal.js";
+import { resolveMoltnetExternalParticipantIntents, resolveOrganizationIdentity, validateB31MoltnetAuth } from "./organizationIdentity.js";
 export const buildCompilePlan = async (inputPath) => {
     const rootManifestPath = getCanonicalManifestPath(getManifestPath(inputPath));
     const loadCache = new Map();
@@ -60,7 +63,21 @@ export const buildCompilePlan = async (inputPath) => {
         root: rootManifestPath,
         runtimes: createRuntimeGroups(compilePlanNodes)
     };
+    const organizationIdentity = resolveOrganizationIdentity(compilePlan);
+    if (organizationIdentity)
+        compilePlan.organizationIdentity = organizationIdentity;
+    // Reject duplicate or invalid authored actor selections before attachment
+    // synthesis can merge them into a single canonical attachment.
+    validateB31MoltnetAuth(compilePlan);
+    const externalParticipantIntents = resolveMoltnetExternalParticipantIntents(compilePlan);
+    if (organizationIdentity)
+        compilePlan.moltnetExternalParticipantIntents = externalParticipantIntents;
     compilePlan.moltnetRoomMemberships = resolveMoltnetRoomMemberships(compilePlan);
+    resolvePlanMemoryAccess(compilePlan);
     resolvePlanMoltnetAttachments(compilePlan);
+    // Recheck the actual canonical attachments emitted after representative
+    // synthesis and duplicate merging.
+    validateB31MoltnetAuth(compilePlan);
+    validateAllowedWakeSenders(compilePlan);
     return compilePlan;
 };

package/dist/compiler/buildCompilePlanAgent.d.ts

@@ -0,0 +1,11 @@
+import { type AgentManifest } from "../manifest/index.js";
+import type { AgentVisitContext } from "./buildCompilePlanRuntime.js";
+import type { ResolvedAgentNode } from "./types.js";
+interface ResolveAgentNodeOptions {
+    context: AgentVisitContext;
+    manifest: AgentManifest;
+    manifestPath: string;
+    source: string;
+}
+export declare const resolveAgentNode: ({ context, manifest, manifestPath, source }: ResolveAgentNodeOptions) => Promise<ResolvedAgentNode>;
+export {};

package/dist/compiler/buildCompilePlanAgent.js

@@ -0,0 +1,56 @@
+import { mergeExecution } from "../manifest/index.js";
+import { resolveAgentSurfaces } from "./agentSurfaces.js";
+import { resolveDescription, resolveRuntime } from "./buildCompilePlanRuntime.js";
+import { DEFAULT_POLICY_MODE, DEFAULT_POLICY_ON_DEGRADE, mergeResolvedDocuments, resolveEffectiveEnvironment } from "./buildCompilePlanTraversalHelpers.js";
+import { getMcpNames, validateEffectiveSkillRequirements } from "./compilePlanHelpers.js";
+import { applyExecutionDefaults } from "./executionDefaults.js";
+import { resolveDeclaredMemoryBanks } from "./memoryResolution.js";
+import { assertRuntimeSupportsExecutionModelAuth } from "./modelAuth.js";
+import { loadResolvedSkills, mergeResolvedSkills } from "./surfaces.js";
+import { assertRuntimeSupportsAgentSurfaces } from "./surfaceSupport.js";
+import { mergeWorkspaceResources } from "./workspaceResources.js";
+export const resolveAgentNode = async ({ context, manifest, manifestPath, source }) => {
+    const runtime = await resolveRuntime(manifest, context);
+    const execution = applyExecutionDefaults(context.isSubagent
+        ? mergeExecution(context.inheritedExecution, manifest.execution)
+        : manifest.execution);
+    assertRuntimeSupportsExecutionModelAuth(runtime.name, execution, manifest.name);
+    const environment = resolveEffectiveEnvironment(context.inheritedShared?.surface?.environment, manifest.environment);
+    const inheritedSkills = context.inheritedShared
+        ? await loadResolvedSkills(context.inheritedShared.manifestPath, context.inheritedShared.surface?.workspace?.skills)
+        : [];
+    const localSkills = await loadResolvedSkills(manifestPath, manifest.workspace?.skills);
+    const skills = mergeResolvedSkills(inheritedSkills, localSkills);
+    validateEffectiveSkillRequirements(manifest.name, getMcpNames(environment.mcpServers), skills);
+    const docs = await mergeResolvedDocuments(manifestPath, manifest.workspace?.docs, context.inheritedShared?.manifestPath, context.inheritedShared?.surface?.workspace?.docs);
+    const workspaceResources = mergeWorkspaceResources(context.inheritedResources, manifest.workspace?.resources, manifest.name, {
+        kind: "agent",
+        key: source,
+        name: manifest.name
+    });
+    const candidate = {
+        description: resolveDescription(manifest.description, docs),
+        docs,
+        env: environment.env,
+        execution,
+        expose: manifest.expose ?? false,
+        kind: "agent",
+        mcpServers: environment.mcpServers,
+        name: manifest.name,
+        policyMode: manifest.policy?.mode ?? DEFAULT_POLICY_MODE,
+        policyOnDegrade: manifest.policy?.on_degrade ?? DEFAULT_POLICY_ON_DEGRADE,
+        runtime,
+        memory: resolveDeclaredMemoryBanks(manifest.memory, source, "agent", manifest.name),
+        schedule: manifest.schedule,
+        secrets: environment.secrets,
+        packages: environment.packages,
+        skills,
+        source,
+        ...(source === manifestPath ? {} : { sourcePath: manifestPath }),
+        surfaces: resolveAgentSurfaces(manifest.surfaces),
+        subagents: [],
+        workspaceResources
+    };
+    assertRuntimeSupportsAgentSurfaces(runtime.name, candidate.surfaces, manifest.name);
+    return candidate;
+};

package/dist/compiler/buildCompilePlanTeams.d.ts

@@ -2,4 +2,5 @@ import type { TeamManifest } from "../manifest/index.js";
 import type { ResolvedTeamNetwork, ResolvedTeamNode } from "./types.js";
 export declare const resolveTeamExternalIds: (manifest: TeamManifest) => string[];
 export declare const resolveTeamNetworks: (manifest: TeamManifest) => ResolvedTeamNetwork[];
+export declare const isAttachedExternalRoomMember: (teamNode: ResolvedTeamNode, networkId: string, memberId: string) => boolean;
 export declare const validateTeamNetworkRooms: (teamNode: ResolvedTeamNode) => void;

package/dist/compiler/buildCompilePlanTeams.js

@@ -32,12 +32,15 @@ export const resolveTeamNetworks = (manifest) => (manifest.networks ?? []).map((
     }
     return resolved;
 });
+export const isAttachedExternalRoomMember = (teamNode, networkId, memberId) => teamNode.externalParticipants?.some((participant) => participant.id === memberId
+    && participant.surfaces.moltnet.some((attachment) => attachment.network === networkId)) === true;
 export const validateTeamNetworkRooms = (teamNode) => {
     for (const network of teamNode.networks ?? []) {
         for (const room of network.rooms) {
             for (const roomMemberId of room.members) {
                 const resolvedMember = teamNode.members.find((member) => member.id === roomMemberId);
-                if (!resolvedMember) {
+                if (!resolvedMember
+                    && !isAttachedExternalRoomMember(teamNode, network.id, roomMemberId)) {
                     throw new SpawnfileError("validation_error", `Team ${teamNode.name} Moltnet room ${room.id} references unknown member ${roomMemberId}`);
                 }
             }

package/dist/compiler/buildCompilePlanTraversal.js

@@ -1,89 +1,62 @@
 import { getCanonicalManifestPath, getManifestPath, resolveProjectPath } from "../filesystem/index.js";
-import { isAgentManifest, isTeamManifest, mergeExecution } from "../manifest/index.js";
+import { isAgentManifest, isReferencedMember, isTeamManifest, materializeInlineAgentManifest } from "../manifest/index.js";
 import { SpawnfileError } from "../shared/index.js";
 import { getAgentFingerprint, getMcpNames, getTeamFingerprint, validateEffectiveSkillRequirements } from "./compilePlanHelpers.js";
-import { resolveAgentSurfaces } from "./agentSurfaces.js";
-import { mergeResolvedSkills, loadResolvedSkills } from "./surfaces.js";
-import { assertRuntimeSupportsExecutionModelAuth } from "./modelAuth.js";
-import { assertRuntimeSupportsAgentSurfaces } from "./surfaceSupport.js";
-import { applyExecutionDefaults } from "./executionDefaults.js";
-import { normalizeDescription, resolveDescription, resolveRuntime } from "./buildCompilePlanRuntime.js";
+import { loadResolvedSkills } from "./surfaces.js";
+import { mergeCompatibleAgentNode } from "./agentNodeMerge.js";
+import { normalizeDescription } from "./buildCompilePlanRuntime.js";
 import { resolveTeamExternalIds, resolveTeamNetworks, validateTeamNetworkRooms } from "./buildCompilePlanTeams.js";
+import { resolveDeclaredMemoryBanks } from "./memoryResolution.js";
 import { mergeWorkspaceResources } from "./workspaceResources.js";
-import { DEFAULT_POLICY_MODE, DEFAULT_POLICY_ON_DEGRADE, mergeResolvedDocuments, resolveEffectiveEnvironment } from "./buildCompilePlanTraversalHelpers.js";
+import { DEFAULT_POLICY_MODE, DEFAULT_POLICY_ON_DEGRADE, mergeResolvedDocuments, } from "./buildCompilePlanTraversalHelpers.js";
+import { resolveAgentNode } from "./buildCompilePlanAgent.js";
+import { createInlineAgentSource } from "./projectManifestGraph.js";
 export const createCompilePlanTraversal = ({ getLoadedManifest, nodeCache, fingerprintCache, edges, memberships }) => {
     const visitStack = [];
-    const visitAgent = async (manifestPath, context) => {
-        const canonicalPath = getCanonicalManifestPath(manifestPath);
-        if (visitStack.includes(canonicalPath)) {
-            throw new SpawnfileError("compile_error", `Cycle detected while visiting ${canonicalPath}`);
-        }
-        const loadedManifest = await getLoadedManifest(canonicalPath);
-        if (!isAgentManifest(loadedManifest.manifest)) {
-            throw new SpawnfileError("compile_error", `Expected agent manifest, got ${loadedManifest.manifest.kind} at ${canonicalPath}`);
-        }
-        const runtime = await resolveRuntime(loadedManifest.manifest, context);
-        const execution = applyExecutionDefaults(context.isSubagent
-            ? mergeExecution(context.inheritedExecution, loadedManifest.manifest.execution)
-            : loadedManifest.manifest.execution);
-        assertRuntimeSupportsExecutionModelAuth(runtime.name, execution, loadedManifest.manifest.name);
-        const environment = resolveEffectiveEnvironment(context.inheritedShared?.surface?.environment, loadedManifest.manifest.environment);
-        const inheritedSkills = context.inheritedShared
-            ? await loadResolvedSkills(context.inheritedShared.manifestPath, context.inheritedShared.surface?.workspace?.skills)
-            : [];
-        const localSkills = await loadResolvedSkills(canonicalPath, loadedManifest.manifest.workspace?.skills);
-        const skills = mergeResolvedSkills(inheritedSkills, localSkills);
-        validateEffectiveSkillRequirements(loadedManifest.manifest.name, getMcpNames(environment.mcpServers), skills);
-        const docs = await mergeResolvedDocuments(canonicalPath, loadedManifest.manifest.workspace?.docs, context.inheritedShared?.manifestPath, context.inheritedShared?.surface?.workspace?.docs);
-        const workspaceResources = mergeWorkspaceResources(context.inheritedResources, loadedManifest.manifest.workspace?.resources, loadedManifest.manifest.name, {
-            kind: "agent",
-            key: canonicalPath,
-            name: loadedManifest.manifest.name
+    const recordAgentMembership = (teamSource, teamName, memberId, agent) => {
+        memberships.set(`${teamSource}::${memberId}::${agent.source}`, {
+            agentSource: agent.source,
+            memberId,
+            teamName,
+            teamSource
         });
-        const candidate = {
-            description: resolveDescription(loadedManifest.manifest.description, docs),
-            docs,
-            env: environment.env,
-            execution,
-            expose: loadedManifest.manifest.expose ?? false,
+        return {
+            id: memberId,
             kind: "agent",
-            mcpServers: environment.mcpServers,
-            name: loadedManifest.manifest.name,
-            policyMode: loadedManifest.manifest.policy?.mode ?? DEFAULT_POLICY_MODE,
-            policyOnDegrade: loadedManifest.manifest.policy?.on_degrade ?? DEFAULT_POLICY_ON_DEGRADE,
-            runtime,
-            schedule: loadedManifest.manifest.schedule,
-            secrets: environment.secrets,
-            packages: environment.packages,
-            skills,
-            source: canonicalPath,
-            surfaces: resolveAgentSurfaces(loadedManifest.manifest.surfaces),
-            subagents: [],
-            workspaceResources
+            nodeSource: agent.source,
+            runtimeName: agent.runtime.name
         };
-        assertRuntimeSupportsAgentSurfaces(runtime.name, candidate.surfaces, loadedManifest.manifest.name);
-        const fingerprint = getAgentFingerprint(candidate);
-        const existingFingerprint = fingerprintCache.get(canonicalPath);
-        if (existingFingerprint && existingFingerprint !== fingerprint) {
-            throw new SpawnfileError("compile_error", `Manifest ${canonicalPath} resolves differently across compile contexts`);
+    };
+    const visitAgentManifest = async (manifest, source, manifestPath, context) => {
+        if (visitStack.includes(source)) {
+            throw new SpawnfileError("compile_error", `Cycle detected while visiting ${source}`);
         }
-        const cachedNode = nodeCache.get(canonicalPath);
+        const candidate = await resolveAgentNode({ context, manifest, manifestPath, source });
+        const cachedNode = nodeCache.get(source);
         if (cachedNode) {
-            return cachedNode.value;
+            const cachedAgent = cachedNode.value;
+            mergeCompatibleAgentNode(cachedAgent, candidate);
+            fingerprintCache.set(source, getAgentFingerprint(cachedAgent));
+            return cachedAgent;
         }
-        fingerprintCache.set(canonicalPath, fingerprint);
-        nodeCache.set(canonicalPath, {
-            runtimeName: runtime.name,
-            source: canonicalPath,
+        const fingerprint = getAgentFingerprint(candidate);
+        const existingFingerprint = fingerprintCache.get(source);
+        if (existingFingerprint && existingFingerprint !== fingerprint) {
+            throw new SpawnfileError("compile_error", `Agent ${source} resolves differently across compile contexts`);
+        }
+        fingerprintCache.set(source, fingerprint);
+        nodeCache.set(source, {
+            runtimeName: candidate.runtime.name,
+            source,
             value: candidate
         });
-        visitStack.push(canonicalPath);
-        for (const subagent of loadedManifest.manifest.subagents ?? []) {
-            const childManifestPath = getManifestPath(resolveProjectPath(canonicalPath, subagent.ref));
+        visitStack.push(source);
+        for (const subagent of manifest.subagents ?? []) {
+            const childManifestPath = getManifestPath(resolveProjectPath(manifestPath, subagent.ref));
             const resolvedSubagent = await visitAgent(childManifestPath, {
-                inheritedExecution: execution,
+                inheritedExecution: candidate.execution,
                 inheritedResources: candidate.workspaceResources,
-                inheritedRuntime: runtime,
+                inheritedRuntime: candidate.runtime,
                 isSubagent: true
             });
             candidate.subagents.push({
@@ -91,7 +64,7 @@ export const createCompilePlanTraversal = ({ getLoadedManifest, nodeCache, finge
                 nodeSource: resolvedSubagent.source
             });
             edges.push({
-                from: canonicalPath,
+                from: source,
                 kind: "subagent",
                 label: subagent.id,
                 to: resolvedSubagent.source
@@ -100,6 +73,14 @@ export const createCompilePlanTraversal = ({ getLoadedManifest, nodeCache, finge
         visitStack.pop();
         return candidate;
     };
+    const visitAgent = async (manifestPath, context) => {
+        const canonicalPath = getCanonicalManifestPath(manifestPath);
+        const loadedManifest = await getLoadedManifest(canonicalPath);
+        if (!isAgentManifest(loadedManifest.manifest)) {
+            throw new SpawnfileError("compile_error", `Expected agent manifest, got ${loadedManifest.manifest.kind} at ${canonicalPath}`);
+        }
+        return visitAgentManifest(loadedManifest.manifest, canonicalPath, canonicalPath, context);
+    };
     const visitTeam = async (manifestPath, inheritedResources = []) => {
         const canonicalPath = getCanonicalManifestPath(manifestPath);
         if (visitStack.includes(canonicalPath)) {
@@ -126,11 +107,15 @@ export const createCompilePlanTraversal = ({ getLoadedManifest, nodeCache, finge
             docs,
             external: resolvedExternal,
             externalExplicit: manifest.external !== undefined,
+            ...(manifest.external_participants
+                ? { externalParticipants: manifest.external_participants }
+                : {}),
             kind: "team",
             lead: manifest.lead ?? null,
             members: [],
             mode: manifest.mode,
             name: manifest.name,
+            memory: resolveDeclaredMemoryBanks(manifest.memory, canonicalPath, "team", manifest.name),
             networks: resolveTeamNetworks(manifest),
             policyMode: manifest.policy?.mode ?? DEFAULT_POLICY_MODE,
             policyOnDegrade: manifest.policy?.on_degrade ?? DEFAULT_POLICY_ON_DEGRADE,
@@ -161,6 +146,25 @@ export const createCompilePlanTraversal = ({ getLoadedManifest, nodeCache, finge
         });
         visitStack.push(canonicalPath);
         for (const member of loadedManifest.manifest.members) {
+            if (!isReferencedMember(member)) {
+                const resolvedAgent = await visitAgentManifest(materializeInlineAgentManifest(manifest, member), createInlineAgentSource(canonicalPath, member.id), canonicalPath, {
+                    inheritedShared: {
+                        manifestPath: canonicalPath,
+                        surface: manifest.shared
+                    },
+                    inheritedResources: candidate.workspaceResources,
+                    isSubagent: false
+                });
+                const resolvedMember = recordAgentMembership(canonicalPath, candidate.name, member.id, resolvedAgent);
+                candidate.members.push(resolvedMember);
+                edges.push({
+                    from: canonicalPath,
+                    kind: "team_member",
+                    label: member.id,
+                    to: resolvedMember.nodeSource
+                });
+                continue;
+            }
             const childManifestPath = getManifestPath(resolveProjectPath(canonicalPath, member.ref));
             const childManifest = await getLoadedManifest(childManifestPath);
             let resolvedMember;
@@ -173,18 +177,7 @@ export const createCompilePlanTraversal = ({ getLoadedManifest, nodeCache, finge
                     inheritedResources: candidate.workspaceResources,
                     isSubagent: false
                 });
-                resolvedMember = {
-                    id: member.id,
-                    kind: "agent",
-                    nodeSource: resolvedAgent.source,
-                    runtimeName: resolvedAgent.runtime.name
-                };
-                memberships.set(`${canonicalPath}::${member.id}::${resolvedAgent.source}`, {
-                    agentSource: resolvedAgent.source,
-                    memberId: member.id,
-                    teamName: candidate.name,
-                    teamSource: canonicalPath
-                });
+                resolvedMember = recordAgentMembership(canonicalPath, candidate.name, member.id, resolvedAgent);
             }
             else {
                 const resolvedTeam = await visitTeam(childManifestPath, candidate.workspaceResources);

package/dist/compiler/buildProject.d.ts

@@ -1,20 +1,39 @@
 import { type CompileProjectOptions, type CompileProjectResult } from "./compileProject.js";
+import { type DockerImageInspector } from "./dockerBuildSkip.js";
+import type { MoltnetTargetArchitecture } from "./moltnetBinaries.js";
 export interface DockerBuildInvocation {
     args: string[];
     command: string;
     cwd: string;
+    dockerContext?: string | null;
     imageTag: string;
 }
 export type DockerBuildRunner = (invocation: DockerBuildInvocation) => Promise<void>;
 export interface BuildProjectOptions extends CompileProjectOptions {
     buildRunner?: DockerBuildRunner;
     dockerCommand?: string;
+    dockerContext?: string;
+    imageInspector?: DockerImageInspector;
     imageTag?: string;
 }
 export interface BuildProjectResult extends CompileProjectResult {
+    imageBuild?: {
+        buildMs: number | null;
+        contextBytes: number;
+        contextDigest: string;
+        contextDigestMs: number;
+        contextFileCount: number;
+        probeMs: number;
+        skipped: boolean;
+    };
     imageTag: string;
 }
 export declare const createDefaultImageTag: (projectRoot: string) => string;
-export declare const createDockerBuildInvocation: (outputDirectory: string, imageTag: string, dockerCommand?: string) => DockerBuildInvocation;
+export declare const createDockerBuildInvocation: (outputDirectory: string, imageTag: string, options?: string | {
+    dockerCommand?: string;
+    dockerContext?: string;
+}) => DockerBuildInvocation;
+export declare const normalizeDockerArchitecture: (architecture: string) => MoltnetTargetArchitecture;
+export declare const resolveDockerBuildArchitecture: (options: Pick<BuildProjectOptions, "dockerCommand" | "dockerContext">) => Promise<MoltnetTargetArchitecture | undefined>;
 export declare const runDockerBuild: DockerBuildRunner;
 export declare const buildProject: (inputPath: string, options?: BuildProjectOptions) => Promise<BuildProjectResult>;