@akira-tl/forgerelay 0.6.1 → 0.7.1

package/dist/cli.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module";
 import { stdin as input, stdout as output } from "node:process";
 import { spawn } from "node:child_process";
 import { mkdtempSync, writeFileSync } from "node:fs";
-import { readFile } from "node:fs/promises";
+import { readFile, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -11,13 +11,12 @@ import * as prompts from "@clack/prompts";
 import { getShellConfig } from "@earendil-works/pi-coding-agent";
 import { satisfies } from "semver";
 import { loadConfig } from "./config.js";
-import { formatVisibleHookReports, HookRunner } from "./hooks.js";
 import { runHooksCommand } from "./hook-cli.js";
-import { runLocalAgentProvider } from "./local-agent-adapters.js";
-import { isLocalAgentProvider, loadLocalAgentProfiles, } from "./local-agent-profiles.js";
-import { assertLocalAgentProviderAvailable, formatLocalAgentProviderAvailabilitySummary, } from "./local-agent-availability.js";
-import { formatAvailableLocalAgentTargets, parseLocalAgentRunArgs, resolveLocalAgentTarget, } from "./local-agent-targets.js";
-import { createLocalAgentStore } from "./local-agent-store.js";
+import { executeSubagentSession } from "./subagents/sessions/execution.js";
+import { SubagentDeliveryMailbox } from "./subagents/sessions/delivery-mailbox.js";
+import { SubagentSessionManager } from "./subagents/sessions/manager.js";
+import { formatSubagentProviderAvailabilitySummary } from "./subagents/providers/availability.js";
+import { parseSubagentRunArgs } from "./subagents/cli-target.js";
 import { ensureForgeRelayInstanceId, generateInstanceId, generateOwnerToken, loadDevspaceFiles, removeForgeRelayRemote, renameForgeRelayRemote, resolveSubagentsFlag, writeDevspaceAuth, writeDevspaceConfig, writeForgeRelayRemote, } from "./user-config.js";
 import { expandHomePath } from "./roots.js";
 import { shutdownHttpServer } from "./server-shutdown.js";
@@ -193,7 +192,7 @@ async function serve() {
     }
     const { createServer } = await import("./server.js");
     const config = loadConfig();
-    const { app, close, localAgentProviders } = createServer(config);
+    const { app, close, subagentProviders } = createServer(config);
     const httpServer = app.listen(config.port, config.host, () => {
         console.log(`forgerelay listening on http://${config.host}:${config.port}/mcp`);
         console.log(`public base url: ${config.publicBaseUrl}`);
@@ -205,7 +204,7 @@ async function serve() {
         console.log("auth: Owner password approval required");
         console.log(`logging: ${config.logging.level} ${config.logging.format}`);
         if (config.subagents) {
-            console.log(`subagent providers: ${formatLocalAgentProviderAvailabilitySummary(localAgentProviders)}`);
+            console.log(`subagent providers: ${formatSubagentProviderAvailabilitySummary(subagentProviders)}`);
         }
     });
     let shuttingDown = false;
@@ -492,92 +491,79 @@ async function runAgentsCommand(args) {
     }
 }
 async function runAgentsList() {
-    const config = loadConfig();
-    const store = createLocalAgentStore(config);
-    const agents = store.list(resolveCurrentWorkspaceScope());
-    if (agents.length === 0) {
-        console.log("No subagent sessions found for this workspace.");
-        return;
+    const manager = createCliSubagentSessionManager();
+    try {
+        const agents = manager.list(resolveCurrentWorkspaceScope());
+        if (agents.length === 0) {
+            console.log("No subagent sessions found for this workspace.");
+            return;
+        }
+        for (const agent of agents) {
+            console.log(formatAgentLine(agent));
+        }
     }
-    for (const agent of agents) {
-        console.log(formatAgentLine(agent));
+    finally {
+        manager.close();
     }
 }
 async function runAgentsRun(args) {
-    const parsed = parseLocalAgentRunArgs(args);
-    const config = loadConfig();
+    const parsed = parseSubagentRunArgs(args);
     const workspaceRoot = resolveCurrentWorkspaceRoot();
-    const store = createLocalAgentStore(config);
-    const existing = store.get(parsed.target);
-    if (existing) {
-        if (!isLocalAgentProvider(existing.provider)) {
-            throw new Error(`Unknown subagent provider for existing session: ${existing.provider}`);
-        }
-        assertLocalAgentProviderAvailable(existing.provider);
-        const promptFile = writeAgentPromptFile(parsed.prompt);
-        store.update(existing.id, {
-            status: "starting",
-            model: parsed.model ?? existing.model,
-            thinking: parsed.thinking ?? existing.thinking,
-            latestResponse: undefined,
-            error: undefined,
-            hookReports: undefined,
-        });
-        spawnAgentWorker(existing.id, promptFile);
-        console.log(formatAgentLine({
-            ...existing,
-            status: "running",
-            model: parsed.model ?? existing.model,
-            thinking: parsed.thinking ?? existing.thinking,
-        }));
-        return;
-    }
-    const profiles = await loadLocalAgentProfiles(config, workspaceRoot);
-    const target = resolveLocalAgentTarget(parsed.target, profiles, parsed.model, parsed.thinking);
-    if (!target) {
-        throw new Error(`Unknown subagent profile, provider, or id: ${parsed.target}. Available ${formatAvailableLocalAgentTargets(profiles)}`);
+    const manager = createCliSubagentSessionManager();
+    try {
+        const existing = manager.get(parsed.target);
+        if (existing && (parsed.model || parsed.thinking))
+            throw new Error("Existing Subagent Sessions cannot override model or thinking.");
+        const started = existing
+            ? manager.resume({ sessionId: existing.id, prompt: parsed.prompt })
+            : await manager.start({
+                workspaceId: process.env.FORGERELAY_WORKSPACE_ID ?? process.env.DEVSPACE_WORKSPACE_ID,
+                workspaceRoot,
+                target: parsed.target,
+                prompt: parsed.prompt,
+                model: parsed.model,
+                thinking: parsed.thinking,
+            });
+        console.log(formatAgentLine(started.session));
+    }
+    finally {
+        manager.close();
     }
-    assertLocalAgentProviderAvailable(target.provider);
-    const promptFile = writeAgentPromptFile(parsed.prompt);
-    const record = store.create({
-        workspaceId: process.env.FORGERELAY_WORKSPACE_ID ?? process.env.DEVSPACE_WORKSPACE_ID,
-        workspaceRoot,
-        profileName: target.name,
-        provider: target.provider,
-        model: target.model,
-        thinking: target.thinking,
-    });
-    spawnAgentWorker(record.id, promptFile);
-    console.log(formatAgentLine({ ...record, status: "running" }));
 }
 async function runAgentsShow(args) {
     const [id] = args;
     if (!id)
         throw new Error("Usage: forgerelay agents show <id>");
     const config = loadConfig();
-    const store = createLocalAgentStore(config);
-    let record = store.get(id);
-    if (!record)
-        throw new Error(`Unknown subagent id: ${id}`);
-    const deadline = Date.now() + 15_000;
-    while ((record.status === "starting" || record.status === "running") && Date.now() < deadline) {
-        await sleep(500);
-        record = store.get(id) ?? record;
-    }
-    console.log(formatAgentLine(record));
-    const hookSummary = formatVisibleHookReports(record.hookReports ?? []);
-    if (hookSummary)
-        console.log(hookSummary);
-    if (record.latestResponse) {
-        console.log(record.latestResponse);
-        return;
-    }
-    if (record.error) {
-        console.log(record.error);
-        return;
+    const manager = createCliSubagentSessionManager(config);
+    try {
+        let record = manager.get(id);
+        if (!record)
+            throw new Error(`Unknown subagent id: ${id}`);
+        const deadline = Date.now() + 15_000;
+        while (record.status === "running" && Date.now() < deadline) {
+            await sleep(500);
+            record = manager.get(id) ?? record;
+        }
+        console.log(formatAgentLine(record));
+        if (record.workspaceId) {
+            const deliveries = new SubagentDeliveryMailbox(config.stateDir).claimSession(record.workspaceId, record.id);
+            for (const delivery of deliveries) {
+                const text = delivery.outcome === "succeeded" ? delivery.finalResponse : delivery.error;
+                if (text)
+                    console.log(text);
+            }
+            if (deliveries.length > 0)
+                return;
+        }
+        if (record.latestRun)
+            console.log(`Latest run ${record.latestRun.id}: ${record.latestRun.status}`);
+        if (record.status === "running") {
+            console.log(`No final response yet. Call \`forgerelay agents show ${record.id}\` again later.`);
+        }
     }
-    if (record.status === "starting" || record.status === "running") {
-        console.log(`No final response yet. Call \`forgerelay agents show ${record.id}\` again later.`);
+    finally {
+        manager.close();
     }
 }
 async function runAgentsWorker(args) {
@@ -586,96 +572,25 @@ async function runAgentsWorker(args) {
         throw new Error("Usage: forgerelay agents __worker <id> --prompt-file <path>");
     }
     const config = loadConfig();
-    const store = createLocalAgentStore(config);
-    const record = store.get(id);
-    if (!record)
-        throw new Error(`Unknown subagent id: ${id}`);
-    const hooks = new HookRunner(config.hooks, config.logging);
-    const hookInvocation = {
-        workspaceId: record.workspaceId,
-        workspaceRoot: record.workspaceRoot,
-        payload: {
-            agentId: record.id,
-            profile: record.profileName,
-            provider: record.provider,
-            model: record.model,
-            thinking: record.thinking,
+    const prompt = await readFile(promptFile, "utf8");
+    await rm(promptFile, { force: true });
+    await executeSubagentSession(config, id, prompt);
+}
+function createCliSubagentSessionManager(config = loadConfig()) {
+    return new SubagentSessionManager(config, {
+        launch(request) {
+            const promptFile = writeSubagentPromptFile(request.prompt);
+            spawnSubagentWorker(request.sessionId, promptFile);
         },
-    };
-    store.update(record.id, { status: "running", error: undefined, hookReports: undefined });
-    const hookReports = await hooks.run("SubagentStart", hookInvocation);
-    store.update(record.id, { hookReports });
-    try {
-        const profiles = await loadLocalAgentProfiles(config, record.workspaceRoot);
-        const profile = profiles.find((candidate) => candidate.name === record.profileName);
-        const prompt = await readFile(promptFile, "utf8");
-        const result = profile
-            ? await runLocalAgentProfile(profile, record, prompt)
-            : await runRawLocalAgentProvider(record, prompt);
-        hookReports.push(...await hooks.run("SubagentStop", {
-            ...hookInvocation,
-            payload: {
-                ...hookInvocation.payload,
-                status: "idle",
-                providerSessionId: result.providerSessionId,
-            },
-        }));
-        store.update(record.id, {
-            providerSessionId: result.providerSessionId ?? undefined,
-            status: "idle",
-            latestResponse: result.finalResponse,
-            error: undefined,
-            hookReports,
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        hookReports.push(...await hooks.run("SubagentStop", {
-            ...hookInvocation,
-            payload: {
-                ...hookInvocation.payload,
-                status: "error",
-            },
-        }));
-        store.update(record.id, {
-            status: "error",
-            error: message,
-            hookReports,
-        });
-    }
-}
-async function runLocalAgentProfile(profile, record, prompt) {
-    const body = profile.body.trim();
-    const fullPrompt = body ? `${body}\n\nTask:\n${prompt}` : prompt;
-    return runLocalAgentProvider(profile.provider, {
-        prompt: fullPrompt,
-        workspace: record.workspaceRoot,
-        providerSessionId: record.providerSessionId,
-        writeMode: "allowed",
-        model: record.model ?? profile.model,
-        thinking: record.thinking ?? profile.thinking,
-    });
-}
-async function runRawLocalAgentProvider(record, prompt) {
-    if (record.profileName !== record.provider || !isLocalAgentProvider(record.provider)) {
-        throw new Error(`Subagent profile not found: ${record.profileName}`);
-    }
-    return runLocalAgentProvider(record.provider, {
-        prompt,
-        workspace: record.workspaceRoot,
-        providerSessionId: record.providerSessionId,
-        writeMode: "allowed",
-        model: record.model,
-        thinking: record.thinking,
     });
 }
-function spawnAgentWorker(agentId, promptFile) {
+function spawnSubagentWorker(sessionId, promptFile) {
     const child = spawn(process.execPath, [
         ...process.execArgv,
         fileURLToPath(import.meta.url),
         "agents",
         "__worker",
-        agentId,
+        sessionId,
         "--prompt-file",
         promptFile,
     ], {
@@ -685,7 +600,7 @@ function spawnAgentWorker(agentId, promptFile) {
     });
     child.unref();
 }
-function writeAgentPromptFile(prompt) {
+function writeSubagentPromptFile(prompt) {
     const directory = mkdtempSync(join(tmpdir(), "forgerelay-agent-prompt-"));
     const filePath = join(directory, "prompt.txt");
     writeFileSync(filePath, prompt, { mode: 0o600 });

package/dist/composite-activity.js

@@ -0,0 +1,155 @@
+export class CompositeActivityCoordinator {
+    composites;
+    queries;
+    remoteWorkspaces;
+    turns = new Map();
+    constructor(composites, queries, remoteWorkspaces) {
+        this.composites = composites;
+        this.queries = queries;
+        this.remoteWorkspaces = remoteWorkspaces;
+    }
+    hasComposite(workspaceId) {
+        return this.composites.has(workspaceId);
+    }
+    beginPanel(workspaceId, conversationScopeId) {
+        this.composites.open(workspaceId);
+        const snapshot = this.queries.beginTurn(conversationScopeId, workspaceId);
+        this.turns.set(snapshot.turnId, {
+            compositeWorkspaceId: workspaceId,
+            conversationScopeId,
+            remoteMembers: new Map(),
+            remoteActivities: new Map(),
+            remoteOutputs: new Map(),
+        });
+        return snapshotResult(snapshot, `Started Composite Workspace Host Turn ${snapshot.turnId}.`);
+    }
+    currentTurnId(conversationScopeId, compositeWorkspaceId) {
+        const turnId = this.queries.currentTurnId(conversationScopeId, compositeWorkspaceId);
+        return turnId && this.turns.has(turnId) ? turnId : undefined;
+    }
+    async prepareMember(compositeWorkspaceId, member, executionWorkspaceId, conversationScopeId) {
+        const turnId = this.currentTurnId(conversationScopeId, compositeWorkspaceId);
+        if (!turnId)
+            return undefined;
+        if (!this.remoteWorkspaces.has(executionWorkspaceId))
+            return turnId;
+        const state = this.turns.get(turnId);
+        const existing = state.remoteMembers.get(member);
+        if (existing?.workspaceId === executionWorkspaceId)
+            return turnId;
+        const panel = await this.remoteWorkspaces.activityPanel(executionWorkspaceId, conversationScopeId);
+        const remoteTurnId = requiredString(panel.structuredContent, "turnId", "Remote Activity panel");
+        state.remoteMembers.set(member, {
+            member,
+            workspaceId: executionWorkspaceId,
+            remoteTurnId,
+        });
+        return turnId;
+    }
+    async snapshot(turnId, knownRevision) {
+        const state = this.turns.get(turnId);
+        if (!state)
+            return undefined;
+        const local = this.queries.snapshot(turnId);
+        const remoteSnapshots = await Promise.all([...state.remoteMembers.values()].map(async (route) => ({
+            route,
+            snapshot: await this.remoteWorkspaces.activitySnapshot({ turnId: route.remoteTurnId }, state.conversationScopeId),
+        })));
+        state.remoteActivities.clear();
+        state.remoteOutputs.clear();
+        const remoteActivities = [];
+        let revision = local.revision;
+        for (const { route, snapshot } of remoteSnapshots) {
+            if (!snapshot?.structuredContent)
+                continue;
+            const structured = snapshot.structuredContent;
+            const remoteRevision = structured.revision;
+            if (typeof remoteRevision === "number" && Number.isInteger(remoteRevision) && remoteRevision >= 0) {
+                revision += remoteRevision;
+            }
+            const activities = Array.isArray(structured.activities)
+                ? structured.activities
+                : [];
+            for (const activity of activities) {
+                const presented = { ...activity, member: route.member };
+                remoteActivities.push(presented);
+                state.remoteActivities.set(activity.activityId, route);
+                if (activity.outputId)
+                    state.remoteOutputs.set(activity.outputId, route);
+            }
+        }
+        const activities = [...local.activities, ...remoteActivities]
+            .sort((left, right) => left.startedAt.localeCompare(right.startedAt));
+        const changed = knownRevision === undefined || knownRevision !== revision;
+        const snapshot = {
+            turnId,
+            revision,
+            changed,
+            state: aggregateState(activities),
+            activities: changed ? activities : [],
+        };
+        return snapshotResult(snapshot, changed
+            ? `Composite Activity snapshot ${turnId} revision ${revision}.`
+            : `Composite Activity snapshot ${turnId} unchanged at revision ${revision}.`);
+    }
+    async detail(turnId, activityId) {
+        const state = this.turns.get(turnId);
+        if (!state)
+            return undefined;
+        const route = state.remoteActivities.get(activityId);
+        if (!route)
+            return undefined;
+        const result = await this.remoteWorkspaces.activityDetail(route.remoteTurnId, activityId, state.conversationScopeId);
+        if (!result?.structuredContent)
+            return result;
+        const structured = result.structuredContent;
+        const activity = structured.activity;
+        return {
+            ...result,
+            structuredContent: {
+                ...structured,
+                ...(activity && typeof activity === "object"
+                    ? { activity: { ...activity, member: route.member } }
+                    : {}),
+            },
+        };
+    }
+    async output(turnId, outputId) {
+        const state = this.turns.get(turnId);
+        if (!state)
+            return undefined;
+        const route = state.remoteOutputs.get(outputId);
+        if (!route)
+            return undefined;
+        return this.remoteWorkspaces.activityOutput(route.remoteTurnId, outputId, state.conversationScopeId);
+    }
+    forgetComposite(workspaceId) {
+        for (const [turnId, state] of this.turns) {
+            if (state.compositeWorkspaceId === workspaceId)
+                this.turns.delete(turnId);
+        }
+    }
+}
+function snapshotResult(snapshot, text) {
+    return {
+        content: [{ type: "text", text }],
+        structuredContent: snapshot,
+    };
+}
+function aggregateState(activities) {
+    if (activities.length === 0)
+        return "working";
+    if (activities.some((activity) => activity.status === "working"))
+        return "working";
+    if (activities.some((activity) => activity.status === "error"))
+        return "error";
+    return "done";
+}
+function requiredString(value, field, label) {
+    if (!value || typeof value !== "object")
+        throw new Error(`${label} did not return structured content.`);
+    const fieldValue = value[field];
+    if (typeof fieldValue !== "string" || !fieldValue)
+        throw new Error(`${label} did not include ${field}.`);
+    return fieldValue;
+}

package/dist/composite-workspaces.js

@@ -0,0 +1,197 @@
+import { randomBytes } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export class CompositeWorkspaceRegistry {
+    stateDir;
+    statePath;
+    records = new Map();
+    constructor(stateDir) {
+        this.stateDir = stateDir;
+        this.statePath = join(stateDir, "composite-workspaces.json");
+        this.load();
+    }
+    has(workspaceId) {
+        return this.records.has(workspaceId);
+    }
+    create(name) {
+        const normalized = normalizeName(name);
+        const existing = [...this.records.values()].find((record) => record.name === normalized);
+        if (existing)
+            return this.touch(existing.id);
+        const now = new Date().toISOString();
+        const record = {
+            id: `cws_${randomBytes(5).toString("hex")}`,
+            kind: "composite",
+            name: normalized,
+            members: [],
+            createdAt: now,
+            lastUsedAt: now,
+        };
+        this.records.set(record.id, record);
+        this.persist();
+        return cloneRecord(record);
+    }
+    get(workspaceId) {
+        const record = this.records.get(workspaceId);
+        if (!record)
+            throw new Error(`Unknown Composite Workspace ${workspaceId}.`);
+        return cloneRecord(record);
+    }
+    open(workspaceId) {
+        return this.touch(workspaceId);
+    }
+    list() {
+        return [...this.records.values()]
+            .map(cloneRecord)
+            .sort((left, right) => right.lastUsedAt.localeCompare(left.lastUsedAt));
+    }
+    addMember(workspaceId, input) {
+        const record = this.requireRecord(workspaceId);
+        const name = normalizeMemberName(input.name);
+        const purpose = input.purpose.trim();
+        if (!purpose)
+            throw new Error("Composite Workspace member purpose must not be empty.");
+        const existing = record.members.find((member) => member.name === name);
+        if (existing) {
+            if (existing.purpose === purpose && existing.workspaceId === input.workspaceId) {
+                return cloneRecord(record);
+            }
+            throw new Error(`Composite Workspace ${workspaceId} already has member ${name} with a different definition.`);
+        }
+        record.members.push({ name, purpose, workspaceId: input.workspaceId });
+        record.lastUsedAt = new Date().toISOString();
+        this.persist();
+        return cloneRecord(record);
+    }
+    updateMember(workspaceId, memberName, input) {
+        const record = this.requireRecord(workspaceId);
+        const currentName = normalizeMemberName(memberName);
+        const index = record.members.findIndex((member) => member.name === currentName);
+        if (index < 0)
+            throw new Error(`Composite Workspace ${workspaceId} has no member ${currentName}.`);
+        const current = record.members[index];
+        const nextName = input.name === undefined ? current.name : normalizeMemberName(input.name);
+        const nextPurpose = input.purpose === undefined ? current.purpose : input.purpose.trim();
+        if (!nextPurpose)
+            throw new Error("Composite Workspace member purpose must not be empty.");
+        const nextWorkspaceId = input.workspaceId ?? current.workspaceId;
+        if (nextName !== current.name &&
+            record.members.some((member, memberIndex) => memberIndex !== index && member.name === nextName)) {
+            throw new Error(`Composite Workspace ${workspaceId} already has member ${nextName}.`);
+        }
+        if (nextName === current.name &&
+            nextPurpose === current.purpose &&
+            nextWorkspaceId === current.workspaceId) {
+            return cloneRecord(record);
+        }
+        record.members[index] = {
+            name: nextName,
+            purpose: nextPurpose,
+            workspaceId: nextWorkspaceId,
+        };
+        record.lastUsedAt = new Date().toISOString();
+        this.persist();
+        return cloneRecord(record);
+    }
+    removeMember(workspaceId, memberName) {
+        const record = this.requireRecord(workspaceId);
+        const name = normalizeMemberName(memberName);
+        const index = record.members.findIndex((member) => member.name === name);
+        if (index < 0)
+            throw new Error(`Composite Workspace ${workspaceId} has no member ${name}.`);
+        record.members.splice(index, 1);
+        record.lastUsedAt = new Date().toISOString();
+        this.persist();
+        return cloneRecord(record);
+    }
+    member(workspaceId, memberName) {
+        const record = this.requireRecord(workspaceId);
+        const name = normalizeMemberName(memberName);
+        const member = record.members.find((entry) => entry.name === name);
+        if (!member)
+            throw new Error(`Composite Workspace ${workspaceId} has no member ${name}.`);
+        return { ...member };
+    }
+    dissolve(workspaceId) {
+        const record = this.requireRecord(workspaceId);
+        this.records.delete(workspaceId);
+        this.persist();
+        return cloneRecord(record);
+    }
+    touch(workspaceId) {
+        const record = this.requireRecord(workspaceId);
+        record.lastUsedAt = new Date().toISOString();
+        this.persist();
+        return cloneRecord(record);
+    }
+    requireRecord(workspaceId) {
+        const record = this.records.get(workspaceId);
+        if (!record)
+            throw new Error(`Unknown Composite Workspace ${workspaceId}.`);
+        return record;
+    }
+    load() {
+        let parsed;
+        try {
+            parsed = JSON.parse(readFileSync(this.statePath, "utf8"));
+        }
+        catch (error) {
+            if (isMissingFile(error))
+                return;
+            throw new Error(`Failed to load Composite Workspace state: ${errorMessage(error)}`);
+        }
+        if (parsed?.version !== 1 || !Array.isArray(parsed.workspaces)) {
+            throw new Error("Composite Workspace state has an unsupported format.");
+        }
+        for (const record of parsed.workspaces) {
+            if (!record?.id?.startsWith("cws_") || record.kind !== "composite")
+                continue;
+            this.records.set(record.id, {
+                ...record,
+                members: Array.isArray(record.members) ? record.members.map((member) => ({ ...member })) : [],
+            });
+        }
+    }
+    persist() {
+        mkdirSync(this.stateDir, { recursive: true });
+        const state = {
+            version: 1,
+            workspaces: [...this.records.values()].map(cloneRecord),
+        };
+        const tempPath = `${this.statePath}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+        try {
+            writeFileSync(tempPath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+            renameSync(tempPath, this.statePath);
+        }
+        finally {
+            rmSync(tempPath, { force: true });
+        }
+    }
+}
+function normalizeName(name) {
+    const value = name.trim();
+    if (!value)
+        throw new Error("Composite Workspace name must not be empty.");
+    if (value.length > 120)
+        throw new Error("Composite Workspace name must be at most 120 characters.");
+    return value;
+}
+function normalizeMemberName(name) {
+    const value = name.trim();
+    if (!/^[a-z][a-z0-9_-]{0,31}$/.test(value)) {
+        throw new Error("Composite Workspace member name must match /^[a-z][a-z0-9_-]{0,31}$/.");
+    }
+    return value;
+}
+function cloneRecord(record) {
+    return {
+        ...record,
+        members: record.members.map((member) => ({ ...member })),
+    };
+}
+function isMissingFile(error) {
+    return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}