spawnfile 0.1.0 → 0.1.2

package/dist/compiler/teamContextHelpers.js

@@ -0,0 +1,112 @@
+import { createHash } from "node:crypto";
+import { generateTeamRoster, listTeamRepresentatives } from "./teamRoster.js";
+export const pathSafe = (value) => {
+    const normalized = value
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return normalized || "context";
+};
+export const shortHash = (value) => createHash("sha256").update(value).digest("hex").slice(0, 8);
+export const reportKeySegment = (value) => /^[A-Za-z0-9_-]+$/.test(value)
+    ? value
+    : encodeURIComponent(value).replace(/\./g, "%2E");
+export const findTeamBySource = (plan, source) => {
+    const node = plan.nodes.find((entry) => entry.kind === "team" && entry.value.source === source);
+    return node?.value.kind === "team" ? node.value : null;
+};
+export const findAgentBySource = (plan, source) => {
+    const node = plan.nodes.find((entry) => entry.kind === "agent" && entry.value.source === source);
+    return node?.value.kind === "agent" ? node.value : null;
+};
+export const getSystemTeamDoc = (teamNode) => teamNode.docs.find((doc) => doc.role === "system")?.content ?? "";
+export const createContextBaseKey = (context) => context.kind === "direct"
+    ? pathSafe(context.teamNode.name)
+    : `${pathSafe(context.parentTeamNode.name)}--${pathSafe(context.representedMember.id)}`;
+export const collectMoltnetBindings = (agentNode, teamSource, memberId) => (agentNode.surfaces?.moltnet ?? [])
+    .filter((attachment) => attachment.memberId === memberId)
+    .map((attachment) => ({
+    network: attachment.network,
+    rooms: [
+        ...(attachment.contextRooms?.[teamSource] ??
+            (attachment.teamSource === teamSource ? Object.keys(attachment.rooms ?? {}) : []))
+    ].sort()
+}))
+    .filter((binding) => binding.rooms.length > 0);
+export const createTeamCard = (contextKey, member, childTeam, representatives) => ({
+    content: [
+        `# ${childTeam.name}`,
+        "",
+        childTeam.description,
+        "",
+        childTeam.docs.find((doc) => doc.role === "identity")?.content ?? "",
+        "## Representatives",
+        "",
+        ...representatives.map((representative) => `- \`${representative}\``)
+    ].filter((line, index, lines) => line !== "" || lines[index - 1] !== "").join("\n").trimEnd() + "\n",
+    path: `.spawnfile/team-cards/${contextKey}/${member.id}.md`
+});
+const formatMoltnetBindings = (surfaces) => {
+    const moltnet = (surfaces &&
+        typeof surfaces === "object" &&
+        "moltnet" in surfaces &&
+        Array.isArray(surfaces.moltnet))
+        ? surfaces.moltnet
+        : [];
+    return moltnet.flatMap((binding) => {
+        const network = typeof binding.network === "string" ? binding.network : null;
+        const rooms = Array.isArray(binding.rooms)
+            ? binding.rooms.filter((room) => typeof room === "string")
+            : [];
+        return network
+            ? rooms.map((room) => `   Moltnet: \`${network}\` / room \`${room}\``)
+            : [];
+    });
+};
+const appendSurfaceBindingLines = (lines, entry) => {
+    const bindings = formatMoltnetBindings(entry.surfaces);
+    if (bindings.length === 0) {
+        return;
+    }
+    lines.push("   Surface bindings:");
+    lines.push(...bindings);
+};
+export const buildContextOrientation = (index) => {
+    const lines = ["# Spawnfile Team Context", ""];
+    if (index.direct_memberships.length > 0) {
+        lines.push("You are a direct member of these teams:", "");
+        index.direct_memberships.forEach((entry, itemIndex) => {
+            lines.push(`${itemIndex + 1}. Team: \`${entry.team}\``);
+            lines.push(`   Member slot: \`${entry.member}\``);
+            lines.push(`   Read \`${entry.team_doc}\` and \`${entry.roster}\`.`);
+            appendSurfaceBindingLines(lines, entry);
+            lines.push("");
+        });
+    }
+    if (index.representations.length > 0) {
+        lines.push("You also represent teams in parent contexts:", "");
+        index.representations.forEach((entry, itemIndex) => {
+            lines.push(`${itemIndex + 1}. Parent team: \`${entry.team}\``);
+            lines.push(`   Represents slot: \`${entry.represents}\``);
+            lines.push(`   Delegate role: \`${entry.delegate_role}\``);
+            lines.push(`   Read \`${entry.team_doc}\` and \`${entry.roster}\`.`);
+            appendSurfaceBindingLines(lines, entry);
+            lines.push("");
+        });
+    }
+    lines.push("Use the context matching the surface or message you are handling. Do not merge team documents.");
+    lines.push("For machine-readable bindings, read `.spawnfile/team-contexts.yaml`.");
+    return `${lines.join("\n").trimEnd()}\n`;
+};
+export const createVisibleTeamCards = (plan, contextKey, teamNode, visibleMembers) => visibleMembers
+    .filter((member) => member.kind === "team")
+    .flatMap((member) => {
+    const childTeam = findTeamBySource(plan, member.nodeSource);
+    if (!childTeam) {
+        return [];
+    }
+    return [
+        createTeamCard(contextKey, member, childTeam, listTeamRepresentatives(plan, childTeam).map((representative) => representative.memberId))
+    ];
+});
+export const generateContextRoster = generateTeamRoster;

