@cydm/happy-elves 0.1.0-beta.31 → 0.1.0-beta.310

package/apps/cli/dist/commands/lib/workspace.js

@@ -2,7 +2,7 @@ import { CliError } from "../../errors.js";
 import { showMachine } from "./session-view.js";
 export async function listWorkspaceHistoricalSessions(client, input) {
     const snapshot = await client.snapshot();
-    const providerLimit = Math.min(200, Math.max(input.limit, 50));
+    const providerPageSize = Math.min(200, Math.max(Math.min(input.limit, 200), 50));
     const selectedMachines = snapshot.machines.filter((machine) => {
         if (input.machineId)
             return machine.id === input.machineId;
@@ -17,13 +17,26 @@ export async function listWorkspaceHistoricalSessions(client, input) {
     const rows = await Promise.all(machines.map(async ({ machine, projected }) => {
         const machineName = projected.metadata.name ?? projected.metadata.hostname ?? machine.name;
         try {
-            const sessions = await client.listHistoricalSessions({
-                machineId: machine.id,
-                cwd: input.cwd,
-                agent: input.agent,
-                includeArchived: input.includeArchived,
-                limit: providerLimit,
-            });
+            const sessions = [];
+            let cursor;
+            const seenCursors = new Set();
+            while (sessions.length < input.limit) {
+                const page = await client.listHistoricalSessionsPage({
+                    machineId: machine.id,
+                    cwd: input.cwd,
+                    agent: input.agent,
+                    includeArchived: input.includeArchived,
+                    limit: providerPageSize,
+                    cursor,
+                });
+                sessions.push(...page.sessions);
+                if (!page.hasMore || !page.nextCursor)
+                    break;
+                if (seenCursors.has(page.nextCursor))
+                    break;
+                seenCursors.add(page.nextCursor);
+                cursor = page.nextCursor;
+            }
             return {
                 sessions: sessions
                     .filter((session) => input.includeArchived === true || session.runtimeState !== "archived")
@@ -47,12 +60,52 @@ export async function listWorkspaceHistoricalSessions(client, input) {
         }
     }));
     return {
-        sessions: rows
+        sessions: await enrichHistoricalLoadedSessionIds(client, rows
             .flatMap((row) => row.sessions)
             .sort((left, right) => right.updatedAt - left.updatedAt || left.runtimeSessionId.localeCompare(right.runtimeSessionId))
-            .slice(0, input.limit),
+            .slice(0, input.limit)),
         errors: rows.flatMap((row) => row.error ? [row.error] : []),
         machines: rows.map((row) => row.machine),
     };
 }
+async function enrichHistoricalLoadedSessionIds(client, sessions) {
+    const snapshot = await client.snapshot();
+    const runtimeIdToSession = new Map();
+    for (const session of snapshot.sessions) {
+        if (session.status === "closed")
+            continue;
+        const metadata = await client.decodeSessionMetadata(session);
+        for (const runtimeSessionId of metadataRuntimeSessionIds(metadata)) {
+            const key = `${session.machineId}:${session.agent}:${runtimeSessionId}`;
+            const existing = runtimeIdToSession.get(key);
+            if (!existing || session.createdAt < existing.createdAt || (session.createdAt === existing.createdAt && session.id < existing.id)) {
+                runtimeIdToSession.set(key, session);
+            }
+        }
+    }
+    return sessions.map((historical) => {
+        const loaded = runtimeIdToSession.get(`${historical.machineId}:${historical.agent}:${historical.runtimeSessionId}`);
+        return loaded ? { ...historical, loadedSessionId: loaded.id } : historical;
+    });
+}
+function metadataRuntimeSessionIds(metadata) {
+    const ids = new Set();
+    addRuntimeSessionId(ids, metadata.importedFromRuntimeSessionId);
+    const runtime = metadata.runtime;
+    if (runtime && typeof runtime === "object" && !Array.isArray(runtime)) {
+        const record = runtime;
+        addRuntimeSessionId(ids, record.backendSessionId);
+        addRuntimeSessionId(ids, record.agentSessionId);
+        addRuntimeSessionId(ids, record.acpxRecordId);
+        const externalHandle = record.externalHandle;
+        if (externalHandle && typeof externalHandle === "object" && !Array.isArray(externalHandle)) {
+            addRuntimeSessionId(ids, externalHandle.sessionId);
+        }
+    }
+    return ids;
+}
+function addRuntimeSessionId(ids, value) {
+    if (typeof value === "string" && value.trim())
+        ids.add(value.trim());
+}
 //# sourceMappingURL=workspace.js.map

package/apps/cli/dist/commands/machine.js

@@ -1,14 +1,50 @@
 import fs from "node:fs";
 import { CliError, ControllerClient, compactText, machineSessionOverview, ok, readConfig, requirePositional, showMachine, wantsJson, wantsVerbose } from "./lib/index.js";
+function machineDisplayName(machine) {
+    return machine.metadata.name ?? machine.name;
+}
+function duplicateNameKey(value) {
+    return value.trim().toLocaleLowerCase();
+}
+function annotateStaleDuplicateMachines(machines) {
+    const byName = new Map();
+    for (const machine of machines) {
+        const displayName = machineDisplayName(machine);
+        const key = duplicateNameKey(displayName);
+        if (!key)
+            continue;
+        const group = byName.get(key) ?? { displayName, machines: [] };
+        group.machines.push(machine);
+        byName.set(key, group);
+    }
+    return machines.map((machine) => {
+        if (machine.online)
+            return machine;
+        const displayName = machineDisplayName(machine);
+        const group = byName.get(duplicateNameKey(displayName));
+        const onlinePeerIds = group?.machines.filter((peer) => peer.online && peer.id !== machine.id).map((peer) => peer.id) ?? [];
+        if (onlinePeerIds.length === 0)
+            return machine;
+        return {
+            ...machine,
+            staleDuplicate: {
+                reason: "offline-same-name",
+                displayName,
+                onlinePeerIds,
+            },
+        };
+    });
+}
 function structuredMachineSummary(machine) {
     const summary = machine.summary;
     return {
         machineId: machine.id,
-        name: machine.metadata.name ?? machine.name,
+        name: machineDisplayName(machine),
         online: machine.online,
         sessionCount: summary.sessionCount,
         runningCount: summary.runningSessionCount,
         blockedCount: summary.blockedSessionCount,
+        ...(machine.staleDuplicate ? { staleDuplicate: machine.staleDuplicate } : {}),
     };
 }
 function structuredMachineVerbose(machine) {
@@ -16,26 +52,30 @@ function structuredMachineVerbose(machine) {
         machineId: machine.id,
         online: machine.online,
         lastSeen: machine.lastSeen,
-        name: machine.metadata.name ?? machine.name,
+        name: machineDisplayName(machine),
         defaultCwd: machine.defaultCwd,
         capabilities: machine.capabilities,
         metadata: machine.metadata,
         summary: machine.summary,
         sessions: machine.sessions,
         encryptedMetadata: machine.encryptedMetadata,
+        ...(machine.staleDuplicate ? { staleDuplicate: machine.staleDuplicate } : {}),
     };
 }
 function printMachineLine(machine) {
-    const name = machine.metadata.name ?? machine.name;
+    const name = machineDisplayName(machine);
     const summary = machine.summary;
-    console.log(`${machine.id}  ${machine.online ? "online" : "offline"}  ${compactText(name, 32)}  sessions:${summary.sessionCount} running:${summary.runningSessionCount} blocked:${summary.blockedSessionCount}`);
+    const duplicate = machine.staleDuplicate ? ` stale-duplicate-of:${machine.staleDuplicate.onlinePeerIds.join(",")}` : "";
+    console.log(`${machine.id}  ${machine.online ? "online" : "offline"}  ${compactText(name, 32)}  sessions:${summary.sessionCount} running:${summary.runningSessionCount} blocked:${summary.blockedSessionCount}${duplicate}`);
 }
 function printMachineDetails(machine) {
-    const name = machine.metadata.name ?? machine.name;
+    const name = machineDisplayName(machine);
     const agents = machine.capabilities.agents.map((agent) => agent.id).join(", ") || "-";
     const summary = machine.summary;
     console.log(`${name} (${machine.id})`);
     console.log(`  status: ${machine.online ? "online" : "offline"}  agents: ${agents}`);
+    if (machine.staleDuplicate)
+        console.log(`  stale duplicate: offline machine with online peer ${machine.staleDuplicate.onlinePeerIds.join(", ")}`);
     console.log(`  cwd: ${machine.defaultCwd ?? "-"}`);
     console.log(`  sessions: ${summary.sessionCount} total, ${summary.runningSessionCount} running, ${summary.readySessionCount} ready, ${summary.needsUserSessionCount} needs user`);
     console.log(`  sessions: happy-elves session list --machine ${machine.id} --limit 20`);
@@ -176,19 +216,20 @@ export async function handleMachine({ domain, action, positional, flags }) {
             ...(await showMachine(client, machine)),
             ...(await machineSessionOverview(client, snapshot.sessions, machine.id)),
         })));
+        const annotatedMachines = annotateStaleDuplicateMachines(machines);
         if (!wantsJson(flags)) {
-            if (machines.length === 0) {
+            if (annotatedMachines.length === 0) {
                 console.log("No machines.");
                 return true;
             }
-            for (const machine of machines) {
+            for (const machine of annotatedMachines) {
                 printMachineLine(machine);
             }
             return true;
         }
         ok("machine.list", {
-            machines: machines.map((machine) => (wantsVerbose(flags) ? structuredMachineVerbose(machine) : structuredMachineSummary(machine))),
-            page: { returned: machines.length },
+            machines: annotatedMachines.map((machine) => (wantsVerbose(flags) ? structuredMachineVerbose(machine) : structuredMachineSummary(machine))),
+            page: { returned: annotatedMachines.length },
         });
         return true;
     }

package/apps/cli/dist/commands/memory.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleMemory({ domain, action, positional, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/memory.js

@@ -0,0 +1,179 @@
+import { CliError, ControllerClient, ok, readConfig, readPromptTextFile, requirePositional, requireString, wantsJson, wantsVerbose } from "./lib/index.js";
+export async function handleMemory({ domain, action, positional, flags }) {
+    if (domain !== "memory")
+        return false;
+    const config = await readConfig(flags);
+    const client = new ControllerClient(config);
+    if (action === "overview" || action === "status" || action === "list") {
+        const machineId = await resolveMemoryMachineId(client, flags);
+        const projectKey = await resolveMemoryProjectKey(client, flags, machineId);
+        const result = await client.memory({ machineId, action: "overview", projectKey, mode: parseMemoryMode(flags.mode) ?? "readonly" });
+        if (!wantsJson(flags)) {
+            const files = result.overview?.files ?? [];
+            if (files.length === 0)
+                console.log("No memory files.");
+            else
+                for (const file of files)
+                    console.log(`${file.layer}  ${file.path}  ${file.lineCount} lines  ${file.updatedAt}`);
+            return true;
+        }
+        ok(`memory.${action}`, result);
+        return true;
+    }
+    if (action === "save" || action === "write") {
+        const machineId = await resolveMemoryMachineId(client, flags);
+        const projectKey = await resolveMemoryProjectKey(client, flags, machineId);
+        const text = typeof flags.text === "string"
+            ? flags.text
+            : typeof flags["text-file"] === "string"
+                ? await readPromptTextFile(flags["text-file"])
+                : "";
+        if (!text.trim())
+            throw new CliError("Missing --text or --text-file", "MISSING_ARGUMENT");
+        const layer = parseMemoryLayer(flags.layer) ?? "curated";
+        const result = await client.memory({
+            machineId,
+            action: "write",
+            projectKey,
+            write: {
+                projectKey,
+                layer,
+                text,
+                ...(typeof flags.title === "string" ? { title: flags.title } : {}),
+                ...(typeof flags.date === "string" ? { date: flags.date } : {}),
+            },
+        });
+        ok("memory.save", result);
+        return true;
+    }
+    if (action === "read") {
+        const machineId = await resolveMemoryMachineId(client, flags);
+        const projectKey = await resolveMemoryProjectKey(client, flags, machineId);
+        const path = typeof flags.path === "string" ? flags.path : requirePositional(positional[0], "path");
+        const result = await client.memory({ machineId, action: "read", projectKey, path });
+        if (!wantsJson(flags)) {
+            console.log(result.content ?? "");
+            return true;
+        }
+        ok("memory.read", result);
+        return true;
+    }
+    if (action === "search") {
+        const machineId = await resolveMemoryMachineId(client, flags);
+        const projectKey = await resolveMemoryProjectKey(client, flags, machineId);
+        const query = requireString(flags, "query");
+        const limit = typeof flags.limit === "string" ? Number(flags.limit) : 5;
+        if (!Number.isInteger(limit) || limit <= 0)
+            throw new CliError("Invalid --limit", "INVALID_ARGUMENT");
+        const result = await client.memory({ machineId, action: "search", projectKey, query, limit });
+        if (!wantsJson(flags)) {
+            const results = result.results ?? [];
+            if (results.length === 0)
+                console.log("No matching memory.");
+            else
+                for (const item of results) {
+                    const hash = item.citation.contentHash ? ` hash=${item.citation.contentHash.slice(0, 10)}` : "";
+                    const stale = item.citation.stale ? " stale" : "";
+                    console.log(`${item.path}:${item.citation.startLine}-${item.citation.endLine}${hash}${stale}  ${item.snippet}`);
+                    if (wantsVerbose(flags))
+                        console.log(`  score=${item.score}`);
+                }
+            return true;
+        }
+        ok("memory.search", result);
+        return true;
+    }
+    if (action === "promote") {
+        const machineId = await resolveMemoryMachineId(client, flags);
+        const projectKey = await resolveMemoryProjectKey(client, flags, machineId);
+        const source = typeof flags.source === "string" ? parseMemoryCitation(flags.source) : undefined;
+        if (!source)
+            throw new CliError("Missing --source <path:start-end>", "MISSING_ARGUMENT");
+        const targetLayer = parsePromotionLayer(flags.layer) ?? "curated";
+        const result = await client.memory({
+            machineId,
+            action: "promote",
+            projectKey,
+            promote: {
+                projectKey,
+                source,
+                targetLayer,
+                ...(typeof flags.title === "string" ? { title: flags.title } : {}),
+            },
+        });
+        ok("memory.promote", result);
+        return true;
+    }
+    if (action === "reindex" || action === "sync") {
+        const machineId = await resolveMemoryMachineId(client, flags);
+        const projectKey = await resolveMemoryProjectKey(client, flags, machineId);
+        ok(`memory.${action}`, await client.memory({ machineId, action, projectKey, mode: parseMemoryMode(flags.mode) ?? "readonly" }));
+        return true;
+    }
+    return false;
+}
+async function resolveMemoryMachineId(client, flags) {
+    if (typeof flags.machine === "string" && flags.machine.length > 0)
+        return flags.machine;
+    if (typeof flags.session === "string" && flags.session.length > 0) {
+        const session = await client.getSession(flags.session);
+        if (session)
+            return session.machineId;
+    }
+    const snapshot = await client.snapshot();
+    const machine = snapshot.machines.find((item) => item.online) ?? snapshot.machines[0];
+    if (!machine)
+        throw new CliError("No daemon machine is available; pass --machine <machineId>", "MACHINE_NOT_FOUND");
+    return machine.id;
+}
+async function resolveMemoryProjectKey(client, flags, machineId) {
+    if (typeof flags.project === "string" && flags.project.trim())
+        return flags.project.trim();
+    if (typeof flags.session === "string" && flags.session.trim()) {
+        const session = await client.getSession(flags.session.trim());
+        if (session)
+            return `${session.machineId}:${session.cwd}`;
+    }
+    const cwd = typeof flags.cwd === "string" && flags.cwd.trim() ? flags.cwd.trim() : process.cwd();
+    return `${machineId}:${cwd}`;
+}
+function parseMemoryLayer(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    if (value === "user" || value === "curated" || value === "daily")
+        return value;
+    throw new CliError("Invalid --layer; expected user|curated|daily", "INVALID_ARGUMENT");
+}
+function parseMemoryMode(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    const normalized = value.trim().toLowerCase().replace(/-/g, "");
+    if (normalized === "off" || normalized === "readonly" || normalized === "readwrite")
+        return normalized;
+    throw new CliError("Invalid --mode; expected off|readonly|readwrite|read-only|read-write", "INVALID_ARGUMENT");
+}
+function parsePromotionLayer(value) {
+    const layer = parseMemoryLayer(value);
+    if (!layer)
+        return undefined;
+    if (layer === "user" || layer === "curated")
+        return layer;
+    throw new CliError("Invalid --layer for promotion; expected user|curated", "INVALID_ARGUMENT");
+}
+function parseMemoryCitation(value) {
+    const match = value.match(/^(.+):(\d+)-(\d+)(?:@([A-Za-z0-9._-]+))?$/);
+    if (!match)
+        throw new CliError("Invalid --source; expected path:start-end or path:start-end@contentHash", "INVALID_ARGUMENT");
+    const startLine = Number(match[2]);
+    const endLine = Number(match[3]);
+    if (!Number.isInteger(startLine) || !Number.isInteger(endLine) || startLine < 1 || endLine < startLine) {
+        throw new CliError("Invalid --source line range", "INVALID_ARGUMENT");
+    }
+    return {
+        path: match[1],
+        startLine,
+        endLine,
+        ...(match[4] ? { contentHash: match[4] } : {}),
+    };
+}
+//# sourceMappingURL=memory.js.map

package/apps/cli/dist/commands/relay.js

@@ -1,5 +1,28 @@
-import { CliError, ok, relayHealth, requireRelayUrl, wantsJson } from "./lib/index.js";
+import { CliError, auditRelayDb, ok, relayHealth, requireRelayUrl, wantsJson } from "./lib/index.js";
 export async function handleRelay({ domain, action, flags }) {
+    if (domain === "relay" && action === "audit-db") {
+        const dbPath = typeof flags.path === "string" ? flags.path : process.env.HAPPY_ELVES_DB;
+        if (!dbPath)
+            throw new CliError("relay audit-db requires --path <relay.db> or HAPPY_ELVES_DB.", "MISSING_ARGUMENT");
+        const result = await auditRelayDb({
+            dbPath,
+            outputDir: typeof flags.output === "string" ? flags.output : undefined,
+        });
+        if (wantsJson(flags)) {
+            ok("relay.audit-db", result);
+        }
+        else {
+            console.log(`Relay DB audit: ${result.ok ? "ok" : "failed"}`);
+            console.log(`source: ${result.sourceDbPath}`);
+            console.log(`backup: ${result.backupPath}`);
+            console.log(`manifest: ${result.manifestPath}`);
+            if (result.unknownTables.length > 0)
+                console.log(`unknown tables preserved: ${result.unknownTables.join(", ")}`);
+            for (const mismatch of result.backupVerification.mismatches)
+                console.log(`mismatch: ${mismatch}`);
+        }
+        return true;
+    }
     if (domain === "relay" && action === "serve") {
         const host = typeof flags.host === "string" ? flags.host : "0.0.0.0";
         const relayPort = typeof flags.port === "string" ? Number(flags.port) : 8787;
@@ -45,7 +68,9 @@ export async function handleRelay({ domain, action, flags }) {
         }
         const allOk = checks.every((check) => check.ok);
         if (wantsJson(flags)) {
-            ok("relay.doctor", { ok: allOk, relayUrl, checks });
+            if (!allOk)
+                process.exitCode = 1;
+            ok("relay.doctor", { ok: allOk, relayUrl, checks }, {}, allOk);
         }
         else {
             console.log(`Relay doctor: ${allOk ? "ok" : "issues found"}`);
@@ -53,6 +78,8 @@ export async function handleRelay({ domain, action, flags }) {
             for (const check of checks) {
                 console.log(`${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`);
             }
+            if (!allOk)
+                process.exitCode = 1;
         }
         return true;
     }

package/apps/cli/dist/commands/release.d.ts

@@ -0,0 +1,2 @@
+import type { CommandInput } from "./command.js";
+export declare function handleRelease({ domain, action, positional, flags }: CommandInput): Promise<boolean>;

package/apps/cli/dist/commands/release.js

@@ -0,0 +1,197 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { normalizeSessionTags, sessionTagsMatch } from "../../../../packages/shared/dist/index.js";
+import { CliError, ControllerClient, DEFAULT_COMMAND_TIMEOUT_MS, compactText, ok, parseDurationMs, readConfig, releaseProfilesPath, wantsJson, } from "./lib/index.js";
+const defaultReleaseProfile = {
+    name: "happy-elves",
+    releaseSessionTags: ["Happy Elves", "Release Session"],
+    reviewerSessionTags: ["Happy Elves", "Reviewer"],
+    dogfoodSessionTags: ["Happy Elves", "Dogfood"],
+};
+export async function handleRelease({ domain, action, positional, flags }) {
+    if (domain !== "release")
+        return false;
+    if (action === "profile") {
+        const subaction = positional[0];
+        if (subaction === "list") {
+            const store = await readReleaseProfileStore();
+            printReleaseOutput("release.profile.list", { profiles: store.profiles, defaultProfile: defaultReleaseProfile.name }, flags);
+            return true;
+        }
+        if (subaction === "show") {
+            const { profile } = await loadProfile(profileNameFromFlags(flags));
+            printReleaseOutput("release.profile.show", { profile }, flags);
+            return true;
+        }
+        if (subaction === "set") {
+            const name = positional[1] || profileNameFromFlags(flags);
+            const profile = profileFromFlags(name, flags);
+            const store = await readReleaseProfileStore();
+            const profiles = store.profiles.filter((item) => item.name !== profile.name);
+            profiles.push(profile);
+            await writeReleaseProfileStore({ version: 1, profiles: profiles.sort((left, right) => left.name.localeCompare(right.name)) });
+            printReleaseOutput("release.profile.set", { profile }, flags);
+            return true;
+        }
+        throw new CliError(`Unsupported release profile action: ${subaction ?? ""}`, "USAGE");
+    }
+    if (action === "resolve") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const { profile } = await loadProfile(profileNameFromFlags(flags));
+        const resolved = await resolveReleaseTargets(client, profile);
+        printReleaseOutput("release.resolve", resolved, flags, resolved.errors.length === 0);
+        if (resolved.errors.length > 0)
+            process.exit(1);
+        return true;
+    }
+    if (action === "notify") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const { profile } = await loadProfile(profileNameFromFlags(flags));
+        const releaseTarget = await resolveRequiredReleaseTarget(client, profile);
+        const text = releaseNotifyText(flags);
+        const wait = flags.detach !== true && flags["no-wait"] !== true;
+        const result = await client.run(releaseTarget.sessionId, text, {
+            wait,
+            permissionMode: "approve-all",
+            memoryMode: "off",
+            memoryProjectKey: `${releaseTarget.machineId}:${releaseTarget.cwd}`,
+            waitTimeoutMs: parseDurationMs(flags.timeout, DEFAULT_COMMAND_TIMEOUT_MS),
+            ackTimeoutMs: parseDurationMs(flags["ack-timeout"], 15_000),
+            inactivityTimeoutMs: parseDurationMs(flags["inactivity-timeout"] ?? flags["runtime-timeout"], DEFAULT_COMMAND_TIMEOUT_MS),
+        });
+        printReleaseOutput("release.notify", {
+            profile: profile.name,
+            releaseTarget,
+            prompt: text,
+            promptPreview: compactText(text, 80),
+            permissionMode: "approve-all",
+            memoryMode: "off",
+            wait,
+            ...result,
+        }, flags);
+        return true;
+    }
+    return false;
+}
+function profileNameFromFlags(flags) {
+    return typeof flags.profile === "string" && flags.profile.trim() ? flags.profile.trim() : defaultReleaseProfile.name;
+}
+function releaseNotifyText(flags) {
+    const value = typeof flags.text === "string" ? flags.text.trim() : "";
+    return value || "发布";
+}
+function tagsFromFlagValue(value) {
+    if (typeof value !== "string")
+        return [];
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function profileFromFlags(name, flags) {
+    const releaseSessionTags = normalizeSessionTags(tagsFromFlagValue(flags["release-tag"]));
+    if (releaseSessionTags.length === 0)
+        throw new CliError("Missing --release-tag", "MISSING_ARGUMENT");
+    const reviewerSessionTags = normalizeSessionTags(tagsFromFlagValue(flags["reviewer-tag"]));
+    const dogfoodSessionTags = normalizeSessionTags(tagsFromFlagValue(flags["dogfood-tag"]));
+    return {
+        name,
+        releaseSessionTags,
+        ...(reviewerSessionTags.length > 0 ? { reviewerSessionTags } : {}),
+        ...(dogfoodSessionTags.length > 0 ? { dogfoodSessionTags } : {}),
+    };
+}
+async function loadProfile(name) {
+    const store = await readReleaseProfileStore();
+    return { profile: store.profiles.find((profile) => profile.name === name) ?? defaultReleaseProfile, store };
+}
+async function readReleaseProfileStore() {
+    try {
+        const parsed = JSON.parse(await fs.readFile(releaseProfilesPath, "utf8"));
+        const profiles = Array.isArray(parsed.profiles) ? parsed.profiles.filter(isReleaseProfile) : [];
+        const hasDefault = profiles.some((profile) => profile.name === defaultReleaseProfile.name);
+        return { version: 1, profiles: hasDefault ? profiles : [defaultReleaseProfile, ...profiles] };
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+        return { version: 1, profiles: [defaultReleaseProfile] };
+    }
+}
+function isReleaseProfile(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const candidate = value;
+    return typeof candidate.name === "string" && Array.isArray(candidate.releaseSessionTags);
+}
+async function writeReleaseProfileStore(store) {
+    await fs.mkdir(path.dirname(releaseProfilesPath), { recursive: true });
+    const tempPath = `${releaseProfilesPath}.${process.pid}.${Date.now()}.tmp`;
+    await fs.writeFile(tempPath, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
+    await fs.rename(tempPath, releaseProfilesPath);
+}
+async function resolveReleaseTargets(client, profile) {
+    const warnings = [];
+    const errors = [];
+    const release = await resolveTaggedSession(client, profile.releaseSessionTags);
+    if (release.kind === "missing")
+        errors.push({ code: "TAG_TARGET_NOT_FOUND", message: `No release session matches tags: ${profile.releaseSessionTags.join(", ")}` });
+    if (release.kind === "ambiguous")
+        errors.push({ code: "TAG_TARGET_AMBIGUOUS", message: `Multiple release sessions match tags: ${profile.releaseSessionTags.join(", ")}`, candidates: release.candidates });
+    const reviewer = profile.reviewerSessionTags?.length ? await resolveTaggedSession(client, profile.reviewerSessionTags) : { kind: "skipped" };
+    if (reviewer.kind === "ambiguous")
+        errors.push({ code: "TAG_TARGET_AMBIGUOUS", message: `Multiple reviewer sessions match tags: ${profile.reviewerSessionTags?.join(", ")}`, candidates: reviewer.candidates });
+    if (reviewer.kind === "missing")
+        warnings.push({ code: "TAG_TARGET_NOT_FOUND", message: `No reviewer session matches tags: ${profile.reviewerSessionTags?.join(", ")}` });
+    const dogfood = profile.dogfoodSessionTags?.length ? await resolveTaggedSession(client, profile.dogfoodSessionTags) : { kind: "skipped" };
+    if (dogfood.kind === "ambiguous")
+        errors.push({ code: "TAG_TARGET_AMBIGUOUS", message: `Multiple dogfood sessions match tags: ${profile.dogfoodSessionTags?.join(", ")}`, candidates: dogfood.candidates });
+    if (dogfood.kind === "missing")
+        warnings.push({ code: "TAG_TARGET_NOT_FOUND", message: `No dogfood session matches tags: ${profile.dogfoodSessionTags?.join(", ")}` });
+    return {
+        profile,
+        ...(release.kind === "found" ? { releaseTarget: release.session } : {}),
+        ...(reviewer.kind === "found" ? { reviewerTarget: reviewer.session } : {}),
+        ...(dogfood.kind === "found" ? { dogfoodTarget: dogfood.session } : {}),
+        warnings,
+        errors,
+    };
+}
+async function resolveRequiredReleaseTarget(client, profile) {
+    const resolved = await resolveReleaseTargets(client, profile);
+    if (resolved.errors.length > 0 || !resolved.releaseTarget) {
+        const error = resolved.errors[0];
+        throw new CliError(error?.message ?? "Release target not found", error?.code ?? "TAG_TARGET_NOT_FOUND");
+    }
+    return resolved.releaseTarget;
+}
+async function resolveTaggedSession(client, tags) {
+    const sessions = await client.listSessions({ tags });
+    const candidates = [];
+    for (const session of sessions.filter((session) => session.status !== "closed")) {
+        const metadata = await client.decodeSessionMetadata(session);
+        const sessionTags = normalizeSessionTags(metadata.tags);
+        if (!sessionTagsMatch(sessionTags, tags))
+            continue;
+        candidates.push({
+            sessionId: session.id,
+            machineId: session.machineId,
+            agent: metadata.agent ?? session.agent,
+            cwd: metadata.cwd ?? session.cwd,
+            name: metadata.name ?? session.name,
+            tags: sessionTags,
+        });
+    }
+    if (candidates.length === 0)
+        return { kind: "missing" };
+    if (candidates.length > 1)
+        return { kind: "ambiguous", candidates };
+    return { kind: "found", session: candidates[0] };
+}
+function printReleaseOutput(type, data, flags, success = true) {
+    if (wantsJson(flags)) {
+        ok(type, data, {}, success);
+        return;
+    }
+    console.log(JSON.stringify(data, null, 2));
+}
+//# sourceMappingURL=release.js.map