spawnfile 0.1.1 → 0.1.3

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/dist/manifest/loadManifest.js

@@ -102,12 +102,12 @@ const validateLocalTeamManifest = async (manifestPath, manifest) => {
     await validateManifestRefs(manifestPath, manifest.members.map((member) => member.ref), "Member");
     validateSkillRequirements(manifest.shared?.skills, getSharedMcpNames(manifest.shared));
     const memberIds = new Set(manifest.members.map((member) => member.id));
-    if (manifest.structure.leader && !memberIds.has(manifest.structure.leader)) {
-        throw new SpawnfileError("validation_error", `Structure leader is not a declared team member: ${manifest.structure.leader}`);
+    if (manifest.lead && !memberIds.has(manifest.lead)) {
+        throw new SpawnfileError("validation_error", `Lead is not a declared team member: ${manifest.lead}`);
     }
-    for (const id of manifest.structure.external ?? []) {
+    for (const id of manifest.external ?? []) {
         if (!memberIds.has(id)) {
-            throw new SpawnfileError("validation_error", `Structure external references undeclared member: ${id}`);
+            throw new SpawnfileError("validation_error", `External references undeclared member: ${id}`);
         }
     }
 };

package/dist/manifest/renderSpawnfile.js

@@ -29,7 +29,8 @@ const orderDiscordSurface = (surface) => {
     }
     return withDefinedEntries([
         ["access", orderDiscordSurfaceAccess(surface.access)],
-        ["bot_token_secret", surface.bot_token_secret]
+        ["bot_token_secret", surface.bot_token_secret],
+        ["identity", surface.identity]
     ]);
 };
 const orderDiscordSurfaceAccess = (access) => {
@@ -49,7 +50,8 @@ const orderTelegramSurface = (surface) => {
     }
     return withDefinedEntries([
         ["access", orderTelegramSurfaceAccess(surface.access)],
-        ["bot_token_secret", surface.bot_token_secret]
+        ["bot_token_secret", surface.bot_token_secret],
+        ["identity", surface.identity]
     ]);
 };
 const orderTelegramSurfaceAccess = (access) => {
@@ -62,11 +64,55 @@ const orderTelegramSurfaceAccess = (access) => {
         ["chats", access.chats]
     ]);
 };
+const orderWebhookSurface = (surface) => {
+    if (!surface) {
+        return undefined;
+    }
+    return withDefinedEntries([
+        ["url", surface.url],
+        ["signing_secret", surface.signing_secret]
+    ]);
+};
+const orderMoltnetRoomBehavior = (behavior) => {
+    if (!behavior) {
+        return undefined;
+    }
+    return withDefinedEntries([
+        ["read", behavior.read],
+        ["reply", behavior.reply]
+    ]);
+};
+const orderMoltnetDm = (dms) => {
+    if (!dms) {
+        return undefined;
+    }
+    return withDefinedEntries([
+        ["enabled", dms.enabled],
+        ["read", dms.read],
+        ["reply", dms.reply]
+    ]);
+};
+const orderMoltnetAttachment = (attachment) => withDefinedEntries([
+    ["network", attachment.network],
+    [
+        "rooms",
+        attachment.rooms
+            ? Object.fromEntries(Object.entries(attachment.rooms)
+                .sort(([left], [right]) => left.localeCompare(right))
+                .map(([roomId, behavior]) => [roomId, orderMoltnetRoomBehavior(behavior)]))
+            : undefined
+    ],
+    ["dms", orderMoltnetDm(attachment.dms)]
+]);
+const orderMoltnetSurface = (surface) => surface?.map(orderMoltnetAttachment);
 const orderWhatsAppSurface = (surface) => {
     if (!surface) {
         return undefined;
     }
-    return withDefinedEntries([["access", orderWhatsAppSurfaceAccess(surface.access)]]);
+    return withDefinedEntries([
+        ["access", orderWhatsAppSurfaceAccess(surface.access)],
+        ["identity", surface.identity]
+    ]);
 };
 const orderWhatsAppSurfaceAccess = (access) => {
     if (!access) {
@@ -85,7 +131,8 @@ const orderSlackSurface = (surface) => {
     return withDefinedEntries([
         ["access", orderSlackSurfaceAccess(surface.access)],
         ["bot_token_secret", surface.bot_token_secret],
-        ["app_token_secret", surface.app_token_secret]
+        ["app_token_secret", surface.app_token_secret],
+        ["identity", surface.identity]
     ]);
 };
 const orderSlackSurfaceAccess = (access) => {
@@ -156,9 +203,24 @@ const orderSurfaces = (surfaces) => {
         ["discord", orderDiscordSurface(surfaces.discord)],
         ["telegram", orderTelegramSurface(surfaces.telegram)],
         ["whatsapp", orderWhatsAppSurface(surfaces.whatsapp)],
-        ["slack", orderSlackSurface(surfaces.slack)]
+        ["slack", orderSlackSurface(surfaces.slack)],
+        ["webhook", orderWebhookSurface(surfaces.webhook)],
+        ["moltnet", orderMoltnetSurface(surfaces.moltnet)]
     ]);
 };
+const orderTeamNetworks = (networks) => networks?.map((network) => withDefinedEntries([
+    ["id", network.id],
+    ["provider", network.provider],
+    ["name", network.name],
+    ["expose", network.expose],
+    [
+        "rooms",
+        network.rooms.map((room) => withDefinedEntries([
+            ["id", room.id],
+            ["members", room.members]
+        ]))
+    ]
+]));
 const renderSections = (sections) => sections
     .filter(hasEntries)
     .map((section) => YAML.stringify(section))
@@ -167,7 +229,8 @@ const orderAgentManifestSections = (manifest) => [
     withDefinedEntries([
         ["spawnfile_version", manifest.spawnfile_version],
         ["kind", manifest.kind],
-        ["name", manifest.name]
+        ["name", manifest.name],
+        ["expose", manifest.expose]
     ]),
     withDefinedEntries([["runtime", orderRuntimeBinding(manifest.runtime)]]),
     withDefinedEntries([["execution", orderExecution(manifest.execution)]]),
@@ -192,7 +255,8 @@ const orderTeamManifestSections = (manifest) => [
     withDefinedEntries([["execution", orderExecution(manifest.execution)]]),
     withDefinedEntries([
         ["docs", orderDocs(manifest.docs)],
-        ["shared", orderSharedSurface(manifest.shared)]
+        ["shared", orderSharedSurface(manifest.shared)],
+        ["networks", orderTeamNetworks(manifest.networks)]
     ]),
     withDefinedEntries([
         ["skills", manifest.skills],
@@ -203,7 +267,9 @@ const orderTeamManifestSections = (manifest) => [
     ]),
     withDefinedEntries([
         ["members", manifest.members],
-        ["structure", manifest.structure]
+        ["mode", manifest.mode],
+        ["lead", manifest.lead],
+        ["external", manifest.external]
     ])
 ];
 export const renderSpawnfile = (manifest) => renderSections(manifest.kind === "agent"

package/dist/manifest/scaffold.js

@@ -35,7 +35,5 @@ export const createTeamScaffoldManifest = () => ({
         system: "TEAM.md"
     },
     members: [],
-    structure: {
-        mode: "swarm"
-    }
+    mode: "swarm"
 });