spawnfile 0.1.4 → 0.1.5

package/dist/cli/lifecycleCommands.d.ts

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

package/dist/cli/lifecycleCommands.js

@@ -0,0 +1,80 @@
+export const registerLifecycleCommands = (program, handlers, streams) => {
+    program
+        .command("compile")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("-o, --out <directory>", "Output directory")
+        .action(async (inputPath, options) => {
+        const result = await handlers.compileProject(inputPath, { outputDirectory: options.out });
+        streams.stdout(`compiled to ${result.outputDirectory}`);
+        streams.stdout(`report: ${result.reportPath}`);
+    });
+    program
+        .command("build")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("--docker-command <command>", "Docker command")
+        .option("-o, --out <directory>", "Output directory")
+        .option("-t, --tag <image>", "Docker image tag")
+        .action(async (inputPath, options) => {
+        const result = await handlers.buildProject(inputPath, {
+            dockerCommand: options.dockerCommand,
+            imageTag: options.tag,
+            outputDirectory: options.out
+        });
+        streams.stdout(`built image ${result.imageTag}`);
+        streams.stdout(`compiled to ${result.outputDirectory}`);
+        streams.stdout(`report: ${result.reportPath}`);
+    });
+    program
+        .command("run")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("-o, --out <directory>", "Output directory")
+        .option("-t, --tag <image>", "Docker image tag")
+        .option("--auth-profile <name>", "Local Spawnfile auth profile")
+        .option("--docker-command <command>", "Docker command")
+        .option("--name <container>", "Docker container name")
+        .option("--env-file <file>", "Path to an env file for runtime secrets")
+        .option("-d, --detach", "Run the container in detached mode")
+        .action(async (inputPath, options) => {
+        const result = await handlers.runProject(inputPath, {
+            authProfile: options.authProfile,
+            containerName: options.name,
+            detach: options.detach,
+            dockerCommand: options.dockerCommand,
+            envFilePath: options.envFile,
+            imageTag: options.tag,
+            outputDirectory: options.out
+        });
+        if (options.detach) {
+            streams.stdout(`running container ${result.containerName ?? "unknown"}`);
+            streams.stdout(`image: ${result.imageTag}`);
+        }
+    });
+    program
+        .command("up")
+        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
+        .option("-o, --out <directory>", "Output directory")
+        .option("-t, --tag <image>", "Docker image tag")
+        .option("--auth-profile <name>", "Local Spawnfile auth profile")
+        .option("--docker-command <command>", "Docker command")
+        .option("--name <container>", "Docker container name")
+        .option("--env-file <file>", "Path to an env file for runtime secrets")
+        .option("-d, --detach", "Run the container in detached mode")
+        .action(async (inputPath, options) => {
+        const result = await handlers.upProject(inputPath, {
+            authProfile: options.authProfile,
+            containerName: options.name,
+            detach: options.detach,
+            dockerCommand: options.dockerCommand,
+            envFilePath: options.envFile,
+            imageTag: options.tag,
+            outputDirectory: options.out
+        });
+        streams.stdout(`built image ${result.imageTag}`);
+        streams.stdout(`compiled to ${result.outputDirectory}`);
+        streams.stdout(`report: ${result.reportPath}`);
+        if (options.detach) {
+            streams.stdout(`running container ${result.containerName ?? "unknown"}`);
+            streams.stdout(`image: ${result.imageTag}`);
+        }
+    });
+};

package/dist/cli/runCli.d.ts

