spawnfile 0.1.13 → 0.1.14

package/dist/compiler/runProjectDocker.js

@@ -132,25 +132,47 @@ const prepareRemoteBindMounts = async (invocation) => {
         }
     };
 };
-const inspectImageArgs = (invocation, containerId) => {
+export const createDetachedContainerInspectArgs = (invocation, containerId) => {
     const base = invocation.dockerContext
         ? ["--context", invocation.dockerContext, "inspect"]
         : invocation.dockerHost
             ? ["--host", invocation.dockerHost, "inspect"]
             : ["inspect"];
-    return [...base, "--format", "{{.Image}}", containerId];
+    return [...base, "--format", "{{json .Id}}\n{{json .Image}}\n{{json .Config.Labels}}", containerId];
 };
-const inspectDetachedImageId = async (invocation, containerId) => {
+export const parseDetachedContainerInspect = (stdout, expectedContainerId, expectedLabels) => {
+    const [idRaw, imageRaw, labelsRaw, ...extra] = stdout.trim().split("\n");
+    if (!idRaw || !imageRaw || !labelsRaw || extra.length > 0)
+        throw new Error("unexpected inspect response");
+    const actualId = JSON.parse(idRaw);
+    const imageId = JSON.parse(imageRaw);
+    const labels = JSON.parse(labelsRaw);
+    if (typeof actualId !== "string" || actualId !== expectedContainerId || !/^[a-f0-9]{64}$/u.test(actualId)
+        || typeof imageId !== "string" || !/^sha256:[a-f0-9]{64}$/u.test(imageId))
+        throw new Error("malformed detached container metadata");
+    if (!expectedLabels)
+        return { containerId: actualId, imageId };
+    if (!labels || typeof labels !== "object" || Array.isArray(labels))
+        throw new Error("missing detached deployment labels");
+    const actual = Object.fromEntries(Object.keys(expectedLabels).sort().map((key) => {
+        const value = labels[key];
+        if (typeof value !== "string" || value !== expectedLabels[key])
+            throw new Error("detached deployment label drift");
+        return [key, value];
+    }));
+    return { containerId: actualId, imageId, deploymentLabels: actual };
+};
+const inspectDetachedContainer = async (invocation, containerId) => {
     try {
-        const { stdout } = await execFile(invocation.command, inspectImageArgs(invocation, containerId), {
+        const { stdout } = await execFile(invocation.command, createDetachedContainerInspectArgs(invocation, containerId), {
             cwd: invocation.cwd,
             timeout: 10_000
         });
-        return stdout.trim() || undefined;
+        return parseDetachedContainerInspect(stdout, containerId, invocation.deploymentLabels);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        throw new SpawnfileError("runtime_error", `Unable to inspect detached container ${containerId} image id: ${message}`);
+        throw new SpawnfileError("runtime_error", `Unable to inspect detached container ${containerId}: ${message}`);
     }
 };
 const runPreparedDockerContainer = (prepared) => new Promise((resolve, reject) => {
@@ -181,8 +203,9 @@ const runPreparedDockerContainer = (prepared) => new Promise((resolve, reject) =
                 settle(() => resolve(undefined));
                 return;
             }
-            inspectDetachedImageId(prepared.invocation, containerId)
-                .then((imageId) => resolve({ containerId, ...(imageId ? { imageId } : {}) }))
+            Promise.resolve(prepared.invocation.onDetachedStarted?.({ containerId }))
+                .then(() => inspectDetachedContainer(prepared.invocation, containerId))
+                .then(resolve)
                 .catch(reject);
             return;
         }

package/dist/compiler/runProjectLifecycle.d.ts

@@ -0,0 +1,7 @@
+import type { DockerRunInvocation, DockerRunResult, DockerRunRunner } from "./runProjectDocker.js";
+/**
+ * Docker consumes an env file before a detached container is started, so the
+ * generated copy must not become a durable credential store. Other files in
+ * the support directory may be active bind-mount sources and must remain.
+ */
+export declare const executeDockerRunWithSupportCleanup: (invocation: DockerRunInvocation, runner: DockerRunRunner) => Promise<DockerRunResult | void>;

package/dist/compiler/runProjectLifecycle.js

@@ -0,0 +1,40 @@
+import { rm } from "node:fs/promises";
+import { removeDirectory } from "../filesystem/index.js";
+/**
+ * Docker consumes an env file before a detached container is started, so the
+ * generated copy must not become a durable credential store. Other files in
+ * the support directory may be active bind-mount sources and must remain.
+ */
+export const executeDockerRunWithSupportCleanup = async (invocation, runner) => {
+    let started = false;
+    try {
+        const runInvocation = invocation.detach
+            ? {
+                ...invocation,
+                onDetachedStarted: async (result) => {
+                    started = true;
+                    await rm(invocation.envFilePath, { force: true });
+                    await invocation.onDetachedStarted?.(result);
+                }
+            }
+            : invocation;
+        const result = await runner(runInvocation);
+        if (invocation.detach) {
+            if (!started) {
+                started = true;
+                await rm(invocation.envFilePath, { force: true });
+            }
+        }
+        else {
+            started = true;
+            await removeDirectory(invocation.supportDirectory);
+        }
+        return result;
+    }
+    catch (error) {
+        if (!started) {
+            await removeDirectory(invocation.supportDirectory);
+        }
+        throw error;
+    }
+};

package/dist/compiler/syncProjectAuth.js

@@ -4,7 +4,7 @@ import { SpawnfileError } from "../shared/index.js";
 import { listAgentSurfaceSecretNames } from "./agentSurfaces.js";
 import { buildCompilePlan } from "./buildCompilePlan.js";
 import { listMoltnetNetworkSecretNames } from "./compilePlanHelpers.js";
-import { listExecutionModelSecretNames, resolveExecutionModelAuthMethods } from "./modelEnv.js";
+import { CLI_CREDENTIAL_SECRET_NAME, listExecutionModelSecretNames, resolveExecutionModelAuthMethods } from "./modelEnv.js";
 const resolveAuthRequirements = async (inputPath) => {
     const plan = await buildCompilePlan(inputPath);
     const methods = new Set();
@@ -46,6 +46,9 @@ const resolveAuthRequirements = async (inputPath) => {
             methods.add(method);
         }
         for (const envName of listExecutionModelSecretNames(node.value.execution)) {
+            if (envName === CLI_CREDENTIAL_SECRET_NAME) {
+                continue;
+            }
             requiredEnvNames.add(envName);
             optionalEnvNames.delete(envName);
         }

package/dist/compiler/teamContextActiveEnvironments.d.ts

@@ -0,0 +1,13 @@
+import type { DiagnosticReport } from "../report/index.js";
+import type { CompileReportActiveEnvironments } from "../report/types.js";
+import type { AgentContext } from "./teamContextTypes.js";
+import type { CompilePlan, ResolvedAgentNode } from "./types.js";
+export type ActiveEnvironmentsIndex = CompileReportActiveEnvironments;
+export interface ActiveEnvironmentsResult {
+    activeEnvironments?: ActiveEnvironmentsIndex;
+    diagnostics: Array<{
+        source: string;
+        diagnostic: DiagnosticReport;
+    }>;
+}
+export declare const buildActiveEnvironments: (plan: CompilePlan, agentNode: ResolvedAgentNode, contexts: AgentContext[], directContextCount: number) => ActiveEnvironmentsResult;

package/dist/compiler/teamContextActiveEnvironments.js

@@ -0,0 +1,255 @@
+import { findTeamBySource, pathSafe } from "./teamContextHelpers.js";
+const ROOM_DERIVATION_RULE = "first_listed_room_member_containing_agent";
+const SCHEDULE_SINGLE_DIRECT_RULE = "single_direct_team_context_for_agent_schedule";
+const SCHEDULE_MULTI_CONTEXT_RULE = "multi_context_agent_schedule_uses_global_self";
+const agentSessionId = (agentNode) => pathSafe(agentNode.name);
+const getContextProfiles = (contexts) => contexts.map((context) => context.kind === "direct"
+    ? {
+        context,
+        contextKey: context.contextKey,
+        concreteMemberId: context.membership.memberId,
+        teamSource: context.teamNode.source
+    }
+    : {
+        context,
+        contextKey: context.contextKey,
+        concreteMemberId: context.representativeMemberId,
+        representedSlot: context.representedMember.id,
+        teamSource: context.parentTeamNode.source
+    });
+const contextKeyByMatch = {
+    direct: (teamSource, concreteMemberId) => `direct:${teamSource}:${concreteMemberId}`,
+    representative: (teamSource, representedSlot, concreteMemberId) => `representative:${teamSource}:${representedSlot}:${concreteMemberId}`
+};
+const findRoomMemberPosition = (plan, teamSource, networkId, roomId, memberSlot) => {
+    const teamNode = findTeamBySource(plan, teamSource);
+    if (!teamNode) {
+        return -1;
+    }
+    const network = teamNode.networks?.find((entry) => entry.id === networkId);
+    if (!network) {
+        return -1;
+    }
+    const room = network.rooms.find((entry) => entry.id === roomId);
+    if (!room) {
+        return -1;
+    }
+    return room.members.indexOf(memberSlot);
+};
+const deriveMoltnetEnvironments = (plan, agentNode, profiles) => {
+    const memberships = plan.moltnetRoomMemberships;
+    if (!memberships || memberships.length === 0) {
+        return { moltnet: undefined, diagnostics: [] };
+    }
+    const direct = new Map();
+    const representative = new Map();
+    const profileByContextKey = new Map();
+    for (const profile of profiles) {
+        profileByContextKey.set(profile.contextKey, profile);
+        if (profile.representedSlot === undefined) {
+            const key = contextKeyByMatch.direct(profile.teamSource, profile.concreteMemberId);
+            direct.set(key, [...(direct.get(key) ?? []), profile]);
+        }
+        else {
+            const key = contextKeyByMatch.representative(profile.teamSource, profile.representedSlot, profile.concreteMemberId);
+            representative.set(key, [...(representative.get(key) ?? []), profile]);
+        }
+    }
+    const diagnostics = [];
+    const byRoom = new Map();
+    for (const membership of memberships) {
+        if (membership.agentSource !== agentNode.source) {
+            continue;
+        }
+        const directProfiles = direct.get(contextKeyByMatch.direct(membership.directTeamSource, membership.concreteMemberId));
+        const representativeProfiles = membership.representedSlot
+            ? representative.get(contextKeyByMatch.representative(membership.declaringTeamSource, membership.representedSlot, membership.concreteMemberId))
+            : undefined;
+        const candidateProfiles = plan.organizationIdentity
+            ? profiles.filter((profile) => membership.representedSlot
+                ? profile.representedSlot === membership.representedSlot &&
+                    profile.teamSource === membership.declaringTeamSource
+                : profile.representedSlot === undefined &&
+                    profile.teamSource === membership.directTeamSource)
+            : membership.representedSlot
+                ? representativeProfiles
+                : directProfiles;
+        if (!candidateProfiles || candidateProfiles.length === 0) {
+            diagnostics.push({
+                source: membership.declaringTeamSource,
+                diagnostic: {
+                    level: "error",
+                    message: `Unable to derive active moltnet context for ${agentNode.name} in ${membership.networkId}/${membership.roomId}`
+                }
+            });
+            continue;
+        }
+        const memberPosition = findRoomMemberPosition(plan, membership.declaringTeamSource, membership.networkId, membership.roomId, membership.declaredSlot);
+        if (memberPosition === -1) {
+            diagnostics.push({
+                source: membership.declaringTeamSource,
+                diagnostic: {
+                    level: "error",
+                    message: `Unable to locate room member ${membership.declaredSlot} for ${membership.networkId}/${membership.roomId} in ${agentNode.name}`
+                }
+            });
+            continue;
+        }
+        const roomKey = `${membership.networkId}\u0000${membership.roomId}`;
+        byRoom.set(roomKey, [
+            ...(byRoom.get(roomKey) ?? []),
+            ...candidateProfiles.map((profile) => ({ profile, memberPosition }))
+        ]);
+    }
+    const moltnet = {};
+    for (const [roomBindingKey, candidates] of byRoom) {
+        if (candidates.length === 0) {
+            continue;
+        }
+        const roomKeyed = new Map();
+        for (const candidate of candidates) {
+            const existing = roomKeyed.get(candidate.profile.contextKey);
+            if (!existing || candidate.memberPosition < existing.memberPosition) {
+                roomKeyed.set(candidate.profile.contextKey, candidate);
+            }
+        }
+        const selected = [...roomKeyed.values()].sort((left, right) => {
+            if (left.memberPosition !== right.memberPosition) {
+                return left.memberPosition - right.memberPosition;
+            }
+            return left.profile.contextKey.localeCompare(right.profile.contextKey);
+        })[0];
+        if (!selected) {
+            continue;
+        }
+        const [networkId, roomId] = roomBindingKey.split("\u0000");
+        if (!networkId || !roomId) {
+            continue;
+        }
+        const profile = profileByContextKey.get(selected.profile.contextKey);
+        if (!profile) {
+            continue;
+        }
+        moltnet[networkId] ??= { rooms: {} };
+        moltnet[networkId].rooms[roomId] = {
+            context_key: profile.contextKey,
+            derivation: {
+                member_position: selected.memberPosition,
+                rule: ROOM_DERIVATION_RULE
+            },
+            member_slot: profile.representedSlot ?? profile.concreteMemberId,
+            roster: `.spawnfile/rosters/${profile.contextKey}.yaml`,
+            team_id: profile.contextKey,
+            team_doc: `.spawnfile/team-contexts/${profile.contextKey}/TEAM.md`,
+            session_key: `${agentSessionId(agentNode)}@moltnet:${networkId}:room:${roomId}`,
+            memory: {
+                durable_scope: {
+                    qualifier: profile.contextKey,
+                    scope: "team"
+                },
+                ephemeral_scope: {
+                    qualifier: `${networkId}:${roomId}`,
+                    scope: "room"
+                }
+            }
+        };
+    }
+    return {
+        moltnet: Object.keys(moltnet).length > 0 ? moltnet : undefined,
+        diagnostics
+    };
+};
+const deriveSchedules = (profiles, directContextCount, agentNode) => {
+    if (!agentNode.schedule || agentNode.schedule.kind === "disabled") {
+        return undefined;
+    }
+    const directProfile = directContextCount === 1
+        ? profiles.find((profile) => profile.context.kind === "direct")
+        : undefined;
+    const contextKey = directProfile ? directProfile.contextKey : "self";
+    return {
+        default: {
+            context_key: contextKey,
+            derivation: {
+                rule: directProfile ? SCHEDULE_SINGLE_DIRECT_RULE : SCHEDULE_MULTI_CONTEXT_RULE
+            },
+            environment_key: `schedule:${contextKey}`,
+            memory: {
+                durable_scope: {
+                    qualifier: directProfile ? directProfile.contextKey : agentSessionId(agentNode),
+                    scope: directProfile ? "team" : "global"
+                }
+            },
+            session_key: `${agentSessionId(agentNode)}@schedule:${contextKey}`
+        }
+    };
+};
+const hasAnyMemoryAccess = (agentNode) => (agentNode.memoryAccess?.length ?? 0) > 0 || (agentNode.memory?.length ?? 0) > 0;
+const resolveTeamMemoryScopes = (access) => {
+    if (access.declaringKind !== "team" || !access.slotId) {
+        return null;
+    }
+    return `${access.source}::${access.slotId}`;
+};
+const deriveDreams = (agentNode, profiles) => {
+    const dreams = {};
+    if (hasAnyMemoryAccess(agentNode)) {
+        dreams.self = {
+            context_key: "self",
+            environment_key: "dream:self",
+            memory: {
+                durable_scope: {
+                    qualifier: agentSessionId(agentNode),
+                    scope: "global"
+                }
+            },
+            session_key_template: `${agentSessionId(agentNode)}@dream:self:{run_id}`
+        };
+    }
+    const addProfileDream = (profile) => {
+        dreams[profile.contextKey] ??= {
+            context_key: profile.contextKey,
+            environment_key: `dream:${profile.contextKey}`,
+            memory: {
+                durable_scope: {
+                    qualifier: profile.contextKey,
+                    scope: "team"
+                }
+            },
+            session_key_template: `${agentSessionId(agentNode)}@dream:${profile.contextKey}:{run_id}`
+        };
+    };
+    if ((agentNode.memory?.length ?? 0) > 0) {
+        profiles.forEach(addProfileDream);
+    }
+    const profileByTeamSlot = new Map();
+    for (const profile of profiles) {
+        const key = `${profile.teamSource}::${profile.concreteMemberId}`;
+        profileByTeamSlot.set(key, [...(profileByTeamSlot.get(key) ?? []), profile]);
+    }
+    for (const access of agentNode.memoryAccess ?? []) {
+        const scopeKey = resolveTeamMemoryScopes(access);
+        if (!scopeKey) {
+            continue;
+        }
+        for (const profile of profileByTeamSlot.get(scopeKey) ?? []) {
+            addProfileDream(profile);
+        }
+    }
+    return Object.keys(dreams).length > 0 ? dreams : undefined;
+};
+export const buildActiveEnvironments = (plan, agentNode, contexts, directContextCount) => {
+    const profiles = getContextProfiles(contexts);
+    const moltnetResult = deriveMoltnetEnvironments(plan, agentNode, profiles);
+    const schedules = deriveSchedules(profiles, directContextCount, agentNode);
+    const dreams = deriveDreams(agentNode, profiles);
+    const activeEnvironments = {
+        ...(moltnetResult.moltnet ? { moltnet: moltnetResult.moltnet } : {}),
+        ...(schedules ? { schedules } : {}),
+        ...(dreams ? { dreams } : {})
+    };
+    if (Object.keys(activeEnvironments).length === 0) {
+        return { activeEnvironments: undefined, diagnostics: moltnetResult.diagnostics };
+    }
+    return { activeEnvironments, diagnostics: moltnetResult.diagnostics };
+};

package/dist/compiler/teamContextSupport.js

@@ -1,5 +1,6 @@
 import YAML from "yaml";
-import { buildContextOrientation, collectMoltnetBindings, createContextBaseKey, createVisibleTeamCards, findAgentBySource, findTeamBySource, getSystemTeamDoc, reportKeySegment, shortHash } from "./teamContextHelpers.js";
+import { buildContextOrientation, collectMoltnetBindings, createContextBaseKey, createVisibleTeamCards, findTeamBySource, getSystemTeamDoc, reportKeySegment, shortHash } from "./teamContextHelpers.js";
+import { buildActiveEnvironments } from "./teamContextActiveEnvironments.js";
 import { generateTeamRoster, listTeamRepresentatives } from "./teamRoster.js";
 const assignContextKeys = (contexts) => {
     const baseCounts = new Map();
@@ -84,6 +85,11 @@ const createTeamCapabilities = (teamNode) => [
         message: "Team context orientation was surfaced through runtime system instructions",
         outcome: "supported"
     },
+    {
+        key: "team.active_environments",
+        message: "Derived active environment bindings were emitted in team-contexts.yaml",
+        outcome: "supported"
+    },
     {
         key: "team.representatives",
         message: "Representative chains were resolved",
@@ -134,44 +140,11 @@ const createRepresentativeDiagnostics = (plan, teamNode) => {
     }
     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 activeEnvironmentsByAgentSource = new Map();
     const contextsByAgent = collectAgentContexts(plan);
     for (const node of plan.nodes) {
         if (node.value.kind !== "team") {
@@ -180,12 +153,24 @@ export const prepareTeamCompileSupport = async (plan) => {
         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) {
+    for (const node of plan.nodes) {
+        if (node.value.kind !== "agent") {
             continue;
         }
+        const agentNode = node.value;
+        const agentSource = agentNode.source;
+        const contexts = contextsByAgent.get(agentSource) ?? [];
         const directCount = contexts.filter((context) => context.kind === "direct").length;
+        const activeEnvironmentsResult = buildActiveEnvironments(plan, agentNode, contexts, directCount);
+        for (const { source, diagnostic } of activeEnvironmentsResult.diagnostics) {
+            addMapEntries(diagnosticsByTeamSource, source, [diagnostic]);
+        }
+        if (activeEnvironmentsResult.activeEnvironments !== undefined) {
+            activeEnvironmentsByAgentSource.set(agentSource, activeEnvironmentsResult.activeEnvironments);
+        }
+        if (contexts.length === 0 && activeEnvironmentsResult.activeEnvironments === undefined) {
+            continue;
+        }
         const directIndex = [];
         const representationIndex = [];
         const files = [];
@@ -247,6 +232,9 @@ export const prepareTeamCompileSupport = async (plan) => {
             }
         }
         const contextIndex = {
+            ...(activeEnvironmentsResult.activeEnvironments
+                ? { active_environments: activeEnvironmentsResult.activeEnvironments }
+                : {}),
             direct_memberships: directIndex,
             representations: representationIndex
         };
@@ -258,7 +246,11 @@ export const prepareTeamCompileSupport = async (plan) => {
             path: ".spawnfile/team-contexts.md"
         });
         filesByAgentSource.set(agentSource, files);
-        addAmbiguousBindingDiagnostics(agentNode, contexts, diagnosticsByTeamSource);
     }
-    return { capabilitiesByTeamSource, diagnosticsByTeamSource, filesByAgentSource };
+    return {
+        activeEnvironmentsByAgentSource,
+        capabilitiesByTeamSource,
+        diagnosticsByTeamSource,
+        filesByAgentSource
+    };
 };

package/dist/compiler/teamContextTypes.d.ts

@@ -1,7 +1,9 @@
 import type { CapabilityReport, DiagnosticReport } from "../report/index.js";
+import type { ActiveEnvironmentsIndex } from "./teamContextActiveEnvironments.js";
 import type { EmittedFile } from "../runtime/index.js";
 import type { ResolvedMemberRef, ResolvedTeamMembershipContext, ResolvedTeamNode } from "./types.js";
 export interface TeamCompileSupport {
+    activeEnvironmentsByAgentSource: Map<string, ActiveEnvironmentsIndex>;
     capabilitiesByTeamSource: Map<string, CapabilityReport[]>;
     diagnosticsByTeamSource: Map<string, DiagnosticReport[]>;
     filesByAgentSource: Map<string, EmittedFile[]>;

package/dist/compiler/types.d.ts

@@ -1,6 +1,7 @@
-import { AgentSchedule, ExecutionBlock, McpServer, ModelEndpoint, Secret, TeamNetworkServer } from "../manifest/index.js";
+import { AgentSchedule, ExecutionBlock, McpServer, MemoryConsolidation, MemoryRetention, ModelEndpoint, Secret, TeamNetworkServer, type ExternalParticipantService } from "../manifest/index.js";
 import { ModelAuthMethod, StringMap } from "../shared/index.js";
 import type { ResolvedWorkspaceResource } from "./workspaceResources.js";
+import type { ResolvedExternalParticipant, ResolvedOrganizationIdentity } from "./organizationIdentity.js";
 export interface ResolvedDocument {
     content: string;
     role: string;
@@ -86,8 +87,12 @@ export interface ResolvedMoltnetRoomPolicy {
 }
 export interface ResolvedMoltnetDMConfig extends ResolvedMoltnetRoomPolicy {
     enabled: boolean;
+    allowedWakeSenders?: string[];
 }
 export interface ResolvedMoltnetAttachment {
+    auth?: {
+        tokenId: string;
+    };
     contextRooms?: Record<string, string[]>;
     dms?: ResolvedMoltnetDMConfig;
     memberId: string | null;
@@ -123,6 +128,67 @@ export interface ResolvedTeamNetwork {
     rooms: ResolvedTeamNetworkRoom[];
     server?: TeamNetworkServer;
 }
+export interface ResolvedMemoryStorePersistence {
+    mode: "durable" | "ephemeral";
+    mount?: string;
+    name?: string;
+}
+export interface ResolvedMemoryStore {
+    kind: "json" | "memory" | "postgres" | "sqlite";
+    path?: string;
+    persistence?: ResolvedMemoryStorePersistence;
+    dsn_secret?: string;
+}
+export interface ResolvedMemoryIndex {
+    graph: {
+        enabled: boolean;
+        kind?: "entity_graph" | "temporal_kg";
+    };
+    lexical: {
+        enabled: boolean;
+        engine?: "bm25" | "sqlite_fts";
+    };
+    rerank: {
+        enabled: boolean;
+    };
+    vector: {
+        base_url?: string;
+        enabled: boolean;
+        model?: string;
+        provider?: "ollama";
+        dimensions?: number;
+        timeout_ms?: number;
+    };
+}
+export interface ResolvedMemoryConsolidation {
+    mode: MemoryConsolidation["mode"];
+    schedule?: string;
+    summarize_after_events?: number;
+}
+export interface ResolvedMemoryRetention {
+    forgetting: MemoryRetention["forgetting"];
+    ttl?: string;
+}
+export interface ResolvedMemoryBank {
+    access?: {
+        members?: string[];
+    };
+    consolidation: ResolvedMemoryConsolidation;
+    declaredBy: "agent" | "team";
+    declaredName: string;
+    id: string;
+    index: ResolvedMemoryIndex;
+    retention: ResolvedMemoryRetention;
+    source: string;
+    store: ResolvedMemoryStore;
+}
+export interface ResolvedMemoryAccess {
+    agentSource: string;
+    declaringKind: "agent" | "team";
+    slotId?: string;
+    source: string;
+    bank: ResolvedMemoryBank;
+}
 export interface EffectiveModelTarget {
     auth: {
         key?: string;
@@ -159,8 +225,11 @@ export interface ResolvedAgentNode {
     secrets: Secret[];
     skills: ResolvedSkill[];
     source: string;
+    sourcePath?: string;
     surfaces?: ResolvedAgentSurfaces;
     subagents: ResolvedSubagentRef[];
+    memory?: ResolvedMemoryBank[];
+    memoryAccess?: ResolvedMemoryAccess[];
     workspaceResources?: ResolvedWorkspaceResource[];
 }
 export interface ResolvedTeamNode {
@@ -168,6 +237,7 @@ export interface ResolvedTeamNode {
     docs: ResolvedDocument[];
     external: string[];
     externalExplicit?: boolean;
+    externalParticipants?: ExternalParticipantService[];
     kind: "team";
     lead: string | null;
     members: ResolvedMemberRef[];
@@ -184,6 +254,7 @@ export interface ResolvedTeamNode {
         skills: ResolvedSkill[];
         packages?: ResolvedPackage[];
     };
+    memory?: ResolvedMemoryBank[];
     source: string;
 }
 export interface CompilePlanEdge {
@@ -224,6 +295,7 @@ export interface ResolvedMoltnetRoomMembership {
 }
 export interface CompilePlan {
     edges: CompilePlanEdge[];
+    memoryAccess?: ResolvedMemoryAccess[];
     memberships?: ResolvedTeamMembershipContext[];
     moltnetRoomMemberships?: ResolvedMoltnetRoomMembership[];
     nodes: CompilePlanNode[];
@@ -231,4 +303,13 @@ export interface CompilePlan {
     runtimes: Record<string, {
         nodeIds: string[];
     }>;
+    organizationIdentity?: ResolvedOrganizationIdentity;
+    moltnetExternalParticipantIntents?: MoltnetExternalParticipantIntent[];
+}
+export interface MoltnetExternalParticipantIntent {
+    participant: ResolvedExternalParticipant;
+    networkId: string;
+    tokenId: string;
+    tokenEnv: string;
+    directMessagePeers: string[];
 }