@cydm/happy-elves 0.1.0-beta.84 → 0.1.0-beta.85

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

@@ -62,6 +62,7 @@ const valueFlags = new Set([
     "session",
     "secret",
     "since",
+    "source",
     "stop-on",
     "tail",
     "tags",
@@ -85,6 +86,7 @@ const booleanFlags = new Set([
     "all",
     "allow-any-sender",
     "app-secret-stdin",
+    "confirm-risk",
     "detach",
     "disable-reaction",
     "help",

package/apps/cli/dist/commands/lib/gateway-store.d.ts

@@ -36,7 +36,3 @@ export type GatewayStore = {
 };
 export declare function readGatewayStore(): Promise<GatewayStore>;
 export declare function updateGatewayStore(update: (store: GatewayStore) => GatewayStore | Promise<GatewayStore>): Promise<GatewayStore>;
-export declare function redactedGatewayChannel(channel: GatewayChannelConfig): Omit<GatewayChannelConfig, "localToken" | "localSecret"> & {
-    hasLocalToken: boolean;
-    hasLocalSecret: boolean;
-};

package/apps/cli/dist/commands/lib/gateway-store.js

@@ -30,12 +30,4 @@ export async function updateGatewayStore(update) {
     await writeGatewayStore(next);
     return next;
 }
-export function redactedGatewayChannel(channel) {
-    const { localToken, localSecret, ...rest } = channel;
-    return {
-        ...rest,
-        hasLocalToken: Boolean(localToken),
-        hasLocalSecret: Boolean(localSecret),
-    };
-}
 //# sourceMappingURL=gateway-store.js.map

package/apps/cli/dist/commands/lib/index.d.ts

@@ -17,7 +17,6 @@ export * from "./loop-store.js";
 export * from "./paths.js";
 export * from "./relay-db-audit.js";
 export * from "./relay-http.js";
-export * from "./schedule-store.js";
 export * from "./scope.js";
 export * from "./session-output.js";
 export * from "./session-view.js";

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

@@ -17,7 +17,6 @@ export * from "./loop-store.js";
 export * from "./paths.js";
 export * from "./relay-db-audit.js";
 export * from "./relay-http.js";
-export * from "./schedule-store.js";
 export * from "./scope.js";
 export * from "./session-output.js";
 export * from "./session-view.js";

package/apps/cli/dist/commands/lib/paths.d.ts

@@ -8,4 +8,3 @@ export declare const daemonPidPath: string;
 export declare const loopStorePath: string;
 export declare const loopStoreLockPath: string;
 export declare const gatewayStorePath: string;
-export declare const scheduleStorePath: string;

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

@@ -12,5 +12,4 @@ export const daemonPidPath = path.join(configDir, "daemon.pid");
 export const loopStorePath = path.join(configDir, "loops.json");
 export const loopStoreLockPath = path.join(configDir, "loops.json.lock");
 export const gatewayStorePath = path.join(configDir, "gateway.json");
-export const scheduleStorePath = path.join(configDir, "schedules.json");
 //# sourceMappingURL=paths.js.map

package/apps/cli/dist/commands/lib/session-output.d.ts

@@ -1,4 +1,5 @@
 import type { ControllerClient, DecodedSessionEvent } from "../../../../../packages/client/dist/index.js";
+import type { MemoryCitation, MemoryLayer } from "../../../../../packages/shared/dist/index.js";
 export declare function compactText(value: string, max?: number): string;
 export declare function lastAssistantOutput(events: DecodedSessionEvent[]): string;
 export declare function compareSessionEventLogicalOrder(left: DecodedSessionEvent, right: DecodedSessionEvent): number;
@@ -14,6 +15,14 @@ export type StoredTurnOutput = {
     startedAt?: number;
     completedAt: number;
     eventCount: number;
+    usedMemories?: UsedMemoryReference[];
+};
+type UsedMemoryReference = {
+    id: string;
+    layer: MemoryLayer;
+    path: string;
+    title?: string;
+    citation: MemoryCitation;
 };
 export type TurnSummary = {
     turnId: string;
@@ -30,6 +39,7 @@ export type TurnSummary = {
     firstEventId: number;
     lastEventId: number;
     eventCount: number;
+    usedMemories?: UsedMemoryReference[];
 };
 export type StructuredCommandOutput = {
     state: string;
@@ -43,6 +53,7 @@ export type StructuredCommandOutput = {
         latest?: string;
         metadata?: string;
     };
+    usedMemories?: UsedMemoryReference[];
 };
 export declare function writeTurnOutput(sessionId: string, turnId: string, events: DecodedSessionEvent[]): Promise<StoredTurnOutput>;
 export declare function readStoredTurnOutput(sessionId: string, turnId?: string): Promise<StoredTurnOutput | undefined>;
@@ -59,3 +70,4 @@ export declare function conciseEvents(events: DecodedSessionEvent[]): Array<{
 }>;
 export declare function printConciseEvents(events: DecodedSessionEvent[]): void;
 export declare function readPromptTextFile(filePath: string): Promise<string>;
+export {};

package/apps/cli/dist/commands/lib/session-output.js

@@ -48,6 +48,45 @@ function assistantOutputForTurn(events, turnId) {
         .join("")
         .trim();
 }
+function usedMemoriesForTurn(events, turnId) {
+    return dedupeUsedMemories(events
+        .filter((event) => event.turnId === turnId && event.decoded?.type === "memory_used")
+        .flatMap((event) => event.decoded?.type === "memory_used" ? event.decoded.memories : []));
+}
+function dedupeUsedMemories(memories) {
+    const seen = new Set();
+    const result = [];
+    for (const memory of memories) {
+        const key = [
+            memory.id,
+            memory.path,
+            memory.citation.path,
+            memory.citation.startLine,
+            memory.citation.endLine,
+        ].join(":");
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        result.push(memory);
+    }
+    return result;
+}
+function isUsedMemoryArray(value) {
+    return Array.isArray(value) && value.every((item) => {
+        if (!item || typeof item !== "object" || Array.isArray(item))
+            return false;
+        const record = item;
+        const citation = record.citation;
+        return typeof record.id === "string" &&
+            (record.layer === "user" || record.layer === "curated" || record.layer === "daily") &&
+            typeof record.path === "string" &&
+            (!record.title || typeof record.title === "string") &&
+            Boolean(citation) &&
+            typeof citation?.path === "string" &&
+            typeof citation?.startLine === "number" &&
+            typeof citation?.endLine === "number";
+    });
+}
 function sessionEventLogicalOrder(event) {
     const messageKey = event.messageId ?? "";
     if (event.occurredAt !== undefined) {
@@ -99,6 +138,7 @@ export async function writeTurnOutput(sessionId, turnId, events) {
     await fs.mkdir(paths.dir, { recursive: true });
     const output = assistantOutputForTurn(events, turnId) || terminalTextForDone(events, turnId);
     const turnEvents = events.filter((event) => event.turnId === turnId);
+    const usedMemories = usedMemoriesForTurn(events, turnId);
     const doneEvent = [...turnEvents].reverse().find((event) => event.decoded?.type === "done");
     const metadata = {
         sessionId,
@@ -107,6 +147,7 @@ export async function writeTurnOutput(sessionId, turnId, events) {
         startedAt: turnEvents[0]?.createdAt,
         completedAt: doneEvent?.createdAt ?? Date.now(),
         eventCount: turnEvents.length,
+        ...(usedMemories.length > 0 ? { usedMemories } : {}),
         outputPath: paths.turn,
         latestPath: paths.latest,
     };
@@ -158,6 +199,7 @@ export async function readStoredTurnOutput(sessionId, turnId) {
         startedAt: typeof metadata.startedAt === "number" ? metadata.startedAt : undefined,
         completedAt: typeof metadata.completedAt === "number" ? metadata.completedAt : 0,
         eventCount: typeof metadata.eventCount === "number" ? metadata.eventCount : 0,
+        ...(isUsedMemoryArray(metadata.usedMemories) ? { usedMemories: metadata.usedMemories } : {}),
     };
 }
 export function summarizeTurns(events) {
@@ -177,6 +219,7 @@ export function summarizeTurns(events) {
             firstEventId: event.id,
             lastEventId: event.id,
             eventCount: 0,
+            usedMemories: [],
             order,
         };
         current.startedAt ??= event.createdAt;
@@ -200,6 +243,9 @@ export function summarizeTurns(events) {
             current.checkpointId = payload.currentHead;
             current.runtimeTurnId = payload.lastTurnId;
         }
+        else if (payload?.type === "memory_used") {
+            current.usedMemories = dedupeUsedMemories([...current.usedMemories, ...payload.memories]);
+        }
         turns.set(event.turnId, current);
     }
     return [...turns.values()]
@@ -218,6 +264,7 @@ export function summarizeTurns(events) {
         firstEventId: turn.firstEventId,
         lastEventId: turn.lastEventId,
         eventCount: turn.eventCount,
+        ...(turn.usedMemories.length > 0 ? { usedMemories: turn.usedMemories } : {}),
         order: turn.order,
     }))
         .sort((left, right) => right.order.time - left.order.time ||
@@ -236,6 +283,7 @@ export function structuredOutputForTurn(sessionId, turn) {
         status: turn.status,
         finalOutput,
         ...(turn.status === "failed" && finalOutput ? { error: finalOutput } : {}),
+        ...(turn.usedMemories?.length ? { usedMemories: turn.usedMemories } : {}),
     };
 }
 export function structuredOutputForStoredTurn(output) {
@@ -246,6 +294,7 @@ export function structuredOutputForStoredTurn(output) {
         status: output.status,
         finalOutput: output.output || undefined,
         ...(output.status === "failed" && output.output ? { error: output.output } : {}),
+        ...(output.usedMemories?.length ? { usedMemories: output.usedMemories } : {}),
         artifactPaths: {
             output: output.outputPath,
             latest: output.latestPath,

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

@@ -74,7 +74,7 @@ Session management:
   happy-elves turn list <sessionId> [--limit 10] [--verbose] [--json]
   happy-elves turn status <sessionId> <turnId> [--verbose] [--json]
   happy-elves turn result <sessionId> [<turnId>] [--verbose] [--json]
-  happy-elves turn run <sessionId> (--text <prompt> | --text-file <path>) [--detach] [--timeout 1000s] [--inactivity-timeout 1000s] [--permission-mode approve-reads|approve-all|deny-all] [--json]
+  happy-elves turn run <sessionId> (--text <prompt> | --text-file <path>) [--detach] [--timeout 1000s] [--inactivity-timeout 1000s] [--permission-mode approve-reads|approve-all|deny-all] [--memory off|readonly|readwrite] [--memory-project <key>] [--memory-top-n 3] [--json]
   happy-elves turn wait <sessionId> <turnId> [--timeout 1000s] --json
   happy-elves turn cancel <sessionId> <turnId> [--reason <reason>] --json
   happy-elves turn rewind <sessionId> <turn-or-checkpoint-id> --json
@@ -124,6 +124,7 @@ gateway serve is kept for fake/local debugging only; lark-cli is not a product d
   happy-elves memory save [--machine <machineId>] [--project <projectKey>] [--layer user|curated|daily] (--text <text> | --text-file <path>) [--title <title>] [--date YYYY-MM-DD] --json
   happy-elves memory read <USER.md|MEMORY.md|memory/YYYY-MM-DD.md> [--project <projectKey>] --json
   happy-elves memory search --query <text> [--project <projectKey>] [--limit 5] --json
+  happy-elves memory promote --source <path:start-end[@contentHash]> --layer user|curated [--project <projectKey>] [--title <title>] --json
   happy-elves memory reindex [--project <projectKey>] --json
   happy-elves memory sync [--project <projectKey>] --json
 

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

@@ -72,7 +72,9 @@ export async function handleMemory({ domain, action, positional, flags }) {
                 console.log("No matching memory.");
             else
                 for (const item of results) {
-                    console.log(`${item.path}:${item.citation.startLine}-${item.citation.endLine}  ${item.snippet}`);
+                    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}`);
                 }
@@ -81,6 +83,27 @@ export async function handleMemory({ domain, action, positional, flags }) {
         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);
@@ -128,4 +151,28 @@ function parseMemoryMode(value) {
         return value;
     throw new CliError("Invalid --mode; expected off|readonly|readwrite", "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/schedule.js

@@ -48,8 +48,10 @@ export async function handleSchedule({ domain, action, positional, flags }) {
             if (schedules.length === 0)
                 console.log("No schedules.");
             else
-                for (const schedule of schedules)
-                    console.log(`${schedule.id}  ${schedule.status}  ${cadenceLabel(schedule)}  next:${schedule.nextRunAt ?? "manual"}  source:${schedule.sourceSessionId ?? schedule.sessionId ?? "pending"}`);
+                for (const schedule of schedules) {
+                    const preview = schedule.previewRunAt?.length ? `  preview:${schedule.previewRunAt.join(",")}` : "";
+                    console.log(`${schedule.id}  ${schedule.status}  ${cadenceLabel(schedule)}  next:${schedule.nextRunAt ?? "manual"}  source:${schedule.sourceSessionId ?? schedule.sessionId ?? "pending"}${preview}`);
+                }
             return true;
         }
         ok("schedule.list", { machineId, schedules: schedules.map(compactSchedule) });
@@ -216,6 +218,7 @@ function compactSchedule(schedule) {
         stopOn: schedule.stopOn,
         dueAt: schedule.dueAt,
         nextRunAt: schedule.nextRunAt,
+        previewRunAt: schedule.previewRunAt,
         status: schedule.status,
         runCount: schedule.runCount ?? schedule.runs.length,
         lastRun: schedule.lastRun ?? schedule.runs[0],

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

@@ -70,6 +70,42 @@ function findTurnSummaryByAnyId(turns, id) {
         turn.runtimeTurnId === id ||
         turn.checkpointId === id);
 }
+function recoveryPromptWithContext(turns, inputTurnId, continuation) {
+    const chronological = [...turns].reverse();
+    const selected = [];
+    for (const turn of chronological) {
+        if (inputTurnId && (turn.turnId === inputTurnId || turn.runtimeTurnId === inputTurnId || turn.checkpointId === inputTurnId))
+            break;
+        if (turn.status === "running")
+            break;
+        selected.push(turn);
+    }
+    const blocks = selected.map((turn) => {
+        const lines = [`Turn ${turn.turnId} (${turn.status})`];
+        if (turn.prompt.trim())
+            lines.push(`User:\n${turn.prompt.trim()}`);
+        const output = (turn.output || turn.terminalText).trim();
+        if (output)
+            lines.push(`Assistant:\n${output}`);
+        return lines.join("\n");
+    });
+    const context = clampEnd(blocks.join("\n\n---\n\n"), 32 * 1024);
+    if (!context.trim())
+        return continuation;
+    return [
+        "Recovered context from the original Happy Elves session. The previous turn could not be confirmed, so do not assume it completed and do not replay its original prompt.",
+        "",
+        context,
+        "",
+        "User continuation:",
+        continuation,
+    ].join("\n");
+}
+function clampEnd(value, maxChars) {
+    if (value.length <= maxChars)
+        return value;
+    return value.slice(value.length - maxChars);
+}
 async function waitForTurn(client, sessionId, turnId, timeoutMs) {
     const startedAt = Date.now();
     while (true) {
@@ -127,6 +163,117 @@ export async function handleTurn({ domain, action, positional, flags }) {
         ok("turn.status", wantsVerbose(flags) ? { sessionId, inputTurnId: turnId, turn } : { sessionId, inputTurnId: turnId, ...compactTurn(turn) }, { sessionId, turnId: turn.turnId });
         return true;
     }
+    if (action === "reconcile") {
+        const sessionId = requirePositional(positional[0], "sessionId");
+        const turnId = positional[1] ?? (typeof flags.turn === "string" ? flags.turn : undefined);
+        if (turnId)
+            rejectEventPrimitiveId(turnId);
+        const result = await client.reconcileTurn(sessionId, turnId);
+        if (wantsJson(flags)) {
+            ok("turn.reconcile", result, { requestId: result.requestId, sessionId, turnId: result.turnId ?? turnId });
+        }
+        else {
+            console.log(`Reconcile: ${result.status}${result.terminalStatus ? ` (${result.terminalStatus})` : ""}`);
+            if (result.turnId)
+                console.log(`Turn: ${result.turnId}`);
+            if (result.providerTurnId)
+                console.log(`Provider turn: ${result.providerTurnId}`);
+            if (result.reason)
+                console.log(`Reason: ${result.reason}`);
+            if (result.status !== "terminal" && result.status !== "active") {
+                console.log("Unable to confirm whether the previous execution finished. Use turn recover with --confirm-risk before sending a continuation.");
+            }
+        }
+        return true;
+    }
+    if (action === "recover") {
+        const sessionId = requirePositional(positional[0], "sessionId");
+        const inputTurnId = positional[1] ?? (typeof flags.turn === "string" ? flags.turn : undefined);
+        if (inputTurnId)
+            rejectEventPrimitiveId(inputTurnId);
+        if (flags["confirm-risk"] !== true) {
+            throw new CliError("Recovery can duplicate external side effects if the original turn later completes. Re-run with --confirm-risk to create a Recovery Session.", "RECOVERY_CONFIRMATION_REQUIRED");
+        }
+        const continuation = typeof flags.text === "string"
+            ? flags.text
+            : typeof flags["text-file"] === "string"
+                ? await readPromptTextFile(flags["text-file"])
+                : "";
+        if (!continuation.trim())
+            throw new CliError("Missing --text or --text-file", "MISSING_ARGUMENT");
+        const sourceSession = await requireProjectedSession(client, sessionId, "turn.recover");
+        const sourceMetadata = await client.decodeSessionMetadata(sourceSession);
+        const sourceName = sourceMetadata.name ?? sourceSession.name;
+        const recoveryName = `${sourceName} Recovery`;
+        const turns = summarizeTurns(await client.history(sessionId, 1000));
+        const targetTurn = inputTurnId ? findTurnSummaryByAnyId(turns, inputTurnId) : turns[0];
+        let recoverySessionId;
+        let recoveryMode = "new-session-context";
+        let forkError;
+        const checkpoint = targetTurn?.checkpointId && !targetTurn.checkpointId.startsWith("event:") ? targetTurn.checkpointId : undefined;
+        if (checkpoint) {
+            try {
+                const fork = await client.fork(sessionId, { from: checkpoint, name: recoveryName });
+                recoverySessionId = fork.sessionId;
+                recoveryMode = "checkpoint-fork";
+            }
+            catch (error) {
+                forkError = error instanceof Error ? error.message : String(error);
+            }
+        }
+        let promptText = continuation;
+        if (!recoverySessionId) {
+            const created = await client.createSession({
+                machineId: sourceSession.machineId,
+                agent: sourceMetadata.agent ?? sourceSession.agent,
+                cwd: sourceMetadata.cwd ?? sourceSession.cwd,
+                name: recoveryName,
+                createdFrom: "turn.recover",
+                permissionMode: parsePermissionMode(flags["permission-mode"] ?? flags.permission),
+            });
+            if (!created.sessionId)
+                throw new CliError("Recovery session create was acknowledged without sessionId", "RELAY_RESPONSE_INVALID");
+            recoverySessionId = created.sessionId;
+            promptText = recoveryPromptWithContext(turns, inputTurnId, continuation);
+        }
+        await client.wait(recoverySessionId, { timeoutMs: 120_000 });
+        const permissionMode = parsePermissionMode(flags["permission-mode"] ?? flags.permission);
+        const wait = flags.detach !== true && flags["no-wait"] !== true;
+        const memoryMode = parseMemoryModeFlag(flags["memory-mode"] ?? flags.memory) ?? "readonly";
+        const recoverySession = await client.getSession(recoverySessionId);
+        const memoryProject = typeof flags["memory-project"] === "string"
+            ? flags["memory-project"]
+            : recoverySession
+                ? `${recoverySession.machineId}:${recoverySession.cwd}`
+                : undefined;
+        const result = await client.run(recoverySessionId, promptText, {
+            wait,
+            permissionMode,
+            memoryMode,
+            ...(memoryProject ? { memoryProjectKey: memoryProject } : {}),
+            memoryTopN: 3,
+            waitTimeoutMs: parseDurationMs(flags.timeout, DEFAULT_COMMAND_TIMEOUT_MS),
+            ackTimeoutMs: 15_000,
+        });
+        if (wantsJson(flags)) {
+            ok("turn.recover", {
+                sourceSessionId: sessionId,
+                sourceTurnId: targetTurn?.turnId ?? inputTurnId,
+                recoverySessionId,
+                recoveryTurnId: result.turnId,
+                recoveryMode,
+                ...(forkError ? { forkError } : {}),
+            }, { requestId: result.requestId, sessionId: recoverySessionId, turnId: result.turnId });
+        }
+        else {
+            console.log(`Recovery session: ${recoverySessionId}`);
+            console.log(`Recovery mode: ${recoveryMode}`);
+            if (forkError)
+                console.log(`Checkpoint fork fallback: ${forkError}`);
+            console.log(`Turn: ${result.turnId}`);
+        }
+        return true;
+    }
     if (action === "run") {
         const sessionId = requirePositional(positional[0], "sessionId");
         const text = typeof flags.text === "string"

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

@@ -1,4 +1,4 @@
-import { ControllerClient, ok, readConfig, requirePositional, requireString, wantsJson } from "./lib/index.js";
+import { CliError, ControllerClient, ok, readConfig, requirePositional, requireString, wantsJson } from "./lib/index.js";
 export async function handleWorkspace({ domain, action, positional, flags }) {
     if (domain !== "workspace")
         return false;
@@ -49,9 +49,17 @@ export async function handleWorkspace({ domain, action, positional, flags }) {
         const machineId = typeof flags.machine === "string" ? flags.machine : undefined;
         const cwd = typeof flags.cwd === "string" ? flags.cwd : undefined;
         const agent = typeof flags.agent === "string" ? flags.agent : undefined;
-        ok("workspace.prefer", await client.setWorkspaceProjectPreference({ projectKey, machineId, cwd, agent }));
+        const memoryMode = parseMemoryMode(flags["memory-mode"] ?? flags.memory);
+        ok("workspace.prefer", await client.setWorkspaceProjectPreference({ projectKey, machineId, cwd, agent, ...(memoryMode ? { memoryMode } : {}) }));
         return true;
     }
     return false;
 }
+function parseMemoryMode(value) {
+    if (value === undefined || value === false)
+        return undefined;
+    if (value === "off" || value === "readonly" || value === "readwrite")
+        return value;
+    throw new CliError("Invalid --memory-mode; expected off|readonly|readwrite", "INVALID_ARGUMENT");
+}
 //# sourceMappingURL=workspace.js.map

package/apps/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cydm/happy-elves-cli",
-  "version": "0.1.0-beta.84",
+  "version": "0.1.0-beta.85",
   "private": true,
   "type": "module"
 }

package/apps/daemon/dist/gateway/adapters.d.ts

@@ -14,7 +14,7 @@ export type GatewayInboundResult = {
     duplicate?: boolean;
     queued?: boolean;
 };
-export type GatewayInboundSender = (input: {
+type GatewayInboundSender = (input: {
     gatewayId: string;
     platform: "feishu" | "fake";
     platformEventId: string;
@@ -35,3 +35,4 @@ export type GatewayAdapterContext = {
     readChannel: () => Promise<GatewayChannelConfig | undefined>;
     sendInbound: GatewayInboundSender;
 };
+export {};

package/apps/daemon/dist/gateway/feishu.d.ts

@@ -56,10 +56,6 @@ export declare function createFeishuProcessingReactionTracker(client: LarkClient
     clear(): Promise<void>;
     pendingCount(): number;
 };
-export declare function createFeishuBotOpenIdResolver(client: LarkClient): {
-    get(): Promise<FeishuBotIdentity | undefined>;
-    cached(): FeishuBotIdentity | undefined;
-};
 export declare function normalizeFeishuMessage(data: unknown): NormalizedFeishuInbound | undefined;
 export declare function shouldHandleFeishuInbound(profile: {
     inboundMode: "mention" | "all";

package/apps/daemon/dist/gateway/feishu.js

@@ -144,7 +144,7 @@ export function createFeishuProcessingReactionTracker(client, input = {}) {
     }
     return { start, complete, clear, pendingCount: () => pending.size };
 }
-export function createFeishuBotOpenIdResolver(client) {
+function createFeishuBotOpenIdResolver(client) {
     let cached;
     let inflight;
     async function get() {

package/apps/daemon/dist/gateway/runtime.d.ts

@@ -18,11 +18,6 @@ type GatewayTerminalInput = {
     error?: string;
     outputPreview?: string;
 };
-export declare function gatewayRuntimeIsListening(): boolean;
-export declare function gatewayRuntimeEndpoint(): {
-    host: string;
-    port: number;
-};
 export declare function startGatewayRuntime(config: DaemonConfig): Promise<void>;
 export declare function stopGatewayRuntime(): Promise<void>;
 export declare function syncGatewayRuntime(config?: DaemonConfig | undefined): Promise<void>;

package/apps/daemon/dist/gateway/runtime.js

@@ -10,10 +10,7 @@ let gatewayServer;
 let gatewayRuntimeConfig;
 const gatewayAdapters = new Map();
 let gatewaySyncChain = Promise.resolve();
-export function gatewayRuntimeIsListening() {
-    return Boolean(gatewayServer?.listening) || gatewayAdapters.size > 0;
-}
-export function gatewayRuntimeEndpoint() {
+function gatewayRuntimeEndpoint() {
     return {
         host: process.env.HAPPY_ELVES_GATEWAY_HOST || "127.0.0.1",
         port: parseGatewayPort(process.env.HAPPY_ELVES_GATEWAY_PORT),

package/apps/daemon/dist/gateway/store.d.ts

@@ -66,7 +66,7 @@ export type GatewayPendingReply = {
     createdAt: string;
     updatedAt: string;
 };
-export type GatewayReplyHistory = {
+type GatewayReplyHistory = {
     channelId: string;
     externalConversationId: string;
     externalMessageId: string;
@@ -89,3 +89,4 @@ export declare function readGatewayStore(): Promise<GatewayStore>;
 export declare function updateGatewayStore(update: (store: GatewayStore) => GatewayStore | Promise<GatewayStore>): Promise<GatewayStore>;
 export declare function publicGatewayChannel(channel: GatewayChannelConfig, listening?: boolean): GatewayChannelPublic;
 export declare function upsertGatewayChannel(current: GatewayStore, input: GatewayChannelInput, defaultMachineId: string): GatewayStore;
+export {};