spawnfile 0.1.2 → 0.1.4

package/README.md

@@ -34,6 +34,7 @@ Node.js 22+ required. See [source install](#from-source) for local development.
 ```bash
 spawnfile init                                   # scaffold an agent (defaults to openclaw)
 spawnfile validate                               # check the graph
+spawnfile view .                                 # read-only graph view; writes no files
 spawnfile compile                                # lower to runtime-native output
 spawnfile auth sync --profile dev --env-file .env
 spawnfile build  --tag my-agent                  # compile + docker build
@@ -42,6 +43,8 @@ spawnfile run    --tag my-agent --auth-profile dev
 
 Compiled output lands under `.spawn/` by default, including a `Dockerfile`, `entrypoint.sh`, `.env.example`, and a prebuilt `container/rootfs/` tree. `spawnfile build` uses the pinned runtime artifacts from `runtimes.yaml`; it does not rebuild runtimes from source.
 
+Declare external credentials in `secrets:` and provide values through an ignored env file or the shell environment. `spawnfile auth sync --env-file .env` stores declared model auth and project secrets in a local auth profile; `spawnfile run --env-file .env` can inject the same values directly for a single run. This is the intended pattern for credentials like `GH_TOKEN`, MCP tokens, and provider API keys.
+
 ## Project structure
 
 A Spawnfile project is either an `agent` or a `team`.

package/dist/cli/runCli.d.ts

@@ -1,12 +1,18 @@
 import { importClaudeCodeAuth, importCodexAuth, importEnvFile, requireAuthProfile } from "../auth/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 { addAgentProject, addProjectSurface, addProjectModelFallback, addSubagentProject, addTeamProject, buildOrganizationView, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, removeProjectSurface, runProject, setProjectPrimaryModel, setProjectRuntime, setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth } from "../compiler/index.js";
 import { listRuntimeAdapters } from "../runtime/index.js";
 export interface CliStreams {
     stderr: (message: string) => void;
     stdout: (message: string) => void;
 }
+export interface CliRenderEnvironment {
+    ci: boolean;
+    noColor: boolean;
+    stdoutIsTty: boolean;
+}
 export interface CliHandlers {
     buildCompilePlan: typeof buildCompilePlan;
+    buildOrganizationView: typeof buildOrganizationView;
     buildProject: typeof buildProject;
     compileProject: typeof compileProject;
     addAgentProject: typeof addAgentProject;
@@ -29,4 +35,14 @@ export interface CliHandlers {
     showProjectSurfaces: typeof showProjectSurfaces;
     syncProjectAuth: typeof syncProjectAuth;
 }
-export declare const runCli: (argv: string[], streams?: CliStreams, handlerOverrides?: Partial<CliHandlers>) => Promise<number>;
+export interface RunCliOptions {
+    handlers?: Partial<CliHandlers>;
+    renderEnvironment?: CliRenderEnvironment;
+    streams?: CliStreams;
+}
+type RunCli = {
+    (argv: string[], options?: RunCliOptions): Promise<number>;
+    (argv: string[], streams?: CliStreams, handlerOverrides?: Partial<CliHandlers>): Promise<number>;
+};
+export declare const runCli: RunCli;
+export {};

package/dist/cli/runCli.js

@@ -1,39 +1,60 @@
 import { Command } from "commander";
 import { importClaudeCodeAuth, importCodexAuth, importEnvFile, requireAuthProfile } from "../auth/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 { addAgentProject, addProjectSurface, addProjectModelFallback, addSubagentProject, addTeamProject, buildOrganizationView, 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";
+import { registerViewCommand } from "./viewCommand.js";
 const createDefaultStreams = () => ({
     stderr: (message) => process.stderr.write(`${message}\n`),
     stdout: (message) => process.stdout.write(`${message}\n`)
 });
+const createDefaultRenderEnvironment = () => ({
+    ci: process.env.CI !== undefined && process.env.CI !== "" && process.env.CI !== "0",
+    noColor: process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== "",
+    stdoutIsTty: process.stdout.isTTY === true
+});
 const createDefaultHandlers = () => ({
-    buildCompilePlan,
-    buildProject,
-    compileProject,
-    addAgentProject,
-    addProjectModelFallback,
-    addProjectSurface,
-    addSubagentProject,
-    addTeamProject,
-    clearProjectModelFallbacks,
-    importClaudeCodeAuth,
-    importCodexAuth,
-    importEnvFile,
-    initProject,
-    listRuntimeAdapters,
-    removeProjectSurface,
-    requireAuthProfile,
-    runProject,
-    setProjectPrimaryModel,
-    setProjectRuntime,
-    setProjectSurfaceAccess,
-    showProjectSurfaces,
-    syncProjectAuth
+    buildCompilePlan, buildOrganizationView, buildProject, compileProject,
+    addAgentProject, addProjectModelFallback, addProjectSurface,
+    addSubagentProject, addTeamProject, clearProjectModelFallbacks,
+    importClaudeCodeAuth, importCodexAuth, importEnvFile,
+    initProject, listRuntimeAdapters, removeProjectSurface, requireAuthProfile,
+    runProject, setProjectPrimaryModel, setProjectRuntime,
+    setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth
 });
+const isCliStreams = (value) => {
+    const candidate = value;
+    return typeof candidate?.stderr === "function" && typeof candidate.stdout === "function";
+};
+const normalizeRunCliOptions = (optionsOrStreams, handlerOverrides = {}) => isCliStreams(optionsOrStreams)
+    ? {
+        handlers: handlerOverrides,
+        renderEnvironment: createDefaultRenderEnvironment(),
+        streams: optionsOrStreams
+    }
+    : {
+        handlers: optionsOrStreams?.handlers ?? handlerOverrides,
+        renderEnvironment: optionsOrStreams?.renderEnvironment ?? createDefaultRenderEnvironment(),
+        streams: optionsOrStreams?.streams ?? createDefaultStreams()
+    };
+const writeCommanderOutput = (write, message) => {
+    const normalized = message.replace(/\n$/, "");
+    if (normalized.length > 0) {
+        write(normalized);
+    }
+};
+const isCommanderError = (error) => {
+    if (typeof error !== "object" || error === null) {
+        return false;
+    }
+    const candidate = error;
+    return typeof candidate.code === "string"
+        && candidate.code.startsWith("commander.")
+        && typeof candidate.exitCode === "number";
+};
 const formatPlanSummary = (plan) => [
     `root: ${plan.root}`,
     `nodes: ${plan.nodes.length}`,
@@ -48,10 +69,20 @@ const formatAuthProfileSummary = (profile) => {
         `imports: ${importedKinds.length > 0 ? importedKinds.join(", ") : "none"}`
     ];
 };
-export const runCli = async (argv, streams = createDefaultStreams(), handlerOverrides = {}) => {
-    const handlers = { ...createDefaultHandlers(), ...handlerOverrides };
+const emitLines = (streams, lines) => lines.forEach((line) => streams.stdout(line));
+const emitFileLines = (streams, label, filePaths) => emitLines(streams, filePaths.map((filePath) => `${label} ${filePath}`));
+export const runCli = async (argv, optionsOrStreams, handlerOverrides = {}) => {
+    const cliOptions = normalizeRunCliOptions(optionsOrStreams, handlerOverrides);
+    const streams = cliOptions.streams;
+    const handlers = { ...createDefaultHandlers(), ...cliOptions.handlers };
     const program = new Command();
     program.name("spawnfile").description("Spawnfile v0.1 compiler");
+    program.exitOverride();
+    program.configureOutput({
+        outputError: (message, write) => write(message),
+        writeErr: (message) => writeCommanderOutput(streams.stderr, message),
+        writeOut: (message) => writeCommanderOutput(streams.stdout, message)
+    });
     program
         .command("compile")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())
@@ -82,12 +113,14 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
         .option("-t, --tag <image>", "Docker image tag")
         .option("--auth-profile <name>", "Local Spawnfile auth profile")
         .option("--name <container>", "Docker container name")
+        .option("--env-file <file>", "Path to an env file for runtime secrets")
         .option("-d, --detach", "Run the container in detached mode")
         .action(async (inputPath, options) => {
         const result = await handlers.runProject(inputPath, {
             authProfile: options.authProfile,
             containerName: options.name,
             detach: options.detach,
+            envFilePath: options.envFile,
             imageTag: options.tag,
             outputDirectory: options.out
         });
@@ -108,9 +141,7 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
             team: options.team
         });
         streams.stdout(`initialized ${result.directory}`);
-        for (const filePath of result.createdFiles) {
-            streams.stdout(`created ${filePath}`);
-        }
+        emitFileLines(streams, "created", result.createdFiles);
     });
     const addCommand = program.command("add").description("Add children to an existing Spawnfile project");
     addCommand
@@ -124,12 +155,8 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
             path: inputPath,
             runtime: options.runtime
         });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
-        for (const filePath of result.createdFiles) {
-            streams.stdout(`created ${filePath}`);
-        }
+        emitFileLines(streams, "updated", result.updatedFiles);
+        emitFileLines(streams, "created", result.createdFiles);
     });
     addCommand
         .command("subagent")
@@ -140,12 +167,8 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
             id,
             path: inputPath
         });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
-        for (const filePath of result.createdFiles) {
-            streams.stdout(`created ${filePath}`);
-        }
+        emitFileLines(streams, "updated", result.updatedFiles);
+        emitFileLines(streams, "created", result.createdFiles);
     });
     addCommand
         .command("team")
@@ -156,16 +179,13 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
             id,
             path: inputPath
         });
-        for (const filePath of result.updatedFiles) {
-            streams.stdout(`updated ${filePath}`);
-        }
-        for (const filePath of result.createdFiles) {
-            streams.stdout(`created ${filePath}`);
-        }
+        emitFileLines(streams, "updated", result.updatedFiles);
+        emitFileLines(streams, "created", result.createdFiles);
     });
     registerModelCommands(program, handlers, streams);
     registerRuntimeCommands(program, handlers, streams);
     registerSurfaceCommands(program, handlers, streams);
+    registerViewCommand(program, handlers, streams, cliOptions.renderEnvironment);
     program
         .command("validate")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())
@@ -192,9 +212,7 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
         .option("-p, --profile <name>", "Auth profile name", "default")
         .action(async (filePath, options) => {
         const profile = await handlers.importEnvFile(options.profile, filePath);
-        for (const line of formatAuthProfileSummary(profile)) {
-            streams.stdout(line);
-        }
+        emitLines(streams, formatAuthProfileSummary(profile));
     });
     authImportCommand
         .command("claude-code")
@@ -202,9 +220,7 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
         .option("--from <directory>", "Source Claude Code config directory")
         .action(async (options) => {
         const profile = await handlers.importClaudeCodeAuth(options.profile, options.from);
-        for (const line of formatAuthProfileSummary(profile)) {
-            streams.stdout(line);
-        }
+        emitLines(streams, formatAuthProfileSummary(profile));
     });
     authImportCommand
         .command("codex")
@@ -212,15 +228,13 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
         .option("--from <directory>", "Source Codex config directory")
         .action(async (options) => {
         const profile = await handlers.importCodexAuth(options.profile, options.from);
-        for (const line of formatAuthProfileSummary(profile)) {
-            streams.stdout(line);
-        }
+        emitLines(streams, formatAuthProfileSummary(profile));
     });
     authCommand
         .command("sync")
         .argument("[path]", "Project directory or Spawnfile path", process.cwd())
         .option("-p, --profile <name>", "Auth profile name", "default")
-        .option("--env-file <file>", "Path to an env file with model API keys")
+        .option("--env-file <file>", "Path to an env file with model keys and runtime secrets")
         .option("--claude-from <directory>", "Source Claude Code config directory")
         .option("--codex-from <directory>", "Source Codex config directory")
         .action(async (inputPath, options) => {
@@ -230,24 +244,23 @@ export const runCli = async (argv, streams = createDefaultStreams(), handlerOver
             envFilePath: options.envFile,
             profileName: options.profile
         });
-        for (const line of formatAuthProfileSummary(profile)) {
-            streams.stdout(line);
-        }
+        emitLines(streams, formatAuthProfileSummary(profile));
     });
     authCommand
         .command("show")
         .option("-p, --profile <name>", "Auth profile name", "default")
         .action(async (options) => {
         const profile = await handlers.requireAuthProfile(options.profile);
-        for (const line of formatAuthProfileSummary(profile)) {
-            streams.stdout(line);
-        }
+        emitLines(streams, formatAuthProfileSummary(profile));
     });
     try {
         await program.parseAsync(argv, { from: "user" });
         return 0;
     }
     catch (error) {
+        if (isCommanderError(error)) {
+            return error.exitCode === 0 ? 0 : 1;
+        }
         const message = isSpawnfileError(error)
             ? `${error.code}: ${error.message}`
             : error instanceof Error

package/dist/cli/viewCommand.d.ts

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

package/dist/cli/viewCommand.js

@@ -0,0 +1,87 @@
+import { stat } from "node:fs/promises";
+import path from "node:path";
+import { Option } from "commander";
+import { renderOrganizationNetworks, renderOrganizationTree } from "../compiler/index.js";
+import { SpawnfileError } from "../shared/index.js";
+const VIEW_MODES = ["tree", "networks"];
+const VIEW_SHOW_OPTIONS = ["paths", "declared"];
+const VIEW_COLOR_OPTIONS = ["auto", "always", "never"];
+const isViewMode = (value) => VIEW_MODES.includes(value);
+const isViewShow = (value) => VIEW_SHOW_OPTIONS.includes(value);
+const manifestPathFor = (inputPath) => path.basename(inputPath) === "Spawnfile"
+    ? path.resolve(inputPath)
+    : path.resolve(inputPath, "Spawnfile");
+const hasResolvedSpawnfile = async (inputPath) => {
+    try {
+        return (await stat(manifestPathFor(inputPath))).isFile();
+    }
+    catch {
+        return false;
+    }
+};
+const suggestModeOptionForPathToken = async (inputPath) => {
+    if (!inputPath || !isViewMode(inputPath) || await hasResolvedSpawnfile(inputPath)) {
+        return;
+    }
+    throw new SpawnfileError("validation_error", `No Spawnfile found for path "${inputPath}". Did you mean "spawnfile view --mode ${inputPath}"?`);
+};
+const resolveColor = (color, environment) => {
+    if (color === "always") {
+        return true;
+    }
+    if (color === "never") {
+        return false;
+    }
+    return environment.stdoutIsTty && !environment.ci && !environment.noColor;
+};
+const parseShowLayers = (value) => {
+    const layers = new Set();
+    if (!value) {
+        return layers;
+    }
+    for (const layer of value.split(",")) {
+        const normalized = layer.trim();
+        if (!isViewShow(normalized)) {
+            throw new SpawnfileError("validation_error", `Unsupported view detail layer "${normalized}". Supported layers: paths, declared.`);
+        }
+        layers.add(normalized);
+    }
+    return layers;
+};
+const toRenderOptions = (options, environment) => {
+    const showLayers = parseShowLayers(options.show);
+    if (options.paths) {
+        showLayers.add("paths");
+    }
+    return {
+        ascii: options.ascii,
+        color: resolveColor(options.color, environment),
+        declared: showLayers.has("declared"),
+        paths: showLayers.has("paths")
+    };
+};
+const emitRenderedView = (streams, output) => {
+    for (const line of output.split("\n")) {
+        streams.stdout(line);
+    }
+};
+export const registerViewCommand = (program, handlers, streams, renderEnvironment) => {
+    program
+        .command("view")
+        .description("Render a read-only organization view")
+        .argument("[path]", "Project directory or Spawnfile path")
+        .addOption(new Option("--mode <mode>", "View mode").choices(VIEW_MODES).default("tree"))
+        .option("--show <show>", "Comma-separated additional details")
+        .option("--ascii", "Use ASCII tree connectors")
+        .addOption(new Option("--color <when>", "Color output").choices(VIEW_COLOR_OPTIONS).default("auto"))
+        .option("--paths", "Show source paths")
+        .action(async (inputPath, options) => {
+        await suggestModeOptionForPathToken(inputPath);
+        const renderOptions = toRenderOptions(options, renderEnvironment);
+        const view = await handlers.buildOrganizationView(inputPath ?? process.cwd());
+        const output = options.mode === "networks"
+            ? renderOrganizationNetworks(view, renderOptions)
+            : renderOrganizationTree(view, renderOptions);
+        emitRenderedView(streams, output);
+    });
+};

package/dist/compiler/buildCompilePlan.js

@@ -9,6 +9,7 @@ import { assertRuntimeSupportsExecutionModelAuth } from "./modelAuth.js";
 import { assertRuntimeSupportsAgentSurfaces } from "./surfaceSupport.js";
 import { applyExecutionDefaults } from "./executionDefaults.js";
 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) => {
@@ -249,6 +250,7 @@ export const buildCompilePlan = async (inputPath) => {
         root: rootManifestPath,
         runtimes
     };
+    compilePlan.moltnetRoomMemberships = resolveMoltnetRoomMemberships(compilePlan);
     resolvePlanMoltnetAttachments(compilePlan);
     return compilePlan;
 };

package/dist/compiler/containerEntrypointRender.js

@@ -8,9 +8,9 @@ const createEnvironmentAssignments = (plan) => {
     if (plan.instancePaths.homePath) {
         envAssignments.push(`HOME=${shellQuote(plan.instancePaths.homePath)}`);
     }
-    if (plan.runtimeName === "tinyclaw" &&
-        plan.instancePaths.homePath &&
-        (plan.modelAuthMethods.openai === "api_key" || plan.modelAuthMethods.openai === "codex")) {
+    if (plan.instancePaths.homePath && ((plan.runtimeName === "tinyclaw" &&
+        (plan.modelAuthMethods.openai === "api_key" || plan.modelAuthMethods.openai === "codex")) ||
+        (plan.runtimeName === "picoclaw" && plan.modelAuthMethods.openai === "codex"))) {
         envAssignments.push(`CODEX_HOME=${shellQuote(path.posix.join(plan.instancePaths.homePath, ".codex"))}`);
     }
     if (plan.meta.homeEnv && plan.instancePaths.homePath) {

package/dist/compiler/index.d.ts

@@ -3,9 +3,11 @@ export * from "./buildCompilePlan.js";
 export * from "./buildProject.js";
 export * from "./compileProject.js";
 export * from "./initProject.js";
+export * from "./moltnetRoomMemberships.js";
 export * from "./runProject.js";
 export * from "./syncProjectAuth.js";
 export * from "./types.js";
 export * from "./updateProjectModels.js";
 export * from "./updateProjectRuntime.js";
 export * from "./updateProjectSurfaces.js";
+export * from "./view/index.js";

package/dist/compiler/index.js

@@ -3,9 +3,11 @@ export * from "./buildCompilePlan.js";
 export * from "./buildProject.js";
 export * from "./compileProject.js";
 export * from "./initProject.js";
+export * from "./moltnetRoomMemberships.js";
 export * from "./runProject.js";
 export * from "./syncProjectAuth.js";
 export * from "./types.js";
 export * from "./updateProjectModels.js";
 export * from "./updateProjectRuntime.js";
 export * from "./updateProjectSurfaces.js";
+export * from "./view/index.js";

package/dist/compiler/moltnetArtifacts.js

@@ -1,5 +1,6 @@
 import { getRuntimeAdapter } from "../runtime/index.js";
 import { SpawnfileError } from "../shared/index.js";
+import { listConcreteMoltnetRoomMemberIds } from "./moltnetRoomMemberships.js";
 const DEFAULT_MOLTNET_PORT = 8787;
 const DEFAULT_TINYCLAW_PORT = 3777;
 const ROOTFS_PREFIX = "container/rootfs";
@@ -86,14 +87,17 @@ export const generateMoltnetArtifacts = async (plan) => {
             const existingPlan = serverPlans.get(serverKey);
             if (existingPlan) {
                 for (const room of network.rooms) {
+                    const concreteMembers = listConcreteMoltnetRoomMemberIds(plan, teamNode.value, network.id, room);
                     const existingRoom = existingPlan.rooms.find((entry) => entry.id === room.id);
                     if (existingRoom) {
-                        existingRoom.members = [...new Set([...existingRoom.members, ...room.members])].sort();
+                        existingRoom.members = [
+                            ...new Set([...existingRoom.members, ...concreteMembers])
+                        ].sort();
                     }
                     else {
                         existingPlan.rooms.push({
                             id: room.id,
-                            members: [...new Set(room.members)].sort()
+                            members: concreteMembers
                         });
                     }
                 }
@@ -107,7 +111,7 @@ export const generateMoltnetArtifacts = async (plan) => {
                     port: nextPort,
                     rooms: network.rooms.map((room) => ({
                         id: room.id,
-                        members: [...new Set(room.members)].sort()
+                        members: listConcreteMoltnetRoomMemberIds(plan, teamNode.value, network.id, room)
                     })),
                     teamSource: teamNode.value.source
                 });

package/dist/compiler/moltnetResolution.js

@@ -1,5 +1,6 @@
 import { SpawnfileError } from "../shared/index.js";
-import { resolveMoltnetAttachments, resolveTeamRepresentatives } from "./moltnetRepresentativeResolution.js";
+import { resolveMoltnetRoomMemberships } from "./moltnetRoomMemberships.js";
+import { resolveMoltnetAttachments } from "./moltnetRepresentativeResolution.js";
 export { resolveMoltnetAttachments, resolveTeamRepresentatives } from "./moltnetRepresentativeResolution.js";
 const findTeamBySource = (plan, source) => {
     const node = plan.nodes.find((entry) => entry.kind === "team" && entry.value.source === source);
@@ -32,52 +33,26 @@ const validateGlobalMemberIds = (plan) => {
         seen.set(context.memberId, label);
     }
 };
-const expandTeamNetworkRooms = (plan) => {
-    const synthesizedAttachments = [];
-    for (const node of plan.nodes) {
-        if (node.value.kind !== "team") {
-            continue;
-        }
-        const teamNode = node.value;
-        for (const network of teamNode.networks ?? []) {
-            for (const room of network.rooms) {
-                const expandedMembers = [];
-                for (const roomMemberId of room.members) {
-                    const member = teamNode.members.find((entry) => entry.id === roomMemberId);
-                    if (!member) {
-                        throw new SpawnfileError("validation_error", `Team ${teamNode.name} Moltnet room ${room.id} references unknown member ${roomMemberId}`);
-                    }
-                    if (member.kind === "agent") {
-                        expandedMembers.push(member.id);
-                        continue;
-                    }
-                    const childTeam = findTeamBySource(plan, member.nodeSource);
-                    const representatives = resolveTeamRepresentatives(plan, childTeam);
-                    if (representatives.length === 0) {
-                        throw new SpawnfileError("validation_error", `Team ${childTeam.name} has no concrete representative for Moltnet room ${room.id} on ${teamNode.name}`);
-                    }
-                    for (const representative of representatives) {
-                        expandedMembers.push(representative.memberId);
-                        synthesizedAttachments.push({
-                            contextRooms: {
-                                [teamNode.source]: [room.id]
-                            },
-                            memberId: representative.memberId,
-                            network: network.id,
-                            rooms: {
-                                [room.id]: {}
-                            },
-                            teamSource: teamNode.source
-                        });
-                    }
-                }
-                room.members = [...new Set(expandedMembers)];
-            }
-        }
-    }
-    return synthesizedAttachments;
+const getRoomMemberships = (plan) => {
+    const memberships = plan.moltnetRoomMemberships ?? resolveMoltnetRoomMemberships(plan);
+    plan.moltnetRoomMemberships = memberships;
+    return memberships;
 };
+const synthesizeRepresentativeAttachments = (memberships) => memberships
+    .filter((membership) => membership.representedSlot !== undefined)
+    .map((membership) => ({
+    contextRooms: {
+        [membership.declaringTeamSource]: [membership.roomId]
+    },
+    memberId: membership.concreteMemberId,
+    network: membership.networkId,
+    rooms: {
+        [membership.roomId]: {}
+    },
+    teamSource: membership.declaringTeamSource
+}));
 const roomPolicyKey = (policy) => JSON.stringify(policy ?? {});
+const hasRoomPolicy = (policy) => policy.read !== undefined || policy.reply !== undefined;
 const mergeAttachment = (target, next, nodeName) => {
     if (target.dms &&
         next.dms &&
@@ -89,11 +64,16 @@ const mergeAttachment = (target, next, nodeName) => {
     target.rooms ??= {};
     for (const [roomId, policy] of Object.entries(next.rooms ?? {})) {
         const existingPolicy = target.rooms[roomId];
-        if (existingPolicy &&
+        const existingHasPolicy = existingPolicy ? hasRoomPolicy(existingPolicy) : false;
+        const nextHasPolicy = hasRoomPolicy(policy);
+        if (existingHasPolicy &&
+            nextHasPolicy &&
             roomPolicyKey(existingPolicy) !== roomPolicyKey(policy)) {
             throw new SpawnfileError("validation_error", `Agent ${nodeName} declares incompatible Moltnet room policy for ${next.network}/${next.memberId ?? "unknown"} room ${roomId}`);
         }
-        target.rooms[roomId] = { ...policy };
+        target.rooms[roomId] = existingPolicy && existingHasPolicy && !nextHasPolicy
+            ? { ...existingPolicy }
+            : { ...policy };
     }
     if (next.contextRooms) {
         target.contextRooms ??= {};
@@ -149,7 +129,8 @@ const mergeAgentAttachments = (agentNode, attachments) => {
 };
 export const resolvePlanMoltnetAttachments = (plan) => {
     validateGlobalMemberIds(plan);
-    const synthesizedAttachments = expandTeamNetworkRooms(plan);
+    const roomMemberships = getRoomMemberships(plan);
+    const synthesizedAttachments = synthesizeRepresentativeAttachments(roomMemberships);
     const synthesizedByAgent = new Map();
     for (const attachment of synthesizedAttachments) {
         const representativeContext = (plan.memberships ?? []).find((context) => context.memberId === attachment.memberId);

package/dist/compiler/moltnetRoomMemberships.d.ts

@@ -0,0 +1,3 @@
+import type { CompilePlan, ResolvedMoltnetRoomMembership, ResolvedTeamNetworkRoom, ResolvedTeamNode } from "./types.js";
+export declare const listConcreteMoltnetRoomMemberIds: (plan: CompilePlan, teamNode: ResolvedTeamNode, networkId: string, room: ResolvedTeamNetworkRoom, memberships?: ResolvedMoltnetRoomMembership[] | undefined) => string[];
+export declare const resolveMoltnetRoomMemberships: (plan: CompilePlan) => ResolvedMoltnetRoomMembership[];