spawnfile 0.1.1 → 0.1.2

package/dist/cli/runCli.js

@@ -1,8 +1,11 @@
 import { Command } from "commander";
 import { importClaudeCodeAuth, importCodexAuth, importEnvFile, requireAuthProfile } from "../auth/index.js";
-import { addAgentProject, addProjectModelFallback, addSubagentProject, addTeamProject, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, runProject, setProjectPrimaryModel, syncProjectAuth } from "../compiler/index.js";
+import { addAgentProject, addProjectSurface, addProjectModelFallback, addSubagentProject, addTeamProject, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, removeProjectSurface, runProject, setProjectPrimaryModel, setProjectRuntime, setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth } from "../compiler/index.js";
 import { isSpawnfileError } from "../shared/index.js";
 import { listRuntimeAdapters } from "../runtime/index.js";
+import { registerModelCommands } from "./modelCommands.js";
+import { registerRuntimeCommands } from "./runtimeCommands.js";
+import { registerSurfaceCommands } from "./surfaceCommands.js";
 const createDefaultStreams = () => ({
     stderr: (message) => process.stderr.write(`${message}\n`),
     stdout: (message) => process.stdout.write(`${message}\n`)
@@ -13,6 +16,7 @@ const createDefaultHandlers = () => ({
     compileProject,
     addAgentProject,
     addProjectModelFallback,
+    addProjectSurface,
     addSubagentProject,
     addTeamProject,
     clearProjectModelFallbacks,
@@ -21,9 +25,13 @@ const createDefaultHandlers = () => ({
     importEnvFile,
     initProject,
     listRuntimeAdapters,
+    removeProjectSurface,
     requireAuthProfile,
     runProject,
     setProjectPrimaryModel,
+    setProjectRuntime,
+    setProjectSurfaceAccess,
+    showProjectSurfaces,
     syncProjectAuth
 });
 const formatPlanSummary = (plan) => [
@@ -155,72 +163,9 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
             streams.stdout(`created ${filePath}`);
         }
     });
-    const modelCommand = program
-        .command("model")
-        .description("Edit primary and fallback model declarations");
-    modelCommand
-        .command("set")
-        .argument("<provider>", "Model provider")
-        .argument("<name>", "Model name")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .option("--auth <method>", "Model auth method")
-        .option("--key <env>", "Environment variable for api_key auth")
-        .option("--compat <compatibility>", "Endpoint compatibility for custom/local models")
-        .option("--base-url <url>", "Endpoint base URL for custom/local models")
-        .option("--recursive", "Update the target project and its descendants")
-        .action(async (provider, name, inputPath, options) => {
-        const result = await handlers.setProjectPrimaryModel({
-            authKey: options.key,
-            authMethod: options.auth,
-            endpointBaseUrl: options.baseUrl,
-            endpointCompatibility: options.compat,
-            name,
-            path: inputPath,
-            provider,
-            recursive: options.recursive
-        });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
-    });
-    modelCommand
-        .command("add-fallback")
-        .argument("<provider>", "Model provider")
-        .argument("<name>", "Model name")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .option("--auth <method>", "Model auth method")
-        .option("--key <env>", "Environment variable for api_key auth")
-        .option("--compat <compatibility>", "Endpoint compatibility for custom/local models")
-        .option("--base-url <url>", "Endpoint base URL for custom/local models")
-        .option("--recursive", "Update the target project and its descendants")
-        .action(async (provider, name, inputPath, options) => {
-        const result = await handlers.addProjectModelFallback({
-            authKey: options.key,
-            authMethod: options.auth,
-            endpointBaseUrl: options.baseUrl,
-            endpointCompatibility: options.compat,
-            name,
-            path: inputPath,
-            provider,
-            recursive: options.recursive
-        });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
-    });
-    modelCommand
-        .command("clear-fallbacks")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .option("--recursive", "Update the target project and its descendants")
-        .action(async (inputPath, options) => {
-        const result = await handlers.clearProjectModelFallbacks({
-            path: inputPath,
-            recursive: options.recursive
-        });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
-    });
+    registerModelCommands(program, handlers, streams);
+    registerRuntimeCommands(program, handlers, streams);
+    registerSurfaceCommands(program, handlers, streams);
     program
         .command("validate")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())

package/dist/cli/runtimeCommands.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { CliHandlers, CliStreams } from "./runCli.js";
+export declare const registerRuntimeCommands: (program: Command, handlers: CliHandlers, streams: CliStreams) => void;

package/dist/cli/runtimeCommands.js

@@ -0,0 +1,20 @@
+export const registerRuntimeCommands = (program, handlers, streams) => {
+    const runtimeCommand = program
+        .command("runtime")
+        .description("Edit runtime declarations");
+    runtimeCommand
+        .command("set")
+        .argument("<name>", "Runtime name")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--recursive", "Update the target project and its descendants")
+        .action(async (runtime, inputPath, options) => {
+        const result = await handlers.setProjectRuntime({
+            path: inputPath,
+            recursive: options.recursive,
+            runtime
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+    });
+};

package/dist/cli/surfaceCommands.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+import type { CliHandlers, CliStreams } from "./runCli.js";
+export declare const registerSurfaceCommands: (program: Command, handlers: CliHandlers, streams: CliStreams) => void;

package/dist/cli/surfaceCommands.js

@@ -0,0 +1,98 @@
+import YAML from "yaml";
+import { resolvePortableSurfaceName } from "../compiler/index.js";
+const collectStringOption = (value, previous) => [...previous, value];
+const emitSurfaceSummaries = (streams, entries) => {
+    entries.forEach((entry, index) => {
+        if (index > 0) {
+            streams.stdout("");
+        }
+        streams.stdout(`path: ${entry.manifestPath}`);
+        streams.stdout(`kind: ${entry.kind}`);
+        streams.stdout(`name: ${entry.name}`);
+        if (!entry.surfaces) {
+            streams.stdout("surfaces: none");
+            return;
+        }
+        streams.stdout(YAML.stringify({ surfaces: entry.surfaces }).trimEnd());
+    });
+};
+export const registerSurfaceCommands = (program, handlers, streams) => {
+    const surfaceCommand = program
+        .command("surface")
+        .description("Edit agent surfaces");
+    surfaceCommand
+        .command("add")
+        .argument("<surface>", "Surface name")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--bot-token-secret <env>", "Override the bot token env var name")
+        .option("--app-token-secret <env>", "Override the Slack app token env var name")
+        .option("--recursive", "Update the target project and its descendants")
+        .action(async (surface, inputPath, options) => {
+        const surfaceName = resolvePortableSurfaceName(surface);
+        const result = await handlers.addProjectSurface({
+            appTokenSecret: options.appTokenSecret,
+            botTokenSecret: options.botTokenSecret,
+            path: inputPath,
+            recursive: options.recursive,
+            surface: surfaceName
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+    });
+    surfaceCommand
+        .command("remove")
+        .argument("<surface>", "Surface name")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--recursive", "Update the target project and its descendants")
+        .action(async (surface, inputPath, options) => {
+        const surfaceName = resolvePortableSurfaceName(surface);
+        const result = await handlers.removeProjectSurface({
+            path: inputPath,
+            recursive: options.recursive,
+            surface: surfaceName
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+    });
+    surfaceCommand
+        .command("set-access")
+        .argument("<surface>", "Surface name")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .requiredOption("--mode <mode>", "Access mode")
+        .option("--user <id>", "Allowlisted user id", collectStringOption, [])
+        .option("--channel <id>", "Allowlisted channel id", collectStringOption, [])
+        .option("--guild <id>", "Allowlisted guild id", collectStringOption, [])
+        .option("--chat <id>", "Allowlisted chat id", collectStringOption, [])
+        .option("--group <id>", "Allowlisted group id", collectStringOption, [])
+        .option("--recursive", "Update the target project and its descendants")
+        .action(async (surface, inputPath, options) => {
+        const surfaceName = resolvePortableSurfaceName(surface);
+        const result = await handlers.setProjectSurfaceAccess({
+            channels: options.channel,
+            chats: options.chat,
+            groups: options.group,
+            guilds: options.guild,
+            mode: options.mode,
+            path: inputPath,
+            recursive: options.recursive,
+            surface: surfaceName,
+            users: options.user
+        });
+        for (const filePath of result.updatedFiles) {
+            streams.stdout(`updated ${filePath}`);
+        }
+    });
+    surfaceCommand
+        .command("show")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--recursive", "Show descendant agent surfaces too")
+        .action(async (inputPath, options) => {
+        const result = await handlers.showProjectSurfaces({
+            path: inputPath,
+            recursive: options.recursive
+        });
+        emitSurfaceSummaries(streams, result.entries);
+    });
+};

package/dist/compiler/agentSurfaces.js

@@ -5,6 +5,7 @@ export const resolveAgentSurfaces = (surfaces) => {
     }
     const resolved = {};
     if (surfaces.discord) {
+        const identity = surfaces.discord.identity;
         resolved.discord = {
             ...(surfaces.discord.access
                 ? {
@@ -16,10 +17,41 @@ export const resolveAgentSurfaces = (surfaces) => {
                     }
                 }
                 : {}),
-            botTokenSecret: surfaces.discord.bot_token_secret ?? DEFAULT_DISCORD_BOT_TOKEN_SECRET
+            botTokenSecret: surfaces.discord.bot_token_secret ?? DEFAULT_DISCORD_BOT_TOKEN_SECRET,
+            ...(identity ? { identity: { userId: identity.user_id } } : {})
         };
     }
+    if (surfaces.moltnet) {
+        resolved.moltnet = surfaces.moltnet.map((attachment) => ({
+            ...(attachment.dms
+                ? {
+                    dms: {
+                        enabled: attachment.dms.enabled,
+                        ...(attachment.dms.read ? { read: attachment.dms.read } : {}),
+                        ...(attachment.dms.reply ? { reply: attachment.dms.reply } : {})
+                    }
+                }
+                : {}),
+            memberId: null,
+            network: attachment.network,
+            ...(attachment.rooms
+                ? {
+                    rooms: Object.fromEntries(Object.entries(attachment.rooms)
+                        .sort(([left], [right]) => left.localeCompare(right))
+                        .map(([roomId, behavior]) => [
+                        roomId,
+                        {
+                            ...(behavior.read ? { read: behavior.read } : {}),
+                            ...(behavior.reply ? { reply: behavior.reply } : {})
+                        }
+                    ]))
+                }
+                : {}),
+            teamSource: null
+        }));
+    }
     if (surfaces.telegram) {
+        const identity = surfaces.telegram.identity;
         resolved.telegram = {
             ...(surfaces.telegram.access
                 ? {
@@ -30,21 +62,34 @@ export const resolveAgentSurfaces = (surfaces) => {
                     }
                 }
                 : {}),
-            botTokenSecret: surfaces.telegram.bot_token_secret ?? DEFAULT_TELEGRAM_BOT_TOKEN_SECRET
+            botTokenSecret: surfaces.telegram.bot_token_secret ?? DEFAULT_TELEGRAM_BOT_TOKEN_SECRET,
+            ...(identity
+                ? {
+                    identity: {
+                        ...(identity.user_id ? { userId: identity.user_id } : {}),
+                        ...(identity.username ? { username: identity.username } : {})
+                    }
+                }
+                : {})
         };
     }
     if (surfaces.whatsapp) {
+        const identity = surfaces.whatsapp.identity;
         resolved.whatsapp = surfaces.whatsapp.access
             ? {
                 access: {
                     groups: [...(surfaces.whatsapp.access.groups ?? [])],
                     mode: surfaces.whatsapp.access.mode ?? "allowlist",
                     users: [...(surfaces.whatsapp.access.users ?? [])]
-                }
+                },
+                ...(identity ? { identity: { phone: identity.phone } } : {})
             }
-            : {};
+            : {
+                ...(identity ? { identity: { phone: identity.phone } } : {})
+            };
     }
     if (surfaces.slack) {
+        const identity = surfaces.slack.identity;
         resolved.slack = {
             ...(surfaces.slack.access
                 ? {
@@ -56,7 +101,8 @@ export const resolveAgentSurfaces = (surfaces) => {
                 }
                 : {}),
             appTokenSecret: surfaces.slack.app_token_secret ?? DEFAULT_SLACK_APP_TOKEN_SECRET,
-            botTokenSecret: surfaces.slack.bot_token_secret ?? DEFAULT_SLACK_BOT_TOKEN_SECRET
+            botTokenSecret: surfaces.slack.bot_token_secret ?? DEFAULT_SLACK_BOT_TOKEN_SECRET,
+            ...(identity ? { identity: { userId: identity.user_id } } : {})
         };
     }
     return Object.keys(resolved).length > 0 ? resolved : undefined;

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,16 @@ 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 { 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 +55,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 +123,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 +181,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 +205,7 @@ export const buildCompilePlan = async (inputPath) => {
                 to: resolvedMember.nodeSource
             });
         }
+        validateTeamNetworkRooms(candidate);
         visitStack.pop();
         return candidate;
     };
@@ -249,10 +242,13 @@ 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
     };
+    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,