spawnfile 0.1.1 → 0.1.3

package/dist/compiler/buildCompilePlan.js

@@ -1,6 +1,5 @@
 import { getCanonicalManifestPath, getManifestPath, resolveProjectPath } from "../filesystem/index.js";
-import { isAgentManifest, isTeamManifest, loadManifest, mergeExecution, normalizeRuntimeBinding } from "../manifest/index.js";
-import { assertRuntimeCanCompile } from "../runtime/index.js";
+import { isAgentManifest, isTeamManifest, loadManifest, mergeExecution } from "../manifest/index.js";
 import { SpawnfileError } from "../shared/index.js";
 import { getAgentFingerprint, getMcpNames, getTeamFingerprint, validateEffectiveSkillRequirements } from "./compilePlanHelpers.js";
 import { resolveAgentSurfaces } from "./agentSurfaces.js";
@@ -9,30 +8,17 @@ import { loadResolvedDocuments, mergeResolvedSkills, loadResolvedSkills, mergeSh
 import { assertRuntimeSupportsExecutionModelAuth } from "./modelAuth.js";
 import { assertRuntimeSupportsAgentSurfaces } from "./surfaceSupport.js";
 import { applyExecutionDefaults } from "./executionDefaults.js";
-const resolveRuntime = async (manifest, context) => {
-    const localRuntime = normalizeRuntimeBinding(manifest.runtime);
-    if (context.isSubagent) {
-        if (!context.inheritedRuntime) {
-            throw new SpawnfileError("runtime_error", `Subagent ${manifest.name} is missing inherited runtime context`);
-        }
-        if (localRuntime &&
-            localRuntime.name !== context.inheritedRuntime.name) {
-            throw new SpawnfileError("runtime_error", `Subagent ${manifest.name} must match parent runtime`);
-        }
-        return context.inheritedRuntime;
-    }
-    if (!localRuntime) {
-        throw new SpawnfileError("runtime_error", `Agent ${manifest.name} does not declare a runtime`);
-    }
-    await assertRuntimeCanCompile(localRuntime.name);
-    return localRuntime;
-};
+import { resolvePlanMoltnetAttachments } from "./moltnetResolution.js";
+import { resolveMoltnetRoomMemberships } from "./moltnetRoomMemberships.js";
+import { normalizeDescription, resolveDescription, resolveRuntime } from "./buildCompilePlanRuntime.js";
+import { resolveTeamExternalIds, resolveTeamNetworks, validateTeamNetworkRooms } from "./buildCompilePlanTeams.js";
 export const buildCompilePlan = async (inputPath) => {
     const rootManifestPath = getCanonicalManifestPath(getManifestPath(inputPath));
     const loadCache = new Map();
     const nodeCache = new Map();
     const fingerprintCache = new Map();
     const edges = [];
+    const memberships = new Map();
     const visitStack = [];
     const getLoadedManifest = (manifestPath) => {
         const canonicalPath = getCanonicalManifestPath(manifestPath);
@@ -70,10 +56,13 @@ export const buildCompilePlan = async (inputPath) => {
         const localSkills = await loadResolvedSkills(canonicalPath, loadedManifest.manifest.skills);
         const skills = mergeResolvedSkills(inheritedSkills, localSkills);
         validateEffectiveSkillRequirements(loadedManifest.manifest.name, getMcpNames(sharedSurface.mcpServers), skills);
+        const docs = await loadResolvedDocuments(canonicalPath, loadedManifest.manifest.docs);
         const candidate = {
-            docs: await loadResolvedDocuments(canonicalPath, loadedManifest.manifest.docs),
+            description: resolveDescription(loadedManifest.manifest.description, docs),
+            docs,
             env: sharedSurface.env,
             execution,
+            expose: loadedManifest.manifest.expose ?? false,
             kind: "agent",
             mcpServers: sharedSurface.mcpServers,
             name: loadedManifest.manifest.name,
@@ -135,31 +124,29 @@ export const buildCompilePlan = async (inputPath) => {
         }
         const sharedSkills = await loadResolvedSkills(canonicalPath, loadedManifest.manifest.shared?.skills);
         validateEffectiveSkillRequirements(loadedManifest.manifest.name, getMcpNames(loadedManifest.manifest.shared?.mcp_servers ?? []), sharedSkills);
-        const structure = loadedManifest.manifest.structure;
-        const memberIds = loadedManifest.manifest.members.map((member) => member.id);
-        const resolvedExternal = structure.external
-            ?? (structure.mode === "hierarchical" && structure.leader
-                ? [structure.leader]
-                : memberIds);
+        const manifest = loadedManifest.manifest;
+        const resolvedExternal = resolveTeamExternalIds(manifest);
+        const docs = await loadResolvedDocuments(canonicalPath, manifest.docs);
         const candidate = {
-            docs: await loadResolvedDocuments(canonicalPath, loadedManifest.manifest.docs),
+            description: manifest.description ? normalizeDescription(manifest.description) : "",
+            docs,
+            external: resolvedExternal,
+            externalExplicit: manifest.external !== undefined,
             kind: "team",
+            lead: manifest.lead ?? null,
             members: [],
-            name: loadedManifest.manifest.name,
-            policyMode: loadedManifest.manifest.policy?.mode ?? null,
-            policyOnDegrade: loadedManifest.manifest.policy?.on_degrade ?? null,
+            mode: manifest.mode,
+            name: manifest.name,
+            networks: resolveTeamNetworks(manifest),
+            policyMode: manifest.policy?.mode ?? null,
+            policyOnDegrade: manifest.policy?.on_degrade ?? null,
             shared: {
-                env: loadedManifest.manifest.shared?.env ?? {},
-                mcpServers: loadedManifest.manifest.shared?.mcp_servers ?? [],
-                secrets: loadedManifest.manifest.shared?.secrets ?? [],
+                env: manifest.shared?.env ?? {},
+                mcpServers: manifest.shared?.mcp_servers ?? [],
+                secrets: manifest.shared?.secrets ?? [],
                 skills: sharedSkills
             },
             source: canonicalPath,
-            structure: {
-                external: resolvedExternal,
-                leader: structure.leader ?? null,
-                mode: structure.mode
-            }
         };
         const fingerprint = getTeamFingerprint(candidate);
         const existingFingerprint = fingerprintCache.get(canonicalPath);
@@ -195,6 +182,12 @@ export const buildCompilePlan = async (inputPath) => {
                     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
+                });
             }
             else {
                 const resolvedTeam = await visitTeam(childManifestPath);
@@ -213,6 +206,7 @@ export const buildCompilePlan = async (inputPath) => {
                 to: resolvedMember.nodeSource
             });
         }
+        validateTeamNetworkRooms(candidate);
         visitStack.pop();
         return candidate;
     };
@@ -249,10 +243,14 @@ export const buildCompilePlan = async (inputPath) => {
         groups[node.runtimeName] = group;
         return groups;
     }, {});