@@ -1,5 +1,5 @@
 import { importClaudeCodeAuth, importCodexAuth, importEnvFile, requireAuthProfile } from "../auth/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 { addAgentProject, addProjectSurface, addProjectModelFallback, addSubagentProject, addTeamProject, buildOrganizationView, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, upProject, removeProjectSurface, runProject, setProjectPrimaryModel, setProjectRuntime, setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth } from "../compiler/index.js";
 import { listRuntimeAdapters } from "../runtime/index.js";
 export interface CliStreams {
     stderr: (message: string) => void;
@@ -29,6 +29,7 @@ export interface CliHandlers {
     removeProjectSurface: typeof removeProjectSurface;
     requireAuthProfile: typeof requireAuthProfile;
     runProject: typeof runProject;
+    upProject: typeof upProject;
     setProjectPrimaryModel: typeof setProjectPrimaryModel;
     setProjectRuntime: typeof setProjectRuntime;
     setProjectSurfaceAccess: typeof setProjectSurfaceAccess;

package/dist/cli/runCli.js

@@ -1,8 +1,9 @@
 import { Command } from "commander";
 import { importClaudeCodeAuth, importCodexAuth, importEnvFile, requireAuthProfile } from "../auth/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 { addAgentProject, addProjectSurface, addProjectModelFallback, addSubagentProject, addTeamProject, buildOrganizationView, buildCompilePlan, buildProject, clearProjectModelFallbacks, compileProject, initProject, upProject, removeProjectSurface, runProject, setProjectPrimaryModel, setProjectRuntime, setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth } from "../compiler/index.js";
 import { isSpawnfileError } from "../shared/index.js";
 import { listRuntimeAdapters } from "../runtime/index.js";
+import { registerLifecycleCommands } from "./lifecycleCommands.js";
 import { registerModelCommands } from "./modelCommands.js";
 import { registerRuntimeCommands } from "./runtimeCommands.js";
 import { registerSurfaceCommands } from "./surfaceCommands.js";
@@ -22,7 +23,7 @@ const createDefaultHandlers = () => ({
     addSubagentProject, addTeamProject, clearProjectModelFallbacks,
     importClaudeCodeAuth, importCodexAuth, importEnvFile,
     initProject, listRuntimeAdapters, removeProjectSurface, requireAuthProfile,
-    runProject, setProjectPrimaryModel, setProjectRuntime,
+    runProject, setProjectPrimaryModel, setProjectRuntime, upProject,
     setProjectSurfaceAccess, showProjectSurfaces, syncProjectAuth
 });
 const isCliStreams = (value) => {
@@ -83,52 +84,7 @@ export const runCli = async (argv, optionsOrStreams, handlerOverrides = {}) => {
         writeErr: (message) => writeCommanderOutput(streams.stderr, message),
         writeOut: (message) => writeCommanderOutput(streams.stdout, message)
     });
-    program
-        .command("compile")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .option("-o, --out <directory>", "Output directory")
-        .action(async (inputPath, options) => {
-        const result = await handlers.compileProject(inputPath, { outputDirectory: options.out });
-        streams.stdout(`compiled to ${result.outputDirectory}`);
-        streams.stdout(`report: ${result.reportPath}`);
-    });
-    program
-        .command("build")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .option("-o, --out <directory>", "Output directory")
-        .option("-t, --tag <image>", "Docker image tag")
-        .action(async (inputPath, options) => {
-        const result = await handlers.buildProject(inputPath, {
-            imageTag: options.tag,
-            outputDirectory: options.out
-        });
-        streams.stdout(`built image ${result.imageTag}`);
-        streams.stdout(`compiled to ${result.outputDirectory}`);
-        streams.stdout(`report: ${result.reportPath}`);
-    });
-    program
-        .command("run")
-        .argument("[path]", "Project directory or Spawnfile path", process.cwd())
-        .option("-o, --out <directory>", "Output directory")
-        .option("-t, --tag <image>", "Docker image tag")
-        .option("--auth-profile <name>", "Local Spawnfile auth profile")
-        .option("--name <container>", "Docker container name")
-        .option("--env-file <file>", "Path to an env file for runtime secrets")
-        .option("-d, --detach", "Run the container in detached mode")
-        .action(async (inputPath, options) => {
-        const result = await handlers.runProject(inputPath, {
-            authProfile: options.authProfile,
-            containerName: options.name,
-            detach: options.detach,
-            envFilePath: options.envFile,
-            imageTag: options.tag,
-            outputDirectory: options.out
-        });
-        if (options.detach) {
-            streams.stdout(`running container ${result.containerName ?? "unknown"}`);
-            streams.stdout(`image: ${result.imageTag}`);
-        }
-    });
+    registerLifecycleCommands(program, handlers, streams);
     program
         .command("init")
         .argument("[path]", "Directory to initialize", process.cwd())

package/dist/compiler/buildCompilePlan.js

@@ -1,17 +1,10 @@
-import { getCanonicalManifestPath, getManifestPath, resolveProjectPath } from "../filesystem/index.js";
-import { isAgentManifest, isTeamManifest, loadManifest, mergeExecution } from "../manifest/index.js";
-import { SpawnfileError } from "../shared/index.js";
-import { getAgentFingerprint, getMcpNames, getTeamFingerprint, validateEffectiveSkillRequirements } from "./compilePlanHelpers.js";
-import { resolveAgentSurfaces } from "./agentSurfaces.js";
+import { getCanonicalManifestPath, getManifestPath } from "../filesystem/index.js";
+import { loadManifest, isAgentManifest } from "../manifest/index.js";
 import { assignStableNodeIds } from "./helpers.js";
-import { loadResolvedDocuments, mergeResolvedSkills, loadResolvedSkills, mergeSharedSurface } from "./surfaces.js";
-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";
+import { createRuntimeGroups } from "./buildCompilePlanRuntime.js";
+import { createCompilePlanTraversal } from "./buildCompilePlanTraversal.js";
 export const buildCompilePlan = async (inputPath) => {
     const rootManifestPath = getCanonicalManifestPath(getManifestPath(inputPath));
     const loadCache = new Map();
@@ -19,7 +12,6 @@ export const buildCompilePlan = async (inputPath) => {
     const fingerprintCache = new Map();
     const edges = [];
     const memberships = new Map();
-    const visitStack = [];
     const getLoadedManifest = (manifestPath) => {
         const canonicalPath = getCanonicalManifestPath(manifestPath);
         const cached = loadCache.get(canonicalPath);
@@ -30,186 +22,13 @@ export const buildCompilePlan = async (inputPath) => {
         loadCache.set(canonicalPath, promise);
         return promise;
     };
-    const visitAgent = async (manifestPath, context) => {
-        const canonicalPath = getCanonicalManifestPath(manifestPath);
-        if (visitStack.includes(canonicalPath)) {
-            throw new SpawnfileError("compile_error", `Cycle detected while visiting ${canonicalPath}`);
-        }
-        const loadedManifest = await getLoadedManifest(canonicalPath);
-        if (!isAgentManifest(loadedManifest.manifest)) {
-            throw new SpawnfileError("compile_error", `Expected agent manifest, got ${loadedManifest.manifest.kind} at ${canonicalPath}`);
-        }
-        const runtime = await resolveRuntime(loadedManifest.manifest, context);
-        const execution = applyExecutionDefaults(context.isSubagent
-            ? mergeExecution(context.inheritedExecution, loadedManifest.manifest.execution)
-            : loadedManifest.manifest.execution);
-        assertRuntimeSupportsExecutionModelAuth(runtime.name, execution, loadedManifest.manifest.name);
-        const sharedSurface = mergeSharedSurface(context.inheritedShared?.surface, {
-            env: loadedManifest.manifest.env,
-            mcpServers: loadedManifest.manifest.mcp_servers,
-            secrets: loadedManifest.manifest.secrets,
-            skills: loadedManifest.manifest.skills
-        });
-        const inheritedSkills = context.inheritedShared
-            ? await loadResolvedSkills(context.inheritedShared.manifestPath, context.inheritedShared.surface?.skills)
-            : [];
-        const localSkills = await loadResolvedSkills(canonicalPath, loadedManifest.manifest.skills);
-        const skills = mergeResolvedSkills(inheritedSkills, localSkills);
-        validateEffectiveSkillRequirements(loadedManifest.manifest.name, getMcpNames(sharedSurface.mcpServers), skills);
-        const docs = await loadResolvedDocuments(canonicalPath, loadedManifest.manifest.docs);
-        const candidate = {
-            description: resolveDescription(loadedManifest.manifest.description, docs),
-            docs,
-            env: sharedSurface.env,
-            execution,
-            expose: loadedManifest.manifest.expose ?? false,
-            kind: "agent",
-            mcpServers: sharedSurface.mcpServers,
-            name: loadedManifest.manifest.name,
-            policyMode: loadedManifest.manifest.policy?.mode ?? null,
-            policyOnDegrade: loadedManifest.manifest.policy?.on_degrade ?? null,
-            runtime,
-            secrets: sharedSurface.secrets,
-            skills,
-            source: canonicalPath,
-            surfaces: resolveAgentSurfaces(loadedManifest.manifest.surfaces),
-            subagents: []
-        };
-        assertRuntimeSupportsAgentSurfaces(runtime.name, candidate.surfaces, loadedManifest.manifest.name);
-        const fingerprint = getAgentFingerprint(candidate);
-        const existingFingerprint = fingerprintCache.get(canonicalPath);
-        if (existingFingerprint && existingFingerprint !== fingerprint) {
-            throw new SpawnfileError("compile_error", `Manifest ${canonicalPath} resolves differently across compile contexts`);
-        }
-        const cachedNode = nodeCache.get(canonicalPath);
-        if (cachedNode) {
-            return cachedNode.value;
-        }
-        fingerprintCache.set(canonicalPath, fingerprint);
-        nodeCache.set(canonicalPath, {
-            runtimeName: runtime.name,
-            source: canonicalPath,
-            value: candidate
-        });
-        visitStack.push(canonicalPath);
-        for (const subagent of loadedManifest.manifest.subagents ?? []) {
-            const childManifestPath = getManifestPath(resolveProjectPath(canonicalPath, subagent.ref));
-            const resolvedSubagent = await visitAgent(childManifestPath, {
-                inheritedExecution: execution,
-                inheritedRuntime: runtime,
-                isSubagent: true
-            });
-            candidate.subagents.push({
-                id: subagent.id,
-                nodeSource: resolvedSubagent.source
-            });
-            edges.push({
-                from: canonicalPath,
-                kind: "subagent",
-                label: subagent.id,
-                to: resolvedSubagent.source
-            });
-        }
-        visitStack.pop();
-        return candidate;
-    };
-    const visitTeam = async (manifestPath) => {
-        const canonicalPath = getCanonicalManifestPath(manifestPath);
-        if (visitStack.includes(canonicalPath)) {
-            throw new SpawnfileError("compile_error", `Cycle detected while visiting ${canonicalPath}`);
-        }
-        const loadedManifest = await getLoadedManifest(canonicalPath);
-        if (!isTeamManifest(loadedManifest.manifest)) {
-            throw new SpawnfileError("compile_error", `Expected team manifest, got ${loadedManifest.manifest.kind} at ${canonicalPath}`);
-        }
-        const sharedSkills = await loadResolvedSkills(canonicalPath, loadedManifest.manifest.shared?.skills);
-        validateEffectiveSkillRequirements(loadedManifest.manifest.name, getMcpNames(loadedManifest.manifest.shared?.mcp_servers ?? []), sharedSkills);
-        const manifest = loadedManifest.manifest;
-        const resolvedExternal = resolveTeamExternalIds(manifest);
-        const docs = await loadResolvedDocuments(canonicalPath, manifest.docs);
-        const candidate = {
-            description: manifest.description ? normalizeDescription(manifest.description) : "",
-            docs,
-            external: resolvedExternal,
-            externalExplicit: manifest.external !== undefined,
-            kind: "team",
-            lead: manifest.lead ?? null,
-            members: [],
-            mode: manifest.mode,
-            name: manifest.name,
-            networks: resolveTeamNetworks(manifest),
-            policyMode: manifest.policy?.mode ?? null,
-            policyOnDegrade: manifest.policy?.on_degrade ?? null,
-            shared: {
-                env: manifest.shared?.env ?? {},
-                mcpServers: manifest.shared?.mcp_servers ?? [],
-                secrets: manifest.shared?.secrets ?? [],
-                skills: sharedSkills
-            },
-            source: canonicalPath,
-        };
-        const fingerprint = getTeamFingerprint(candidate);
-        const existingFingerprint = fingerprintCache.get(canonicalPath);
-        if (existingFingerprint && existingFingerprint !== fingerprint) {
-            throw new SpawnfileError("compile_error", `Team manifest ${canonicalPath} resolves differently across compile contexts`);
-        }
-        const cachedNode = nodeCache.get(canonicalPath);
-        if (cachedNode) {
-            return cachedNode.value;
-        }
-        fingerprintCache.set(canonicalPath, fingerprint);
-        nodeCache.set(canonicalPath, {
-            runtimeName: null,
-            source: canonicalPath,
-            value: candidate
-        });
-        visitStack.push(canonicalPath);
-        for (const member of loadedManifest.manifest.members) {
-            const childManifestPath = getManifestPath(resolveProjectPath(canonicalPath, member.ref));
-            const childManifest = await getLoadedManifest(childManifestPath);
-            let resolvedMember;
-            if (isAgentManifest(childManifest.manifest)) {
-                const resolvedAgent = await visitAgent(childManifestPath, {
-                    inheritedShared: {
-                        manifestPath: canonicalPath,
-                        surface: loadedManifest.manifest.shared
-                    },
-                    isSubagent: false
-                });
-                resolvedMember = {
-                    id: member.id,
-                    kind: "agent",
-                    nodeSource: resolvedAgent.source,
-                    runtimeName: resolvedAgent.runtime.name
-                };
-                memberships.set(`${canonicalPath}::${member.id}::${resolvedAgent.source}`, {
-                    agentSource: resolvedAgent.source,
-                    memberId: member.id,
-                    teamName: candidate.name,
-                    teamSource: canonicalPath
-                });
-            }
-            else {
-                const resolvedTeam = await visitTeam(childManifestPath);
-                resolvedMember = {
-                    id: member.id,
-                    kind: "team",
-                    nodeSource: resolvedTeam.source,
-                    runtimeName: null
-                };
-            }
-            candidate.members.push(resolvedMember);
-            edges.push({
-                from: canonicalPath,
-                kind: "team_member",
-                label: member.id,
-                to: resolvedMember.nodeSource
-            });
-        }
-        validateTeamNetworkRooms(candidate);
-        visitStack.pop();
-        return candidate;
-    };
+    const { visitAgent, visitTeam } = createCompilePlanTraversal({
+        getLoadedManifest,
+        nodeCache,
+        edges,
+        fingerprintCache,
+        memberships
+    });
     const rootLoadedManifest = await getLoadedManifest(rootManifestPath);
     if (isAgentManifest(rootLoadedManifest.manifest)) {
         await visitAgent(rootManifestPath, { isSubagent: false });
@@ -234,21 +53,12 @@ export const buildCompilePlan = async (inputPath) => {
         from: idBySource.get(edge.from) ?? edge.from,
         to: idBySource.get(edge.to) ?? edge.to
     }));
-    const runtimes = compilePlanNodes.reduce((groups, node) => {
-        if (!node.runtimeName) {
-            return groups;
-        }
-        const group = groups[node.runtimeName] ?? { nodeIds: [] };
-        group.nodeIds.push(node.id);
-        groups[node.runtimeName] = group;
-        return groups;
-    }, {});
     const compilePlan = {
         edges: compilePlanEdges,
         memberships: [...memberships.values()].sort((left, right) => `${left.agentSource}:${left.teamSource}:${left.memberId}`.localeCompare(`${right.agentSource}:${right.teamSource}:${right.memberId}`)),
         nodes: compilePlanNodes,
         root: rootManifestPath,
-        runtimes
+        runtimes: createRuntimeGroups(compilePlanNodes)
     };
     compilePlan.moltnetRoomMemberships = resolveMoltnetRoomMemberships(compilePlan);
     resolvePlanMoltnetAttachments(compilePlan);

package/dist/compiler/buildCompilePlanRuntime.d.ts

@@ -1,7 +1,9 @@
 import { type AgentManifest, type ExecutionBlock, type SharedSurface } from "../manifest/index.js";
-import type { ResolvedDocument, ResolvedRuntime } from "./types.js";
+import type { CompilePlanNode, ResolvedDocument, ResolvedRuntime } from "./types.js";
+import type { ResolvedWorkspaceResource } from "./workspaceResources.js";
 export interface AgentVisitContext {
     inheritedExecution?: ExecutionBlock;
+    inheritedResources?: ResolvedWorkspaceResource[];
     inheritedShared?: {
         manifestPath: string;
         surface: SharedSurface | undefined;
@@ -12,3 +14,6 @@ export interface AgentVisitContext {
 export declare const resolveRuntime: (manifest: AgentManifest, context: AgentVisitContext) => Promise<ResolvedRuntime>;
 export declare const normalizeDescription: (description: string) => string;
 export declare const resolveDescription: (description: string | undefined, docs: ResolvedDocument[]) => string;
+export declare const createRuntimeGroups: (nodes: CompilePlanNode[]) => Record<string, {
+    nodeIds: string[];
+}>;

package/dist/compiler/buildCompilePlanRuntime.js

@@ -37,3 +37,12 @@ const deriveDescriptionFromDocs = (docs) => {
 export const resolveDescription = (description, docs) => description !== undefined
     ? normalizeDescription(description)
     : deriveDescriptionFromDocs(docs);
+export const createRuntimeGroups = (nodes) => nodes.reduce((groups, node) => {
+    if (!node.runtimeName) {
+        return groups;
+    }
+    const group = groups[node.runtimeName] ?? { nodeIds: [] };
+    group.nodeIds.push(node.id);
+    groups[node.runtimeName] = group;
+    return groups;
+}, {});

package/dist/compiler/buildCompilePlanTeams.js

@@ -14,16 +14,22 @@ export const resolveTeamExternalIds = (manifest) => {
             ? [manifest.lead]
             : memberIds);
 };
-export const resolveTeamNetworks = (manifest) => (manifest.networks ?? []).map((network) => ({
-    expose: network.expose ?? false,
-    id: network.id,
-    name: network.name ?? network.id,
-    provider: network.provider,
-    rooms: network.rooms.map((room) => ({
-        id: room.id,
-        members: [...room.members]
-    }))
-}));
+export const resolveTeamNetworks = (manifest) => (manifest.networks ?? []).map((network) => {
+    const resolved = {
+        id: network.id,
+        name: network.name ?? network.id,
+        provider: network.provider,
+        rooms: network.rooms.map((room) => ({
+            id: room.id,
+            members: [...room.members],
+            ...(room.name ? { name: room.name } : {})
+        }))
+    };
+    if (network.server) {
+        resolved.server = network.server;
+    }
+    return resolved;
+});
 export const validateTeamNetworkRooms = (teamNode) => {
     for (const network of teamNode.networks ?? []) {
         for (const room of network.rooms) {

package/dist/compiler/buildCompilePlanTraversal.d.ts

@@ -0,0 +1,16 @@
+import { LoadedManifest } from "../manifest/index.js";
+import { CompilePlanEdge, ResolvedAgentNode, ResolvedTeamMembershipContext, ResolvedTeamNode } from "./types.js";
+import { type AgentVisitContext } from "./buildCompilePlanRuntime.js";
+import { type InternalNode } from "./buildCompilePlanTraversalHelpers.js";
+type BuildCompilePlanTraversalDeps = {
+    getLoadedManifest: (manifestPath: string) => Promise<LoadedManifest>;
+    nodeCache: Map<string, InternalNode>;
+    fingerprintCache: Map<string, string>;
+    edges: CompilePlanEdge[];
+    memberships: Map<string, ResolvedTeamMembershipContext>;
+};
+export declare const createCompilePlanTraversal: ({ getLoadedManifest, nodeCache, fingerprintCache, edges, memberships }: BuildCompilePlanTraversalDeps) => {
+    visitAgent: (manifestPath: string, context: AgentVisitContext) => Promise<ResolvedAgentNode>;
+    visitTeam: (manifestPath: string, inheritedResources?: ResolvedAgentNode["workspaceResources"]) => Promise<ResolvedTeamNode>;
+};
+export type { InternalNode };