package/dist/compiler/teamContextSupport.d.ts

@@ -0,0 +1,4 @@
+import type { TeamCompileSupport } from "./teamContextTypes.js";
+export type { TeamCompileSupport } from "./teamContextTypes.js";
+import type { CompilePlan } from "./types.js";
+export declare const prepareTeamCompileSupport: (plan: CompilePlan) => Promise<TeamCompileSupport>;

package/dist/compiler/teamContextSupport.js

@@ -0,0 +1,264 @@
+import YAML from "yaml";
+import { buildContextOrientation, collectMoltnetBindings, createContextBaseKey, createVisibleTeamCards, findAgentBySource, findTeamBySource, getSystemTeamDoc, reportKeySegment, shortHash } from "./teamContextHelpers.js";
+import { generateTeamRoster, listTeamRepresentatives } from "./teamRoster.js";
+const assignContextKeys = (contexts) => {
+    const baseCounts = new Map();
+    for (const context of contexts) {
+        const base = createContextBaseKey(context);
+        baseCounts.set(base, (baseCounts.get(base) ?? 0) + 1);
+    }
+    const used = new Set();
+    for (const context of contexts) {
+        const base = createContextBaseKey(context);
+        const tuple = context.kind === "direct"
+            ? `direct:${context.membership.teamSource}:${context.membership.memberId}`
+            : `representative:${context.parentTeamNode.source}:${context.representedMember.id}:${context.representativeMemberId}`;
+        const key = baseCounts.get(base) === 1 && !used.has(base)
+            ? base
+            : `${base}--${shortHash(tuple)}`;
+        context.contextKey = key;
+        used.add(key);
+    }
+};
+const collectAgentContexts = (plan) => {
+    const contextsByAgent = new Map();
+    const addContext = (agentSource, context) => {
+        const contexts = contextsByAgent.get(agentSource) ?? [];
+        contexts.push(context);
+        contextsByAgent.set(agentSource, contexts);
+    };
+    for (const membership of plan.memberships ?? []) {
+        const teamNode = findTeamBySource(plan, membership.teamSource);
+        if (teamNode) {
+            addContext(membership.agentSource, {
+                contextKey: "",
+                kind: "direct",
+                membership,
+                teamNode
+            });
+        }
+    }
+    for (const node of plan.nodes) {
+        if (node.value.kind !== "team") {
+            continue;
+        }
+        const parentTeamNode = node.value;
+        for (const member of parentTeamNode.members.filter((entry) => entry.kind === "team")) {
+            const childTeam = findTeamBySource(plan, member.nodeSource);
+            if (!childTeam) {
+                continue;
+            }
+            const delegateRole = member.id === parentTeamNode.lead ? "lead" : "representative";
+            for (const representative of listTeamRepresentatives(plan, childTeam)) {
+                addContext(representative.agentSource, {
+                    contextKey: "",
+                    delegateRole,
+                    kind: "representative",
+                    parentTeamNode,
+                    representedMember: member,
+                    representativeMemberId: representative.memberId,
+                    representativeSource: representative.agentSource
+                });
+            }
+        }
+    }
+    for (const contexts of contextsByAgent.values()) {
+        assignContextKeys(contexts);
+    }
+    return contextsByAgent;
+};
+const addMapEntries = (target, key, entries) => {
+    if (entries.length === 0) {
+        return;
+    }
+    target.set(key, [...(target.get(key) ?? []), ...entries]);
+};
+const createTeamCapabilities = (teamNode) => [
+    {
+        key: "team.roster",
+        message: "Context-scoped team rosters were emitted",
+        outcome: "supported"
+    },
+    {
+        key: "team.context_orientation",
+        message: "Team context orientation was surfaced through runtime system instructions",
+        outcome: "supported"
+    },
+    {
+        key: "team.representatives",
+        message: "Representative chains were resolved",
+        outcome: "supported"
+    },
+    ...((teamNode.networks?.length ?? 0) > 0
+        ? [
+            {
+                key: "team.networks",
+                message: "Team networks were lowered",
+                outcome: "supported"
+            },
+            {
+                key: "team.networks.moltnet",
+                message: "Moltnet team networks were lowered",
+                outcome: "supported"
+            },
+            ...(teamNode.networks ?? []).map((network) => ({
+                key: `team.networks.moltnet.${reportKeySegment(network.id)}`,
+                message: `Moltnet network ${network.id} was lowered`,
+                outcome: "supported"
+            }))
+        ]
+        : [])
+];
+const createRepresentativeDiagnostics = (plan, teamNode) => {
+    const diagnostics = [];
+    for (const member of teamNode.members.filter((entry) => entry.kind === "team")) {
+        const childTeam = findTeamBySource(plan, member.nodeSource);
+        if (!childTeam) {
+            continue;
+        }
+        if (childTeam.mode === "swarm" && !childTeam.externalExplicit) {
+            diagnostics.push({
+                level: "warn",
+                message: `Nested swarm team ${childTeam.name} is exposed without explicit external representatives`
+            });
+        }
+        if (teamNode.lead === member.id && !childTeam.externalExplicit) {
+            const representatives = listTeamRepresentatives(plan, childTeam);
+            if (representatives.length > 1) {
+                diagnostics.push({
+                    level: "warn",
+                    message: `Team ${teamNode.name} lead ${member.id} resolves to multiple implicit representatives`
+                });
+            }
+        }
+    }
+    return diagnostics;
+};
+const addAmbiguousBindingDiagnostics = (agentNode, contexts, diagnosticsByTeamSource) => {
+    const bindings = new Map();
+    for (const context of contexts) {
+        const teamSource = context.kind === "direct"
+            ? context.membership.teamSource
+            : context.parentTeamNode.source;
+        const memberId = context.kind === "direct"
+            ? context.membership.memberId
+            : context.representativeMemberId;
+        for (const binding of collectMoltnetBindings(agentNode, teamSource, memberId)) {
+            for (const room of binding.rooms) {
+                const key = `moltnet:${binding.network}:${room}`;
+                bindings.set(key, [...(bindings.get(key) ?? []), context]);
+            }
+        }
+    }
+    for (const [binding, bindingContexts] of bindings) {
+        const uniqueKeys = [...new Set(bindingContexts.map((context) => context.contextKey))];
+        if (uniqueKeys.length < 2) {
+            continue;
+        }
+        for (const context of bindingContexts) {
+            const teamSource = context.kind === "direct"
+                ? context.membership.teamSource
+                : context.parentTeamNode.source;
+            addMapEntries(diagnosticsByTeamSource, teamSource, [
+                {
+                    level: "warn",
+                    message: `Agent ${agentNode.name} maps ${binding} to multiple team contexts: ${uniqueKeys.join(", ")}`
+                }
+            ]);
+        }
+    }
+};
+export const prepareTeamCompileSupport = async (plan) => {
+    const capabilitiesByTeamSource = new Map();
+    const diagnosticsByTeamSource = new Map();
+    const filesByAgentSource = new Map();
+    const contextsByAgent = collectAgentContexts(plan);
+    for (const node of plan.nodes) {
+        if (node.value.kind !== "team") {
+            continue;
+        }
+        addMapEntries(capabilitiesByTeamSource, node.value.source, createTeamCapabilities(node.value));
+        addMapEntries(diagnosticsByTeamSource, node.value.source, createRepresentativeDiagnostics(plan, node.value));
+    }
+    for (const [agentSource, contexts] of contextsByAgent) {
+        const agentNode = findAgentBySource(plan, agentSource);
+        if (!agentNode) {
+            continue;
+        }
+        const directCount = contexts.filter((context) => context.kind === "direct").length;
+        const directIndex = [];
+        const representationIndex = [];
+        const files = [];
+        for (const context of contexts) {
+            if (context.kind === "direct") {
+                const teamDocPath = `.spawnfile/team-contexts/${context.contextKey}/TEAM.md`;
+                const rosterPath = `.spawnfile/rosters/${context.contextKey}.yaml`;
+                const generated = generateTeamRoster(context.teamNode, plan, {
+                    contextKey: context.contextKey,
+                    selfMemberId: context.membership.memberId,
+                    teamSource: context.membership.teamSource
+                });
+                const aliases = directCount === 1
+                    ? { roster: ".spawnfile/roster.yaml", team_doc: "TEAM.md" }
+                    : undefined;
+                files.push({ content: getSystemTeamDoc(context.teamNode), path: teamDocPath }, { content: generated.roster, path: rosterPath }, ...createVisibleTeamCards(plan, context.contextKey, context.teamNode, generated.visibleMembers));
+                if (aliases) {
+                    files.push({ content: getSystemTeamDoc(context.teamNode), path: aliases.team_doc }, { content: generated.roster, path: aliases.roster });
+                }
+                directIndex.push({
+                    ...(aliases ? { aliases } : {}),
+                    context_key: context.contextKey,
+                    member: context.membership.memberId,
+                    roster: rosterPath,
+                    surfaces: {
+                        moltnet: collectMoltnetBindings(agentNode, context.membership.teamSource, context.membership.memberId)
+                    },
+                    team: context.teamNode.name,
+                    team_doc: teamDocPath
+                });
+                addMapEntries(diagnosticsByTeamSource, context.teamNode.source, generated.diagnostics);
+            }
+            else {
+                const teamDocPath = `.spawnfile/team-contexts/${context.contextKey}/TEAM.md`;
+                const rosterPath = `.spawnfile/rosters/${context.contextKey}.yaml`;
+                const generated = generateTeamRoster(context.parentTeamNode, plan, {
+                    contextKey: context.contextKey,
+                    delegateRole: context.delegateRole,
+                    representedSlotId: context.representedMember.id,
+                    selfMemberId: context.representativeMemberId,
+                    teamSource: context.parentTeamNode.source
+                });
+                const cards = createVisibleTeamCards(plan, context.contextKey, context.parentTeamNode, generated.visibleMembers);
+                files.push({ content: getSystemTeamDoc(context.parentTeamNode), path: teamDocPath }, { content: generated.roster, path: rosterPath }, ...cards);
+                representationIndex.push({
+                    cards: cards.map((file) => file.path),
+                    context_key: context.contextKey,
+                    delegate_role: context.delegateRole,
+                    representative: context.representativeMemberId,
+                    represents: context.representedMember.id,
+                    roster: rosterPath,
+                    surfaces: {
+                        moltnet: collectMoltnetBindings(agentNode, context.parentTeamNode.source, context.representativeMemberId)
+                    },
+                    team: context.parentTeamNode.name,
+                    team_doc: teamDocPath
+                });
+                addMapEntries(diagnosticsByTeamSource, context.parentTeamNode.source, generated.diagnostics);
+            }
+        }
+        const contextIndex = {
+            direct_memberships: directIndex,
+            representations: representationIndex
+        };
+        files.push({
+            content: YAML.stringify(contextIndex),
+            path: ".spawnfile/team-contexts.yaml"
+        }, {
+            content: buildContextOrientation(contextIndex),
+            path: ".spawnfile/team-contexts.md"
+        });
+        filesByAgentSource.set(agentSource, files);
+        addAmbiguousBindingDiagnostics(agentNode, contexts, diagnosticsByTeamSource);
+    }
+    return { capabilitiesByTeamSource, diagnosticsByTeamSource, filesByAgentSource };
+};

