spawnfile 0.1.2 → 0.1.3

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

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())
@@ -108,9 +139,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 +153,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 +165,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 +177,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 +210,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 +218,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,9 +226,7 @@ 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")
@@ -230,24 +242,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/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[];

package/dist/compiler/moltnetRoomMemberships.js

@@ -0,0 +1,140 @@
+import { SpawnfileError } from "../shared/index.js";
+import { resolveTeamRepresentatives } from "./moltnetRepresentativeResolution.js";
+const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
+const findAgentBySource = (plan, source) => {
+    const node = plan.nodes.find((entry) => entry.kind === "agent" && entry.value.source === source);
+    if (!node || node.value.kind !== "agent") {
+        throw new SpawnfileError("compile_error", `Unable to find agent node at ${source}`);
+    }
+    return node.value;
+};
+const findTeamBySource = (plan, source) => {
+    const node = plan.nodes.find((entry) => entry.kind === "team" && entry.value.source === source);
+    if (!node || node.value.kind !== "team") {
+        throw new SpawnfileError("compile_error", `Unable to find team node at ${source}`);
+    }
+    return node.value;
+};
+const clonePolicy = (policy) => ({
+    ...(policy.read ? { read: policy.read } : {}),
+    ...(policy.reply ? { reply: policy.reply } : {})
+});
+const findDirectRoomPolicy = (plan, teamNode, agentSource, memberId, networkId, roomId) => {
+    const agentNode = findAgentBySource(plan, agentSource);
+    for (const attachment of agentNode.surfaces?.moltnet ?? []) {
+        if (attachment.network !== networkId) {
+            continue;
+        }
+        if (attachment.teamSource && attachment.teamSource !== teamNode.source) {
+            continue;
+        }
+        if (attachment.memberId && attachment.memberId !== memberId) {
+            continue;
+        }
+        if (!attachment.rooms || !hasOwn(attachment.rooms, roomId)) {
+            continue;
+        }
+        return clonePolicy(attachment.rooms[roomId] ?? {});
+    }
+    return undefined;
+};
+const compareRoomMemberships = (left, right) => [
+    left.declaringTeamSource.localeCompare(right.declaringTeamSource),
+    left.networkId.localeCompare(right.networkId),
+    left.roomId.localeCompare(right.roomId),
+    left.declaredSlot.localeCompare(right.declaredSlot),
+    (left.representativePath ?? []).join("/").localeCompare((right.representativePath ?? []).join("/")),
+    left.concreteMemberId.localeCompare(right.concreteMemberId),
+    left.agentSource.localeCompare(right.agentSource)
+].find((result) => result !== 0) ?? 0;
+export const listConcreteMoltnetRoomMemberIds = (plan, teamNode, networkId, room, memberships = plan.moltnetRoomMemberships) => {
+    if (memberships) {
+        return [
+            ...new Set(memberships
+                .filter((membership) => membership.declaringTeamSource === teamNode.source
+                && membership.networkId === networkId
+                && membership.roomId === room.id)
+                .map((membership) => membership.concreteMemberId))
+        ].sort();
+    }
+    const concreteMembers = [];
+    for (const declaredSlot of room.members) {
+        const member = teamNode.members.find((entry) => entry.id === declaredSlot);
+        if (!member) {
+            throw new SpawnfileError("validation_error", `Team ${teamNode.name} Moltnet room ${room.id} references unknown member ${declaredSlot}`);
+        }
+        if (member.kind === "agent") {
+            concreteMembers.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}`);
+        }
+        concreteMembers.push(...representatives.map((representative) => representative.memberId));
+    }
+    return [...new Set(concreteMembers)].sort();
+};
+export const resolveMoltnetRoomMemberships = (plan) => {
+    const memberships = [];
+    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) {
+                for (const declaredSlot of room.members) {
+                    const declaredMember = teamNode.members.find((member) => member.id === declaredSlot);
+                    if (!declaredMember) {
+                        throw new SpawnfileError("validation_error", `Team ${teamNode.name} Moltnet room ${room.id} references unknown member ${declaredSlot}`);
+                    }
+                    if (declaredMember.kind === "agent") {
+                        const agentNode = findAgentBySource(plan, declaredMember.nodeSource);
+                        const policy = findDirectRoomPolicy(plan, teamNode, agentNode.source, declaredSlot, network.id, room.id);
+                        memberships.push({
+                            agentName: agentNode.name,
+                            agentSource: agentNode.source,
+                            concreteMemberId: declaredSlot,
+                            declaredSlot,
+                            declaringTeamName: teamNode.name,
+                            declaringTeamSource: teamNode.source,
+                            directTeamName: teamNode.name,
+                            directTeamSource: teamNode.source,
+                            networkId: network.id,
+                            ...(policy ? { policy } : {}),
+                            roomId: room.id
+                        });
+                        continue;
+                    }
+                    const childTeam = findTeamBySource(plan, declaredMember.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) {
+                        const agentNode = findAgentBySource(plan, representative.agentSource);
+                        memberships.push({
+                            agentName: agentNode.name,
+                            agentSource: agentNode.source,
+                            concreteMemberId: representative.memberId,
+                            declaredSlot,
+                            declaringTeamName: teamNode.name,
+                            declaringTeamSource: teamNode.source,
+                            directTeamName: representative.sourceTeamName,
+                            directTeamSource: representative.sourceTeamSource,
+                            networkId: network.id,
+                            representedSlot: declaredSlot,
+                            representedTeamName: childTeam.name,
+                            representedTeamSource: childTeam.source,
+                            representativePath: [declaredSlot, ...representative.path],
+                            roomId: room.id
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return memberships.sort(compareRoomMemberships);
+};

package/dist/compiler/types.d.ts

@@ -189,9 +189,27 @@ export interface ResolvedTeamMembershipContext {
     teamName: string;
     teamSource: string;
 }
+export interface ResolvedMoltnetRoomMembership {
+    agentName: string;
+    agentSource: string;
+    concreteMemberId: string;
+    declaredSlot: string;
+    declaringTeamName: string;
+    declaringTeamSource: string;
+    directTeamName: string;
+    directTeamSource: string;
+    networkId: string;
+    policy?: ResolvedMoltnetRoomPolicy;
+    representedSlot?: string;
+    representedTeamName?: string;
+    representedTeamSource?: string;
+    representativePath?: string[];
+    roomId: string;
+}
 export interface CompilePlan {
     edges: CompilePlanEdge[];
     memberships?: ResolvedTeamMembershipContext[];
+    moltnetRoomMemberships?: ResolvedMoltnetRoomMembership[];
     nodes: CompilePlanNode[];
     root: string;
     runtimes: Record<string, {

package/dist/compiler/view/buildOrganizationView.d.ts

@@ -0,0 +1,2 @@
+import type { OrganizationView } from "./types.js";
+export declare const buildOrganizationView: (inputPath: string) => Promise<OrganizationView>;

package/dist/compiler/view/buildOrganizationView.js

@@ -0,0 +1,180 @@
+import path from "node:path";
+import { SpawnfileError } from "../../shared/index.js";
+import { buildCompilePlan } from "../buildCompilePlan.js";
+import { resolveMoltnetRoomMemberships } from "../moltnetRoomMemberships.js";
+const createNameCounts = (plan) => {
+    const counts = new Map();
+    for (const node of plan.nodes) {
+        const key = `${node.kind}:${node.value.name}`;
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    return counts;
+};
+const formatDisplayName = (node, nameCounts) => {
+    const key = `${node.kind}:${node.value.name}`;
+    return (nameCounts.get(key) ?? 0) > 1
+        ? `${node.value.name} [${node.id}]`
+        : node.value.name;
+};
+const groupEdgesBySource = (edges) => {
+    const groups = new Map();
+    for (const edge of edges) {
+        const group = groups.get(edge.from) ?? [];
+        group.push(edge);
+        groups.set(edge.from, group);
+    }
+    return groups;
+};
+const buildTreeNetworkSummaries = (node) => {
+    if (node.value.kind !== "team") {
+        return [];
+    }
+    return (node.value.networks ?? []).map((network) => ({
+        expose: network.expose ?? false,
+        id: network.id,
+        name: network.name,
+        provider: network.provider,
+        rooms: network.rooms.map((room) => ({
+            declaredMembers: [...room.members],
+            id: room.id
+        }))
+    }));
+};
+const buildTreeNode = (node, nodeById, edgesBySource, nameCounts, ancestors = []) => {
+    if (ancestors.includes(node.id)) {
+        throw new SpawnfileError("compile_error", `Cycle detected while building view tree for ${node.id}`);
+    }
+    const children = (edgesBySource.get(node.id) ?? []).map((edge) => {
+        const child = nodeById.get(edge.to);
+        if (!child) {
+            throw new SpawnfileError("compile_error", `Unable to find view node ${edge.to}`);
+        }
+        return {
+            label: edge.label,
+            node: buildTreeNode(child, nodeById, edgesBySource, nameCounts, [...ancestors, node.id]),
+            relation: edge.kind
+        };
+    });
+    return {
+        children,
+        displayName: formatDisplayName(node, nameCounts),
+        ...(node.value.kind === "team"
+            ? {
+                external: [...node.value.external],
+                lead: node.value.lead,
+                mode: node.value.mode
+            }
+            : {}),
+        id: node.id,
+        kind: node.kind,
+        name: node.value.name,
+        networks: buildTreeNetworkSummaries(node),
+        runtimeName: node.runtimeName,
+        source: node.value.source
+    };
+};
+const sortNetworkMembers = (declaredMembers, members) => {
+    const declaredOrder = new Map(declaredMembers.map((member, index) => [member, index]));
+    return [...members].sort((left, right) => (declaredOrder.get(left.declaredSlot) ?? Number.MAX_SAFE_INTEGER)
+        - (declaredOrder.get(right.declaredSlot) ?? Number.MAX_SAFE_INTEGER)
+        || (left.representativePath ?? []).join("/").localeCompare((right.representativePath ?? []).join("/"))
+        || left.concreteMemberId.localeCompare(right.concreteMemberId));
+};
+const toNetworkMemberView = (membership) => ({
+    agentName: membership.agentName,
+    agentSource: membership.agentSource,
+    concreteMemberId: membership.concreteMemberId,
+    declaredSlot: membership.declaredSlot,
+    directTeamName: membership.directTeamName,
+    directTeamSource: membership.directTeamSource,
+    ...(membership.policy ? { policy: { ...membership.policy } } : {}),
+    ...(membership.representedSlot ? { representedSlot: membership.representedSlot } : {}),
+    ...(membership.representedTeamName
+        ? { representedTeamName: membership.representedTeamName }
+        : {}),
+    ...(membership.representedTeamSource
+        ? { representedTeamSource: membership.representedTeamSource }
+        : {}),
+    ...(membership.representativePath
+        ? { representativePath: [...membership.representativePath] }
+        : {})
+});
+const createNetworkKey = (provider, networkId) => `${provider}::${networkId}`;
+const buildNetworkDeclaration = (teamNode, network, roomMemberships) => ({
+    declaringTeamName: teamNode.name,
+    declaringTeamSource: teamNode.source,
+    expose: network.expose ?? false,
+    name: network.name,
+    rooms: network.rooms.map((room) => {
+        const members = roomMemberships
+            .filter((membership) => membership.declaringTeamSource === teamNode.source
+            && membership.networkId === network.id
+            && membership.roomId === room.id)
+            .map(toNetworkMemberView);
+        return {
+            declaredMembers: [...room.members],
+            id: room.id,
+            members: sortNetworkMembers(room.members, members)
+        };
+    })
+});
+const buildNetworks = (plan) => {
+    const roomMemberships = plan.moltnetRoomMemberships
+        ?? resolveMoltnetRoomMemberships(plan);
+    const groups = new Map();
+    for (const node of plan.nodes) {
+        if (node.value.kind !== "team") {
+            continue;
+        }
+        const teamNode = node.value;
+        for (const network of teamNode.networks ?? []) {
+            const key = createNetworkKey(network.provider, network.id);
+            const declaration = buildNetworkDeclaration(teamNode, network, roomMemberships);
+            const existing = groups.get(key);
+            if (existing) {
+                existing.declarations = [...(existing.declarations ?? []), declaration];
+                continue;
+            }
+            groups.set(key, {
+                declaringTeamName: declaration.declaringTeamName,
+                declaringTeamSource: declaration.declaringTeamSource,
+                declarations: [declaration],
+                expose: declaration.expose,
+                id: network.id,
+                name: declaration.name,
+                provider: network.provider,
+                rooms: declaration.rooms
+            });
+        }
+    }
+    const networks = [...groups.values()];
+    for (const network of networks) {
+        const firstDeclaration = network.declarations?.[0];
+        if (firstDeclaration) {
+            network.declaringTeamName = firstDeclaration.declaringTeamName;
+            network.declaringTeamSource = firstDeclaration.declaringTeamSource;
+            network.expose = firstDeclaration.expose;
+            network.name = firstDeclaration.name;
+            network.rooms = firstDeclaration.rooms;
+        }
+    }
+    return networks;
+};
+export const buildOrganizationView = async (inputPath) => {
+    const plan = await buildCompilePlan(inputPath);
+    const rootNode = plan.nodes.find((node) => node.value.source === plan.root);
+    if (!rootNode) {
+        throw new SpawnfileError("compile_error", `Unable to find root view node for ${plan.root}`);
+    }
+    const nodeById = new Map(plan.nodes.map((node) => [node.id, node]));
+    const root = buildTreeNode(rootNode, nodeById, groupEdgesBySource(plan.edges), createNameCounts(plan));
+    return {
+        contexts: [],
+        diagnostics: [],
+        inputPath,
+        networks: buildNetworks(plan),
+        projectRoot: path.dirname(plan.root),
+        root,
+        runtimes: []
+    };
+};

package/dist/compiler/view/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./buildOrganizationView.js";
+export * from "./renderNetworks.js";
+export * from "./renderTree.js";
+export * from "./types.js";

package/dist/compiler/view/index.js

@@ -0,0 +1,4 @@
+export * from "./buildOrganizationView.js";
+export * from "./renderNetworks.js";
+export * from "./renderTree.js";
+export * from "./types.js";

package/dist/compiler/view/renderNetworks.d.ts

@@ -0,0 +1,2 @@
+import type { OrganizationView, RenderOrganizationViewOptions } from "./types.js";
+export declare const renderOrganizationNetworks: (view: OrganizationView, options?: RenderOrganizationViewOptions) => string;

package/dist/compiler/view/renderNetworks.js

@@ -0,0 +1,93 @@
+import { formatSourceMeta } from "./sourcePaths.js";
+const color = (value, code, options) => options.color ? `\u001b[${code}m${value}\u001b[0m` : value;
+const glyphsFor = (options) => options.ascii
+    ? { branch: "|-- ", last: "`-- ", pipe: "|   ", space: "    " }
+    : { branch: "├── ", last: "└── ", pipe: "│   ", space: "    " };
+const formatPolicy = (member) => {
+    if (!member.policy) {
+        return [];
+    }
+    return [
+        member.policy.read ? `read=${member.policy.read}` : undefined,
+        member.policy.reply ? `reply=${member.policy.reply}` : undefined
+    ].filter((entry) => entry !== undefined);
+};
+const formatMember = (member, options, projectRoot) => {
+    const metadata = member.representedSlot
+        ? [
+            `represents=${member.representedSlot}`,
+            member.representedTeamName && member.representedTeamName !== member.representedSlot
+                ? `team=${member.representedTeamName}`
+                : undefined,
+            `member=${member.concreteMemberId}`
+        ]
+        : [
+            `team=${member.directTeamName}`,
+            `member=${member.concreteMemberId}`
+        ];
+    const source = options.paths
+        ? formatSourceMeta("source", member.agentSource, projectRoot)
+        : "";
+    const details = [
+        ...metadata,
+        ...formatPolicy(member)
+    ].filter((entry) => entry !== undefined);
+    return `${member.agentName}  ${details.join(" ")}${source}`;
+};
+const formatNetwork = (network, options) => {
+    const id = color(network.id, "36", options);
+    return `${network.provider} ${id}`;
+};
+const getDeclarations = (network) => network.declarations ?? [
+    {
+        declaringTeamName: network.declaringTeamName,
+        declaringTeamSource: network.declaringTeamSource,
+        expose: network.expose,
+        name: network.name,
+        rooms: network.rooms
+    }
+];
+const formatDeclaration = (network, declaration, options, projectRoot) => {
+    const exposed = declaration.expose ? " exposed" : "";
+    const source = options.paths
+        ? formatSourceMeta("declared_source", declaration.declaringTeamSource, projectRoot)
+        : "";
+    return `${network.id} "${declaration.name}" on ${declaration.declaringTeamName}${exposed}${source}`;
+};
+export const renderOrganizationNetworks = (view, options = {}) => {
+    if (view.networks.length === 0) {
+        return "No Moltnet networks.";
+    }
+    const glyphs = glyphsFor(options);
+    const lines = ["Moltnet networks"];
+    view.networks.forEach((network, networkIndex) => {
+        const networkLast = networkIndex === view.networks.length - 1;
+        const networkPrefix = networkLast ? glyphs.space : glyphs.pipe;
+        lines.push(`${networkLast ? glyphs.last : glyphs.branch}${formatNetwork(network, options)}`);
+        const declarations = getDeclarations(network);
+        declarations.forEach((declaration, declarationIndex) => {
+            const declarationLast = declarationIndex === declarations.length - 1;
+            const declarationPrefix = `${networkPrefix}${declarationLast ? glyphs.space : glyphs.pipe}`;
+            lines.push(`${networkPrefix}${declarationLast ? glyphs.last : glyphs.branch}${formatDeclaration(network, declaration, options, view.projectRoot)}`);
+            declaration.rooms.forEach((room, roomIndex) => {
+                const roomLast = roomIndex === declaration.rooms.length - 1;
+                const roomPrefix = `${declarationPrefix}${roomLast ? glyphs.space : glyphs.pipe}`;
+                const legacyDeclared = options.declared && !view.projectRoot
+                    ? ` room ${room.id} declared [${room.declaredMembers.join(", ")}]`
+                    : "";
+                lines.push(`${declarationPrefix}${roomLast ? glyphs.last : glyphs.branch}#${room.id}${legacyDeclared}`);
+                if (options.declared) {
+                    const declaredMembers = room.declaredMembers.length > 0
+                        ? room.declaredMembers.join(", ")
+                        : "(none)";
+                    lines.push(`${roomPrefix}${glyphs.branch}declared members: ${declaredMembers}`);
+                }
+                room.members.forEach((member, memberIndex) => {
+                    const memberLast = memberIndex === room.members.length - 1;
+                    lines.push(`${roomPrefix}${memberLast ? glyphs.last : glyphs.branch}${formatMember(member, options, view.projectRoot)}`);
+                });
+            });
+        });
+    });
+    return lines.join("\n");
+};

package/dist/compiler/view/renderTree.d.ts

@@ -0,0 +1,2 @@
+import type { OrganizationView, RenderOrganizationViewOptions } from "./types.js";
+export declare const renderOrganizationTree: (view: OrganizationView, options?: RenderOrganizationViewOptions) => string;

package/dist/compiler/view/renderTree.js

@@ -0,0 +1,59 @@
+import { formatSourceMeta } from "./sourcePaths.js";
+const color = (value, code, options) => options.color ? `\u001b[${code}m${value}\u001b[0m` : value;
+const formatNode = (node, options, projectRoot) => {
+    const kind = color(node.kind, node.kind === "team" ? "36" : "32", options);
+    const metadata = node.kind === "team"
+        ? [
+            node.mode ? `mode=${node.mode}` : undefined,
+            node.lead ? `lead=${node.lead}` : undefined,
+            node.external && node.external.length > 0
+                ? `external=${node.external.join(",")}`
+                : undefined
+        ]
+        : [
+            node.runtimeName ? `[${node.runtimeName}]` : undefined,
+            node.runtimeName ? `runtime=${node.runtimeName}` : undefined
+        ];
+    const details = metadata.filter((entry) => entry !== undefined);
+    const source = options.paths ? formatSourceMeta("source", node.source, projectRoot) : "";
+    const separator = details[0]?.startsWith("[") ? " " : "  ";
+    return `${kind} ${node.displayName}${details.length > 0 ? `${separator}${details.join(" ")}` : ""}${source}`;
+};
+const formatEdgeLabel = (edge) => edge.relation === "subagent"
+    ? `subagent ${edge.label}`
+    : edge.label;
+const formatNetworkSummary = (network, options) => {
+    const id = color(network.id, "36", options);
+    const exposed = network.expose ? " exposed" : "";
+    const rooms = network.rooms
+        .map((room) => `${room.id} [${room.declaredMembers.join(", ")}]`)
+        .join("; ");
+    return `network ${id} "${network.name}"${exposed}: ${rooms}`;
+};
+const renderChildren = (node, options, projectRoot, prefix = "") => {
+    const glyphs = options.ascii
+        ? { branch: "|-- ", last: "`-- ", pipe: "|   ", space: "    " }
+        : { branch: "├── ", last: "└── ", pipe: "│   ", space: "    " };
+    const items = [
+        ...(node.networks ?? []).map((network) => ({ kind: "network", network })),
+        ...node.children.map((edge) => ({ kind: "edge", edge }))
+    ];
+    return items.flatMap((item, index) => {
+        const isLast = index === items.length - 1;
+        const connector = isLast ? glyphs.last : glyphs.branch;
+        const nextPrefix = `${prefix}${isLast ? glyphs.space : glyphs.pipe}`;
+        if (item.kind === "network") {
+            return [`${prefix}${connector}${formatNetworkSummary(item.network, options)}`];
+        }
+        const edge = item.edge;
+        const line = `${prefix}${connector}${formatEdgeLabel(edge)}: ${formatNode(edge.node, options, projectRoot)}`;
+        return [
+            line,
+            ...renderChildren(edge.node, options, projectRoot, nextPrefix)
+        ];
+    });
+};
+export const renderOrganizationTree = (view, options = {}) => [
+    formatNode(view.root, options, view.projectRoot),
+    ...renderChildren(view.root, options, view.projectRoot)
+].join("\n");

package/dist/compiler/view/sourcePaths.d.ts

@@ -0,0 +1,2 @@
+export declare const formatSourcePath: (sourcePath: string, projectRoot: string | undefined) => string;
+export declare const formatSourceMeta: (label: string, sourcePath: string, projectRoot: string | undefined) => string;

package/dist/compiler/view/sourcePaths.js

@@ -0,0 +1,19 @@
+import path from "node:path";
+export const formatSourcePath = (sourcePath, projectRoot) => {
+    if (!projectRoot || !path.isAbsolute(sourcePath) || !path.isAbsolute(projectRoot)) {
+        return sourcePath;
+    }
+    const relativePath = path.relative(projectRoot, sourcePath);
+    if (relativePath === ""
+        || relativePath.startsWith("..")
+        || path.isAbsolute(relativePath)) {
+        return sourcePath;
+    }
+    return relativePath.split(path.sep).join("/");
+};
+export const formatSourceMeta = (label, sourcePath, projectRoot) => {
+    const formattedPath = formatSourcePath(sourcePath, projectRoot);
+    return projectRoot
+        ? ` ${label}=${formattedPath}`
+        : ` <${formattedPath}>`;
+};

package/dist/compiler/view/types.d.ts

@@ -0,0 +1,80 @@
+import type { ResolvedMoltnetRoomPolicy } from "../types.js";
+export interface OrganizationViewTreeNode {
+    children: OrganizationViewTreeEdge[];
+    displayName: string;
+    external?: string[];
+    id: string;
+    kind: "agent" | "team";
+    lead?: string | null;
+    mode?: "hierarchical" | "swarm";
+    name: string;
+    networks?: OrganizationTreeNetworkSummary[];
+    runtimeName: string | null;
+    source: string;
+}
+export interface OrganizationTreeNetworkRoomSummary {
+    declaredMembers: string[];
+    id: string;
+}
+export interface OrganizationTreeNetworkSummary {
+    expose: boolean;
+    id: string;
+    name: string;
+    provider: "moltnet";
+    rooms: OrganizationTreeNetworkRoomSummary[];
+}
+export interface OrganizationViewTreeEdge {
+    label: string;
+    node: OrganizationViewTreeNode;
+    relation: "subagent" | "team_member";
+}
+export interface OrganizationNetworkMemberView {
+    agentName: string;
+    agentSource: string;
+    concreteMemberId: string;
+    declaredSlot: string;
+    directTeamName: string;
+    directTeamSource: string;
+    policy?: ResolvedMoltnetRoomPolicy;
+    representedSlot?: string;
+    representedTeamName?: string;
+    representedTeamSource?: string;
+    representativePath?: string[];
+}
+export interface OrganizationNetworkDeclarationView {
+    declaringTeamName: string;
+    declaringTeamSource: string;
+    expose: boolean;
+    name: string;
+    rooms: OrganizationNetworkRoomView[];
+}
+export interface OrganizationNetworkRoomView {
+    declaredMembers: string[];
+    id: string;
+    members: OrganizationNetworkMemberView[];
+}
+export interface OrganizationNetworkView {
+    declaringTeamName: string;
+    declaringTeamSource: string;
+    expose: boolean;
+    id: string;
+    name: string;
+    provider: "moltnet";
+    rooms: OrganizationNetworkRoomView[];
+    declarations?: OrganizationNetworkDeclarationView[];
+}
+export interface OrganizationView {
+    contexts: [];
+    diagnostics: [];
+    inputPath: string;
+    networks: OrganizationNetworkView[];
+    projectRoot?: string;
+    root: OrganizationViewTreeNode;
+    runtimes: [];
+}
+export interface RenderOrganizationViewOptions {
+    ascii?: boolean;
+    color?: boolean;
+    declared?: boolean;
+    paths?: boolean;
+}

package/dist/compiler/view/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spawnfile",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Canonical source compiler for autonomous agents and teams.",
   "license": "MIT",
   "type": "module",
@@ -16,7 +16,7 @@
   },
   "scripts": {
     "blueprints": "./scripts/blueprints.sh",
-    "build": "rm -rf dist && tsc --project tsconfig.build.json && node ./scripts/copy-runtime-scaffold-assets.mjs",
+    "build": "rm -rf dist && tsc --project tsconfig.build.json && chmod +x dist/cli/index.js && node ./scripts/copy-runtime-scaffold-assets.mjs",
     "clean": "rm -rf coverage dist",
     "coverage": "vitest run --coverage",
     "dev": "tsx src/cli/index.ts",