-    return {
+    const compilePlan = {
         edges: compilePlanEdges,
+        memberships: [...memberships.values()].sort((left, right) => `${left.agentSource}:${left.teamSource}:${left.memberId}`.localeCompare(`${right.agentSource}:${right.teamSource}:${right.memberId}`)),
         nodes: compilePlanNodes,
         root: rootManifestPath,
         runtimes
     };
+    compilePlan.moltnetRoomMemberships = resolveMoltnetRoomMemberships(compilePlan);
+    resolvePlanMoltnetAttachments(compilePlan);
+    return compilePlan;
 };

package/dist/compiler/buildCompilePlanRuntime.d.ts

@@ -0,0 +1,14 @@
+import { type AgentManifest, type ExecutionBlock, type SharedSurface } from "../manifest/index.js";
+import type { ResolvedDocument, ResolvedRuntime } from "./types.js";
+export interface AgentVisitContext {
+    inheritedExecution?: ExecutionBlock;
+    inheritedShared?: {
+        manifestPath: string;
+        surface: SharedSurface | undefined;
+    };
+    inheritedRuntime?: ResolvedRuntime;
+    isSubagent: boolean;
+}
+export declare const resolveRuntime: (manifest: AgentManifest, context: AgentVisitContext) => Promise<ResolvedRuntime>;
+export declare const normalizeDescription: (description: string) => string;
+export declare const resolveDescription: (description: string | undefined, docs: ResolvedDocument[]) => string;