package/dist/compiler/teamContextSupport.testHelpers.d.ts

@@ -0,0 +1,16 @@
+import type { EmittedFile } from "../runtime/index.js";
+import type { CompilePlan, ResolvedAgentNode, ResolvedAgentSurfaces, ResolvedMemberRef, ResolvedTeamNetwork, ResolvedTeamNode } from "./types.js";
+export declare const createTestAgent: (name: string, source: string, surfaces?: ResolvedAgentSurfaces) => ResolvedAgentNode;
+export declare const createTestTeam: (input: {
+    docs?: ResolvedTeamNode["docs"];
+    external?: string[];
+    externalExplicit?: boolean;
+    lead?: string | null;
+    members: ResolvedMemberRef[];
+    mode?: "hierarchical" | "swarm";
+    name: string;
+    networks?: ResolvedTeamNetwork[];
+    source: string;
+}) => ResolvedTeamNode;
+export declare const createTestPlan: (agents: ResolvedAgentNode[], teams: ResolvedTeamNode[], memberships: NonNullable<CompilePlan["memberships"]>) => CompilePlan;
+export declare const findTestFile: (files: EmittedFile[], filePath: string) => EmittedFile;

package/dist/compiler/teamContextSupport.testHelpers.js

@@ -0,0 +1,68 @@
+export const createTestAgent = (name, source, surfaces) => ({
+    description: `${name} description`,
+    docs: [],
+    env: {},
+    execution: undefined,
+    kind: "agent",
+    mcpServers: [],
+    name,
+    policyMode: null,
+    policyOnDegrade: null,
+    runtime: { name: "openclaw", options: {} },
+    secrets: [],
+    skills: [],
+    source,
+    surfaces,
+    subagents: []
+});
+export const createTestTeam = (input) => ({
+    description: `${input.name} description`,
+    docs: input.docs ?? [
+        {
+            content: `# ${input.name} operating context\n`,
+            role: "system",
+            sourcePath: `${input.source}/TEAM.md`
+        }
+    ],
+    external: input.external ?? [],
+    externalExplicit: input.externalExplicit ?? false,
+    kind: "team",
+    lead: input.lead ?? null,
+    members: input.members,
+    mode: input.mode ?? "swarm",
+    name: input.name,
+    networks: input.networks,
+    policyMode: null,
+    policyOnDegrade: null,
+    shared: { env: {}, mcpServers: [], secrets: [], skills: [] },
+    source: input.source
+});
+export const createTestPlan = (agents, teams, memberships) => ({
+    edges: [],
+    memberships,
+    nodes: [
+        ...teams.map((team, index) => ({
+            id: `team-${index}`,
+            kind: "team",
+            runtimeName: null,
+            slug: team.name.toLowerCase().replaceAll(" ", "-"),
+            value: team
+        })),
+        ...agents.map((agent, index) => ({
+            id: `agent-${index}`,
+            kind: "agent",
+            runtimeName: agent.runtime.name,
+            slug: agent.name,
+            value: agent
+        }))
+    ],
+    root: teams[0]?.source ?? agents[0]?.source ?? "/tmp/Spawnfile",
+    runtimes: { openclaw: { nodeIds: agents.map((_, index) => `agent-${index}`) } }
+});
+export const findTestFile = (files, filePath) => {
+    const file = files.find((entry) => entry.path === filePath);
+    if (!file) {
+        throw new Error(`missing emitted file ${filePath}`);
+    }
+    return file;
+};

package/dist/compiler/teamContextTypes.d.ts

@@ -0,0 +1,28 @@
+import type { CapabilityReport, DiagnosticReport } from "../report/index.js";
+import type { EmittedFile } from "../runtime/index.js";
+import type { ResolvedMemberRef, ResolvedTeamMembershipContext, ResolvedTeamNode } from "./types.js";
+export interface TeamCompileSupport {
+    capabilitiesByTeamSource: Map<string, CapabilityReport[]>;
+    diagnosticsByTeamSource: Map<string, DiagnosticReport[]>;
+    filesByAgentSource: Map<string, EmittedFile[]>;
+}
+export interface DirectContext {
+    contextKey: string;
+    kind: "direct";
+    membership: ResolvedTeamMembershipContext;
+    teamNode: ResolvedTeamNode;
+}
+export interface RepresentativeContext {
+    contextKey: string;
+    delegateRole: "lead" | "representative";
+    kind: "representative";
+    parentTeamNode: ResolvedTeamNode;
+    representedMember: ResolvedMemberRef;
+    representativeMemberId: string;
+    representativeSource: string;
+}
+export type AgentContext = DirectContext | RepresentativeContext;
+export interface TeamContextIndex {
+    direct_memberships: Array<Record<string, unknown>>;
+    representations: Array<Record<string, unknown>>;
+}