package/dist/compiler/buildCompilePlanRuntime.js

@@ -0,0 +1,39 @@
+import { normalizeRuntimeBinding } from "../manifest/index.js";
+import { assertRuntimeCanCompile } from "../runtime/index.js";
+import { SpawnfileError } from "../shared/index.js";
+export const resolveRuntime = async (manifest, context) => {
+    const localRuntime = normalizeRuntimeBinding(manifest.runtime);
+    if (context.isSubagent) {
+        if (!context.inheritedRuntime) {
+            throw new SpawnfileError("runtime_error", `Subagent ${manifest.name} is missing inherited runtime context`);
+        }
+        if (localRuntime &&
+            localRuntime.name !== context.inheritedRuntime.name) {
+            throw new SpawnfileError("runtime_error", `Subagent ${manifest.name} must match parent runtime`);
+        }
+        return context.inheritedRuntime;
+    }
+    if (!localRuntime) {
+        throw new SpawnfileError("runtime_error", `Agent ${manifest.name} does not declare a runtime`);
+    }
+    await assertRuntimeCanCompile(localRuntime.name);
+    return localRuntime;
+};
+export const normalizeDescription = (description) => description.replace(/\s+/g, " ").trim();
+const deriveDescriptionFromDocs = (docs) => {
+    const identity = docs.find((doc) => doc.role === "identity")?.content;
+    if (!identity) {
+        return "";
+    }
+    const paragraph = identity
+        .split(/\n\s*\n/)
+        .map((block) => normalizeDescription(block))
+        .find((block) => block.length > 0 && !/^#{1,6}\s+/.test(block));
+    if (!paragraph) {
+        return "";
+    }
+    return paragraph.length > 200 ? paragraph.slice(0, 200).trimEnd() : paragraph;
+};
+export const resolveDescription = (description, docs) => description !== undefined
+    ? normalizeDescription(description)
+    : deriveDescriptionFromDocs(docs);

package/dist/compiler/buildCompilePlanTeams.d.ts

@@ -0,0 +1,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 validateTeamNetworkRooms: (teamNode: ResolvedTeamNode) => void;

package/dist/compiler/buildCompilePlanTeams.js

@@ -0,0 +1,38 @@
+import { SpawnfileError } from "../shared/index.js";
+export const resolveTeamExternalIds = (manifest) => {
+    const memberIds = manifest.members.map((member) => member.id);
+    if (manifest.lead && !memberIds.includes(manifest.lead)) {
+        throw new SpawnfileError("validation_error", `Team ${manifest.name} lead references unknown member ${manifest.lead}`);
+    }
+    for (const externalMemberId of manifest.external ?? []) {
+        if (!memberIds.includes(externalMemberId)) {
+            throw new SpawnfileError("validation_error", `Team ${manifest.name} external representative references unknown member ${externalMemberId}`);
+        }
+    }
+    return manifest.external
+        ?? (manifest.mode === "hierarchical" && manifest.lead
+            ? [manifest.lead]
+            : memberIds);
+};
+export const resolveTeamNetworks = (manifest) => (manifest.networks ?? []).map((network) => ({
+    expose: network.expose ?? false,
+    id: network.id,
+    name: network.name ?? network.id,
+    provider: network.provider,
+    rooms: network.rooms.map((room) => ({
+        id: room.id,
+        members: [...room.members]
+    }))
+}));
+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) {
+                    throw new SpawnfileError("validation_error", `Team ${teamNode.name} Moltnet room ${room.id} references unknown member ${roomMemberId}`);
+                }
+            }
+        }
+    }
+};

package/dist/compiler/compilePlanHelpers.js

@@ -25,7 +25,10 @@ export const getAgentFingerprint = (node) => stableStringify({
 });
 export const getTeamFingerprint = (node) => stableStringify({
     members: node.members,
-    structure: node.structure,
+    mode: node.mode,
+    lead: node.lead,
+    external: node.external,
+    networks: node.networks ?? [],
     shared: {
         env: node.shared.env,
         mcpServers: node.shared.mcpServers,

package/dist/compiler/compileProject.js

@@ -1,23 +1,19 @@
 import path from "node:path";
 import { chmod } from "node:fs/promises";
-import { ensureDirectory, removeDirectory, writeUtf8File } from "../filesystem/index.js";
+import { ensureDirectory, removeDirectory } from "../filesystem/index.js";
 import { createCompileReport, createDiagnostic, writeCompileReport } from "../report/index.js";
 import { DEFAULT_OUTPUT_DIRECTORY } from "../shared/index.js";
 import { assertRuntimeCanCompile, createRuntimeLifecycleDiagnostics, getRuntimeAdapter } from "../runtime/index.js";
 import { buildCompilePlan } from "./buildCompilePlan.js";
 import { createContainerArtifacts } from "./containerArtifacts.js";
-const writeEmittedFiles = async (outputDirectory, files) => {
-    await Promise.all(files.map(async (file) => {
-        const targetPath = path.join(outputDirectory, file.path);
-        await ensureDirectory(path.dirname(targetPath));
-        await writeUtf8File(targetPath, file.content);
-    }));
-};
+import { injectMoltnetWorkspaceFiles, injectTeamCompileSupportFiles, prepareTeamCompileSupport, writeEmittedFiles } from "./compileProjectSupport.js";
+import { generateMoltnetArtifacts } from "./moltnetArtifacts.js";
+import { stageMoltnetBinaries } from "./moltnetBinaries.js";
 const createTeamCapabilities = (outcome, message) => [
     { key: "team.members", message, outcome },
-    { key: "team.structure.mode", message, outcome },
-    { key: "team.structure.leader", message, outcome },
-    { key: "team.structure.external", message, outcome },
+    { key: "team.mode", message, outcome },
+    { key: "team.lead", message, outcome },
+    { key: "team.external", message, outcome },
     { key: "team.shared", message, outcome },
     { key: "team.nested", message, outcome }
 ];
@@ -148,6 +144,46 @@ const enforcePolicy = (nodeReport, policyMode, onDegrade) => {
         }
     }
 };
+const createIdentityCapabilities = (node) => [
+    ...(node.surfaces?.slack?.identity
+        ? [{
+                key: "surfaces.slack.identity",
+                message: "Declared Slack identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.discord?.identity
+        ? [{
+                key: "surfaces.discord.identity",
+                message: "Declared Discord identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.telegram?.identity
+        ? [{
+                key: "surfaces.telegram.identity",
+                message: "Declared Telegram identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : []),
+    ...(node.surfaces?.whatsapp?.identity
+        ? [{
+                key: "surfaces.whatsapp.identity",
+                message: "Declared WhatsApp identity was preserved for roster output",
+                outcome: "supported"
+            }]
+        : [])
+];
+const augmentNodeReports = (compiledNodes, support) => {
+    for (const compiled of compiledNodes) {
+        if (compiled.value.kind === "team") {
+            compiled.report.capabilities.push(...(support.capabilitiesByTeamSource.get(compiled.value.source) ?? []));
+            compiled.report.diagnostics.push(...(support.diagnosticsByTeamSource.get(compiled.value.source) ?? []));
+            continue;
+        }
+        compiled.report.capabilities.push(...createIdentityCapabilities(compiled.value));
+    }
+};
 export const compileProject = async (inputPath, options = {}) => {
     const plan = await buildCompilePlan(inputPath);
     const outputDirectory = path.resolve(options.outputDirectory ?? DEFAULT_OUTPUT_DIRECTORY);
@@ -155,21 +191,34 @@ export const compileProject = async (inputPath, options = {}) => {
         await removeDirectory(outputDirectory);
     }
     await ensureDirectory(outputDirectory);
+    const teamCompileSupport = await prepareTeamCompileSupport(plan);
     const nodeReports = [];
     const compiledNodes = [];
     for (const node of plan.nodes) {
         let compiled;
         if (node.kind === "agent") {
             compiled = await compileAgentNode(outputDirectory, node);
+            await injectTeamCompileSupportFiles(outputDirectory, compiled, teamCompileSupport);
         }
         else {
             compiled = await compileTeamNode(outputDirectory, node);
         }
-        enforcePolicy(compiled.report, node.value.policyMode, node.value.policyOnDegrade);
         nodeReports.push(compiled.report);
         compiledNodes.push(compiled);
     }
-    const containerArtifacts = await createContainerArtifacts(plan, compiledNodes);
+    augmentNodeReports(compiledNodes, teamCompileSupport);
+    for (const compiled of compiledNodes) {
+        enforcePolicy(compiled.report, compiled.value.policyMode, compiled.value.policyOnDegrade);
+    }
+    const moltnetArtifacts = await generateMoltnetArtifacts(plan);
+    const hasStagedMoltnetBinaries = moltnetArtifacts
+        ? await stageMoltnetBinaries(outputDirectory)
+        : false;
+    await injectMoltnetWorkspaceFiles(outputDirectory, compiledNodes, moltnetArtifacts);
+    const containerArtifacts = await createContainerArtifacts(plan, compiledNodes, {
+        hasStagedMoltnetBinaries,
+        moltnet: moltnetArtifacts
+    });
     await writeEmittedFiles(outputDirectory, containerArtifacts.files);
     await Promise.all(containerArtifacts.executablePaths.map((filePath) => chmod(path.join(outputDirectory, filePath), 0o755)));
     const report = createCompileReport(plan.root, nodeReports, [], containerArtifacts.report);

package/dist/compiler/compileProjectSupport.d.ts

@@ -0,0 +1,17 @@
+import { type EmittedFile } from "../runtime/index.js";
+import type { MoltnetArtifacts } from "./moltnetArtifacts.js";
+import type { TeamCompileSupport } from "./teamContextSupport.js";
+import type { ResolvedAgentNode, ResolvedTeamNode } from "./types.js";
+export { prepareTeamCompileSupport } from "./teamContextSupport.js";
+export type { TeamCompileSupport } from "./teamContextSupport.js";
+export interface CompiledNodeOutput {
+    emittedFiles: EmittedFile[];
+    kind: "agent" | "team";
+    report: {
+        output_dir: string | null;
+    };
+    value: ResolvedAgentNode | ResolvedTeamNode;
+}
+export declare const writeEmittedFiles: (outputDirectory: string, files: EmittedFile[]) => Promise<void>;
+export declare const injectTeamCompileSupportFiles: (outputDirectory: string, compiled: CompiledNodeOutput, support: TeamCompileSupport) => Promise<void>;
+export declare const injectMoltnetWorkspaceFiles: (outputDirectory: string, compiledNodes: CompiledNodeOutput[], artifacts: MoltnetArtifacts | null) => Promise<void>;

package/dist/compiler/compileProjectSupport.js

@@ -0,0 +1,136 @@
+import { execFile as execFileCallback } from "node:child_process";
+import { chmod, readFile } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { ensureDirectory, writeUtf8File } from "../filesystem/index.js";
+import { getRuntimeAdapter } from "../runtime/index.js";
+import { SpawnfileError } from "../shared/index.js";
+import { resolveMoltnetCliCommand } from "./moltnetBinaries.js";
+import { createMoltnetClientConfigFiles, resolveMoltnetWorkspaceLayout } from "./moltnetClientConfig.js";
+export { prepareTeamCompileSupport } from "./teamContextSupport.js";
+const execFile = promisify(execFileCallback);
+const resolveAgentWorkspacePaths = (node) => {
+    const systemInstructionSurface = getRuntimeAdapter(node.runtime.name).systemInstructionSurface;
+    if (!systemInstructionSurface) {
+        return null;
+    }
+    const systemInstructionPath = systemInstructionSurface.resolvePath({ node });
+    const systemInstructionDirectory = path.posix.dirname(systemInstructionPath);
+    return {
+        systemInstructionPath,
+        spawnfileDirectory: systemInstructionDirectory === "."
+            ? ".spawnfile"
+            : `${systemInstructionDirectory}/.spawnfile`
+    };
+};
+const upsertEmittedFile = (emittedFiles, nextFile) => {
+    const existing = emittedFiles.find((file) => file.path === nextFile.path);
+    if (existing) {
+        existing.content = nextFile.content;
+        return existing;
+    }
+    emittedFiles.push(nextFile);
+    return nextFile;
+};
+export const writeEmittedFiles = async (outputDirectory, files) => {
+    await Promise.all(files.map(async (file) => {
+        const targetPath = path.join(outputDirectory, file.path);
+        await ensureDirectory(path.dirname(targetPath));
+        await writeUtf8File(targetPath, file.content);
+        if (file.mode !== undefined) {
+            await chmod(targetPath, file.mode);
+        }
+    }));
+};
+export const injectTeamCompileSupportFiles = async (outputDirectory, compiled, support) => {
+    if (compiled.kind !== "agent" ||
+        compiled.value.kind !== "agent" ||
+        !compiled.report.output_dir) {
+        return;
+    }
+    const supportFiles = support.filesByAgentSource.get(compiled.value.source);
+    if (!supportFiles || supportFiles.length === 0) {
+        return;
+    }
+    const workspacePaths = resolveAgentWorkspacePaths(compiled.value);
+    if (!workspacePaths) {
+        return;
+    }
+    const filesToWrite = supportFiles.map((file) => upsertEmittedFile(compiled.emittedFiles, {
+        ...file,
+        path: file.path.startsWith(".spawnfile/") || file.path === "TEAM.md"
+            ? path.posix.join(path.posix.dirname(workspacePaths.spawnfileDirectory), file.path)
+            : file.path
+    }));
+    const rosterBlock = "\n\n<!-- spawnfile-team-context:start -->\n" +
+        "## Spawnfile Team Context\n\n" +
+        "Read `.spawnfile/team-contexts.md` and `.spawnfile/team-contexts.yaml` for generated team membership, representative context, and surface bindings.\n" +
+        "<!-- spawnfile-team-context:end -->\n";
+    const existingAgentsMd = compiled.emittedFiles.find((file) => file.path === workspacePaths.systemInstructionPath);
+    filesToWrite.push(existingAgentsMd
+        ? (() => {
+            existingAgentsMd.content += rosterBlock;
+            return existingAgentsMd;
+        })()
+        : upsertEmittedFile(compiled.emittedFiles, {
+            content: rosterBlock.trimStart(),
+            path: workspacePaths.systemInstructionPath
+        }));
+    await writeEmittedFiles(path.join(outputDirectory, compiled.report.output_dir), filesToWrite);
+};
+export const injectMoltnetWorkspaceFiles = async (outputDirectory, compiledNodes, artifacts) => {
+    if (!artifacts) {
+        return;
+    }
+    let moltnetCliCommand = null;
+    for (const compiled of compiledNodes) {
+        if (compiled.kind !== "agent" ||
+            compiled.value.kind !== "agent" ||
+            !compiled.report.output_dir) {
+            continue;
+        }
+        const runtimeOutputDirectory = path.join(outputDirectory, compiled.report.output_dir);
+        const moltnetClientConfigFiles = createMoltnetClientConfigFiles(compiled.value, artifacts);
+        if (moltnetClientConfigFiles.length === 0) {
+            continue;
+        }
+        const layout = resolveMoltnetWorkspaceLayout(compiled.value.runtime.name, compiled.value.name);
+        const workspacePath = path.join(runtimeOutputDirectory, layout.workspaceRootPath);
+        for (const file of moltnetClientConfigFiles) {
+            upsertEmittedFile(compiled.emittedFiles, file);
+        }
+        await writeEmittedFiles(runtimeOutputDirectory, moltnetClientConfigFiles);
+        if (!moltnetCliCommand) {
+            moltnetCliCommand = await resolveMoltnetCliCommand();
+        }
+        try {
+            await execFile(moltnetCliCommand, [
+                "skill",
+                "install",
+                "--runtime",
+                layout.cliRuntime,
+                "--workspace",
+                workspacePath
+            ]);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            throw new SpawnfileError("compile_error", `Unable to install the Moltnet skill into ${compiled.value.name}: ${reason}`);
+        }
+        const moltnetSkillFiles = await Promise.all(layout.skillPaths.map(async (filePath) => {
+            try {
+                return {
+                    content: await readFile(path.join(runtimeOutputDirectory, filePath), "utf8"),
+                    path: filePath
+                };
+            }
+            catch (error) {
+                const reason = error instanceof Error ? error.message : String(error);
+                throw new SpawnfileError("compile_error", `Moltnet skill install for ${compiled.value.name} did not produce ${filePath}: ${reason}`);
+            }
+        }));
+        for (const file of moltnetSkillFiles) {
+            upsertEmittedFile(compiled.emittedFiles, file);
+        }
+    }
+};

package/dist/compiler/containerArtifacts.d.ts

@@ -1,4 +1,9 @@
+import type { MoltnetArtifacts } from "./moltnetArtifacts.js";
 import type { CompiledNodeArtifact, GeneratedContainerArtifacts } from "./containerArtifactsTypes.js";
 import type { CompilePlan } from "./types.js";
 export type { CompiledNodeArtifact, GeneratedContainerArtifacts } from "./containerArtifactsTypes.js";
-export declare const createContainerArtifacts: (plan: CompilePlan, compiledNodes: CompiledNodeArtifact[]) => Promise<GeneratedContainerArtifacts>;
+export interface ContainerArtifactOptions {
+    hasStagedMoltnetBinaries?: boolean;
+    moltnet?: MoltnetArtifacts | null;
+}
+export declare const createContainerArtifacts: (plan: CompilePlan, compiledNodes: CompiledNodeArtifact[], options?: ContainerArtifactOptions) => Promise<GeneratedContainerArtifacts>;

package/dist/compiler/containerArtifacts.js

@@ -1,6 +1,6 @@
 import { createEnvVariableMap, createRuntimeTargetPlans } from "./containerArtifactsPlans.js";
 import { createRootfsFiles, renderDockerfile, renderEntrypoint, renderEnvExample } from "./containerArtifactsRender.js";
-export const createContainerArtifacts = async (plan, compiledNodes) => {
+export const createContainerArtifacts = async (plan, compiledNodes, options = {}) => {
     const runtimePlans = await createRuntimeTargetPlans(plan, compiledNodes);
     const envVariables = [...createEnvVariableMap(compiledNodes, runtimePlans).values()].sort((left, right) => left.name.localeCompare(right.name));
     const requiredSecrets = envVariables
@@ -17,12 +17,24 @@ export const createContainerArtifacts = async (plan, compiledNodes) => {
         .sort();
     const files = [
         ...createRootfsFiles(runtimePlans),
+        ...(options.moltnet?.files ?? []),
         {
-            content: await renderDockerfile(runtimePlans),
+            content: await renderDockerfile(runtimePlans, {
+                hasMoltnet: Boolean(options.moltnet),
+                hasStagedMoltnetBinaries: options.hasStagedMoltnetBinaries,
+                moltnetPublishedPorts: options.moltnet?.publishedPorts ?? []
+            }),
             path: "Dockerfile"
         },
         {
-            content: renderEntrypoint(runtimePlans, requiredSecrets.filter((secretName) => !modelSecretsRequired.includes(secretName))),
+            content: renderEntrypoint(runtimePlans, requiredSecrets.filter((secretName) => !modelSecretsRequired.includes(secretName)), {
+                moltnet: options.moltnet
+                    ? {
+                        bridgePlans: options.moltnet.bridgePlans,
+                        serverPlans: options.moltnet.serverPlans
+                    }
+                    : undefined
+            }),
             path: "entrypoint.sh"
         },
         {
@@ -30,7 +42,9 @@ export const createContainerArtifacts = async (plan, compiledNodes) => {
             path: ".env.example"
         }
     ];
-    const ports = [...new Set(runtimePlans.flatMap((plan) => (plan.port ? [plan.port] : [])))].sort((left, right) => left - right);
+    const runtimePorts = runtimePlans.flatMap((plan) => plan.publishedPort ? [plan.publishedPort] : []);
+    const moltnetPorts = options.moltnet?.publishedPorts ?? [];
+    const ports = [...new Set([...runtimePorts, ...moltnetPorts])].sort((left, right) => left - right);
     const runtimeHomes = [
         ...new Set(runtimePlans.flatMap((plan) => (plan.instancePaths.homePath ? [plan.instancePaths.homePath] : [])))
     ].sort();
@@ -48,6 +62,14 @@ export const createContainerArtifacts = async (plan, compiledNodes) => {
     return {
         executablePaths: ["entrypoint.sh"],
         files,
+        ...(options.moltnet
+            ? {
+                moltnet: {
+                    bridgePlans: options.moltnet.bridgePlans,
+                    serverPlans: options.moltnet.serverPlans
+                }
+            }
+            : {}),
         report: {
             dockerfile: "Dockerfile",
             entrypoint: "entrypoint.sh",

package/dist/compiler/containerArtifactsPlans.js

@@ -76,6 +76,9 @@ export const createEnvVariableMap = (compiledNodes, runtimePlans) => {
         for (const variable of runtimePlan.meta.env ?? []) {
             register(variable.name, variable.required, variable.description, "runtime");
         }
+        for (const binding of runtimePlan.targetConfigEnvBindings ?? []) {
+            register(binding.envName, true, `Injected into ${runtimePlan.runtimeName} runtime config`, "runtime");
+        }
     }
     return variables;
 };
@@ -115,6 +118,13 @@ const resolveTargetModelAuthMethods = (target, inputs) => {
     }
     return Object.fromEntries([...methods.entries()].sort(([left], [right]) => left.localeCompare(right)));
 };
+const resolveTargetExposure = (target, inputs) => {
+    const sourceIds = new Set(target.sourceIds ?? []);
+    if (sourceIds.size === 0) {
+        return false;
+    }
+    return inputs.some((input) => sourceIds.has(input.id) && input.value.kind === "agent" && input.value.expose === true);
+};
 export const createRuntimeTargetPlans = async (plan, compiledNodes) => {
     const runtimeNames = Object.keys(plan.runtimes).sort();
     const runtimePlans = [];
@@ -135,6 +145,7 @@ export const createRuntimeTargetPlans = async (plan, compiledNodes) => {
         targets.forEach((target, index) => {
             assertTargetHasConfig(runtimeName, target.id, adapter.container, target.files);
             const instancePaths = resolveInstancePaths(runtimeName, target.id, adapter.container);
+            const portStride = adapter.container.portStride ?? 1;
             runtimePlans.push({
                 configEnvBindings: resolveTargetConfigEnvBindings(adapter.container, target) ?? [],
                 envFiles: resolveTargetEnvFiles(instancePaths.configPath, target),
@@ -143,9 +154,13 @@ export const createRuntimeTargetPlans = async (plan, compiledNodes) => {
                 meta: adapter.container,
                 modelAuthMethods: resolveTargetModelAuthMethods(target, targetInputs),
                 modelSecretsRequired: resolveTargetModelSecrets(target, targetInputs),
-                port: adapter.container.port ? adapter.container.port + index : undefined,
+                port: adapter.container.port ? adapter.container.port + (index * portStride) : undefined,
+                publishedPort: resolveTargetExposure(target, targetInputs) && adapter.container.port
+                    ? adapter.container.port + (index * portStride)
+                    : undefined,
                 runtimeName,
                 runtimeRoot: recipe.runtimeRoot,
+                targetConfigEnvBindings: target.configEnvBindings,
                 targetFiles: target.files
             });
         });

package/dist/compiler/containerArtifactsRender.d.ts

@@ -1,6 +1,8 @@
 import type { EmittedFile } from "../runtime/index.js";
 import type { ContainerEnvVariable, RuntimeTargetPlan } from "./containerArtifactsTypes.js";
+import type { EntrypointOptions } from "./containerEntrypointRender.js";
+export { renderEntrypoint } from "./containerEntrypointRender.js";
+export type { EntrypointOptions } from "./containerEntrypointRender.js";
 export declare const renderEnvExample: (variables: ContainerEnvVariable[]) => string;
-export declare const renderDockerfile: (runtimePlans: RuntimeTargetPlan[]) => Promise<string>;
+export declare const renderDockerfile: (runtimePlans: RuntimeTargetPlan[], options?: EntrypointOptions) => Promise<string>;
 export declare const createRootfsFiles: (runtimePlans: RuntimeTargetPlan[]) => EmittedFile[];
-export declare const renderEntrypoint: (runtimePlans: RuntimeTargetPlan[], requiredSecrets: string[]) => string;