package/dist/compiler/teamRoster.d.ts

@@ -0,0 +1,12 @@
+import type { DiagnosticReport } from "../report/index.js";
+import { type TeamRepresentativeResolution } from "./moltnetResolution.js";
+export type { GeneratedTeamRoster, GenerateTeamRosterOptions, Roster, RosterEntry, RosterRepresentativeEntry } from "./teamRosterTypes.js";
+import type { GeneratedTeamRoster, GenerateTeamRosterOptions } from "./teamRosterTypes.js";
+import type { CompilePlan, ResolvedTeamNode } from "./types.js";
+export { getVisibleTeamMembers } from "./teamRosterEntries.js";
+export declare const generateTeamRoster: (teamNode: ResolvedTeamNode, plan: CompilePlan, options: GenerateTeamRosterOptions) => GeneratedTeamRoster;
+export declare const generateTeamRosters: (teamNode: ResolvedTeamNode, plan: CompilePlan) => {
+    diagnostics: DiagnosticReport[];
+    rosters: Map<string, string>;
+};
+export declare const listTeamRepresentatives: (plan: CompilePlan, teamNode: ResolvedTeamNode) => TeamRepresentativeResolution[];

package/dist/compiler/teamRoster.js

@@ -0,0 +1,48 @@
+import YAML from "yaml";
+import { resolveTeamRepresentatives } from "./moltnetResolution.js";
+import { collectConcreteParticipants, createCoordinationDiagnostics, createRosterEntry, getVisibleTeamMembers } from "./teamRosterEntries.js";
+export { getVisibleTeamMembers } from "./teamRosterEntries.js";
+export const generateTeamRoster = (teamNode, plan, options) => {
+    const visibleMembers = getVisibleTeamMembers(teamNode, options.selfMemberId, options.delegateRole, options.representedSlotId);
+    const roster = {
+        ...(options.representedSlotId && options.delegateRole
+            ? {
+                context_kind: "representative",
+                represents: {
+                    delegate_role: options.delegateRole,
+                    representative: options.selfMemberId,
+                    slot: options.representedSlotId
+                }
+            }
+            : { context_kind: "direct" }),
+        lead: teamNode.lead,
+        members: Object.fromEntries(visibleMembers.map((member) => [
+            member.id,
+            createRosterEntry(plan, teamNode, member, options)
+        ])),
+        mode: teamNode.mode,
+        self: options.selfMemberId,
+        team: teamNode.name
+    };
+    const participants = collectConcreteParticipants(plan, teamNode, options.selfMemberId, visibleMembers, options.representedSlotId);
+    return {
+        diagnostics: createCoordinationDiagnostics(plan, teamNode, participants, options.teamSource),
+        roster: YAML.stringify(roster),
+        visibleMembers
+    };
+};
+export const generateTeamRosters = (teamNode, plan) => {
+    const diagnostics = [];
+    const rosters = new Map();
+    for (const member of teamNode.members.filter((entry) => entry.kind === "agent")) {
+        const generated = generateTeamRoster(teamNode, plan, {
+            contextKey: teamNode.name,
+            selfMemberId: member.id,
+            teamSource: teamNode.source
+        });
+        rosters.set(member.id, generated.roster);
+        diagnostics.push(...generated.diagnostics);
+    }
+    return { diagnostics, rosters };
+};
+export const listTeamRepresentatives = (plan, teamNode) => resolveTeamRepresentatives(plan, teamNode);

package/dist/compiler/teamRosterEntries.d.ts

@@ -0,0 +1,13 @@
+import type { DiagnosticReport } from "../report/index.js";
+import type { GenerateTeamRosterOptions, RosterEntry } from "./teamRosterTypes.js";
+import type { CompilePlan, ResolvedMemberRef, ResolvedTeamNode } from "./types.js";
+export declare const getVisibleTeamMembers: (teamNode: ResolvedTeamNode, selfMemberId: string, delegateRole?: "lead" | "representative", representedSlotId?: string) => ResolvedMemberRef[];
+export declare const createRosterEntry: (plan: CompilePlan, teamNode: ResolvedTeamNode, member: ResolvedMemberRef, options: GenerateTeamRosterOptions) => RosterEntry;
+export declare const collectConcreteParticipants: (plan: CompilePlan, teamNode: ResolvedTeamNode, selfMemberId: string, visibleMembers: ResolvedMemberRef[], representedSlotId?: string) => Array<{
+    agentSource: string;
+    id: string;
+}>;
+export declare const createCoordinationDiagnostics: (plan: CompilePlan, teamNode: ResolvedTeamNode, participants: Array<{
+    agentSource: string;
+    id: string;
+}>, contextTeamSource: string) => DiagnosticReport[];