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

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

@@ -48,6 +48,66 @@ 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) {
+        return { time: event.occurredAt, seq: event.turnSeq ?? event.seq, messageKey, id: event.id };
+    }
+    if (event.messageId?.startsWith("hist_") && event.turnSeq !== undefined) {
+        return { time: 0, seq: event.turnSeq, messageKey, id: event.id };
+    }
+    return { time: event.createdAt, seq: event.seq, messageKey, id: event.id };
+}
+export function compareSessionEventLogicalOrder(left, right) {
+    const leftOrder = sessionEventLogicalOrder(left);
+    const rightOrder = sessionEventLogicalOrder(right);
+    if (leftOrder.time !== rightOrder.time)
+        return leftOrder.time - rightOrder.time;
+    if (leftOrder.seq !== rightOrder.seq)
+        return leftOrder.seq - rightOrder.seq;
+    if (leftOrder.messageKey !== rightOrder.messageKey)
+        return leftOrder.messageKey < rightOrder.messageKey ? -1 : 1;
+    return leftOrder.id - rightOrder.id;
+}
 function outputPaths(sessionId, turnId) {
     const dir = path.join(outputRoot, sessionId);
     const latest = path.join(dir, "latest.md");
@@ -78,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,
@@ -86,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,
     };
@@ -137,13 +199,15 @@ 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) {
     const folded = foldAliasedRuntimeEvents(events);
     const turns = new Map();
-    const sorted = [...folded.events].sort((left, right) => left.id - right.id);
+    const sorted = [...folded.events].sort(compareSessionEventLogicalOrder);
     for (const event of sorted) {
+        const order = sessionEventLogicalOrder(event);
         const current = turns.get(event.turnId) ?? {
             turnId: event.turnId,
             promptChunks: [],
@@ -155,11 +219,16 @@ export function summarizeTurns(events) {
             firstEventId: event.id,
             lastEventId: event.id,
             eventCount: 0,
+            usedMemories: [],
+            order,
         };
         current.startedAt ??= event.createdAt;
         current.updatedAt = event.createdAt;
         current.lastEventId = event.id;
         current.eventCount += 1;
+        current.order = order;
+        if (event.turnSeq !== undefined)
+            current.turnSeq = event.turnSeq;
         const payload = event.decoded;
         if (payload?.type === "user_prompt" && payload.text.trim()) {
             current.promptChunks.push(payload.text.trim());
@@ -174,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()]
@@ -181,6 +253,7 @@ export function summarizeTurns(events) {
         turnId: turn.turnId,
         checkpointId: turn.checkpointId,
         runtimeTurnId: turn.runtimeTurnId,
+        turnSeq: turn.turnSeq,
         status: turn.status,
         prompt: turn.promptChunks.join("\n").trim(),
         output: turn.outputChunks.join("").trim() || turn.terminalText,
@@ -191,8 +264,15 @@ 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.updatedAt - left.updatedAt || right.lastEventId - left.lastEventId);
+        .sort((left, right) => right.order.time - left.order.time ||
+        right.order.seq - left.order.seq ||
+        (right.order.messageKey === left.order.messageKey ? 0 : right.order.messageKey < left.order.messageKey ? -1 : 1) ||
+        right.order.id - left.order.id ||
+        right.lastEventId - left.lastEventId)
+        .map(({ order: _order, ...turn }) => turn);
 }
 export function structuredOutputForTurn(sessionId, turn) {
     const finalOutput = turn.output || turn.terminalText || undefined;
@@ -203,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) {
@@ -213,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,
@@ -229,10 +311,12 @@ export function structuredOutputForRunningTurn(sessionId, turnId) {
     };
 }
 function foldAliasedRuntimeEvents(events) {
+    events = dedupeSyntheticHistoricalEvents(events);
     const profiles = new Map();
     const runtimeToRequest = new Map();
     for (const event of events) {
-        const profile = profiles.get(event.turnId) ?? { output: "" };
+        const profile = profiles.get(event.turnId) ?? { output: "", hasDone: false, firstEventId: event.id };
+        profile.firstEventId = Math.min(profile.firstEventId, event.id);
         const payload = event.decoded;
         if (payload?.type === "user_prompt" && profile.prompt === undefined) {
             profile.prompt = payload.text.trim();
@@ -241,6 +325,7 @@ function foldAliasedRuntimeEvents(events) {
             profile.output += payload.text;
         }
         else if (payload?.type === "done") {
+            profile.hasDone = true;
             const runtimeTurnId = payload.lastTurnId ?? payload.currentHead;
             if (runtimeTurnId && runtimeTurnId !== event.turnId && !runtimeTurnId.startsWith("event:")) {
                 runtimeToRequest.set(runtimeTurnId, event.turnId);
@@ -262,11 +347,134 @@ function foldAliasedRuntimeEvents(events) {
             duplicateRuntimeToRequest.set(runtimeTurnId, requestTurnId);
         }
     }
+    const inferredRuntimeToRequest = inferRuntimeToRequestAliases(profiles, runtimeToRequest);
+    const inferredRequestToRuntime = new Map();
+    for (const [runtimeTurnId, requestTurnId] of inferredRuntimeToRequest) {
+        runtimeToRequest.set(runtimeTurnId, requestTurnId);
+        inferredRequestToRuntime.set(requestTurnId, runtimeTurnId);
+    }
+    const foldedEvents = [];
+    for (const event of events) {
+        if (duplicateRuntimeTurns.has(event.turnId))
+            continue;
+        const inferredRequestTurnId = inferredRuntimeToRequest.get(event.turnId);
+        if (inferredRequestTurnId) {
+            foldedEvents.push({ ...event, turnId: inferredRequestTurnId });
+            continue;
+        }
+        const inferredRuntimeTurnId = inferredRequestToRuntime.get(event.turnId);
+        if (inferredRuntimeTurnId && shouldDropRequestSideDuplicateEvent(event, profiles.get(inferredRuntimeTurnId))) {
+            continue;
+        }
+        foldedEvents.push(event);
+    }
     return {
-        events: duplicateRuntimeTurns.size === 0 ? events : events.filter((event) => !duplicateRuntimeTurns.has(event.turnId)),
-        runtimeToRequest: duplicateRuntimeToRequest,
+        events: foldedEvents,
+        runtimeToRequest: new Map([...duplicateRuntimeToRequest, ...inferredRuntimeToRequest]),
     };
 }
+function inferRuntimeToRequestAliases(profiles, explicitRuntimeToRequest) {
+    const requestsByPrompt = new Map();
+    const runtimesByPrompt = new Map();
+    for (const [turnId, profile] of profiles) {
+        const promptKey = comparableOutput(profile.prompt ?? "");
+        if (!promptKey)
+            continue;
+        if (turnId.startsWith("turn_") && !profile.hasDone) {
+            requestsByPrompt.set(promptKey, [...(requestsByPrompt.get(promptKey) ?? []), { turnId, output: profile.output, firstEventId: profile.firstEventId }]);
+        }
+        else if (!turnId.startsWith("turn_") && profile.hasDone && !explicitRuntimeToRequest.has(turnId)) {
+            runtimesByPrompt.set(promptKey, [...(runtimesByPrompt.get(promptKey) ?? []), { turnId, output: profile.output, firstEventId: profile.firstEventId }]);
+        }
+    }
+    const inferred = new Map();
+    for (const [promptKey, requests] of requestsByPrompt) {
+        const runtimes = runtimesByPrompt.get(promptKey) ?? [];
+        if (requests.length !== 1 || runtimes.length !== 1)
+            continue;
+        const request = requests[0];
+        const runtime = runtimes[0];
+        if (!request || !runtime)
+            continue;
+        if (runtime.firstEventId <= request.firstEventId)
+            continue;
+        if (!outputsAreCompatible(request.output, runtime.output))
+            continue;
+        inferred.set(runtime.turnId, request.turnId);
+    }
+    return inferred;
+}
+function outputsAreCompatible(requestOutput, runtimeOutput) {
+    const request = comparableOutput(requestOutput);
+    const runtime = comparableOutput(runtimeOutput);
+    if (!request || !runtime)
+        return true;
+    return request.includes(runtime) || runtime.includes(request);
+}
+function shouldDropRequestSideDuplicateEvent(event, runtimeProfile) {
+    if (!runtimeProfile)
+        return false;
+    const payload = event.decoded;
+    if (payload?.type === "user_prompt") {
+        return comparableOutput(payload.text) === comparableOutput(runtimeProfile.prompt ?? "");
+    }
+    if (payload?.type === "text_delta" && payload.stream !== "thought" && payload.text) {
+        const chunk = comparableOutput(payload.text);
+        return Boolean(chunk) && comparableOutput(runtimeProfile.output).includes(chunk);
+    }
+    return false;
+}
+function dedupeSyntheticHistoricalEvents(events) {
+    const groups = new Map();
+    for (const event of events) {
+        const key = historicalComparableEventKey(event);
+        if (!key)
+            continue;
+        groups.set(key, [...(groups.get(key) ?? []), event]);
+    }
+    const keepIds = new Set();
+    const dropIds = new Set();
+    for (const group of groups.values()) {
+        if (group.length < 2 || !group.some(isSyntheticHistoricalEvent))
+            continue;
+        const preferred = group.find((event) => !isSyntheticHistoricalEvent(event)) ?? group[0];
+        if (preferred)
+            keepIds.add(preferred.id);
+        for (const event of group) {
+            if (event.id !== preferred?.id)
+                dropIds.add(event.id);
+        }
+    }
+    return events.filter((event) => !dropIds.has(event.id) || keepIds.has(event.id));
+}
+function isSyntheticHistoricalEvent(event) {
+    const messageId = event.messageId ?? "";
+    return messageId.startsWith("hist_") || messageId.startsWith("tail_");
+}
+function historicalComparableEventKey(event) {
+    const payload = event.decoded;
+    if (!payload)
+        return undefined;
+    if (payload.type === "user_prompt")
+        return [event.turnId, "user_prompt", comparableOutput(payload.text)].join("\0");
+    if (payload.type === "text_delta" && payload.stream !== "thought") {
+        return [event.turnId, "text_delta", payload.stream, comparableOutput(payload.text)].join("\0");
+    }
+    if (payload.type === "done") {
+        return [
+            event.turnId,
+            "done",
+            payload.status,
+            payload.currentHead ?? "",
+            payload.lastTurnId ?? "",
+            comparableOutput(payload.error ?? payload.stopReason ?? ""),
+        ].join("\0");
+    }
+    if (payload.type === "memory_used") {
+        return [event.turnId, "memory_used", payload.mode, payload.projectKey, JSON.stringify(payload.memories)].join("\0");
+    }
+    return undefined;
+}
 function isDuplicateRuntimeOutput(requestOutput, runtimeOutput) {
     const request = comparableOutput(requestOutput);
     if (!request)
@@ -302,7 +510,7 @@ export async function rebuildTurnOutput(client, sessionId, turnId) {
 }
 export function conciseEvents(events) {
     const result = [];
-    for (const event of events) {
+    for (const event of dedupeSyntheticHistoricalEvents(events)) {
         const payload = event.decoded;
         if (!payload)
             continue;

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

@@ -1,5 +1,5 @@
-import type { ControllerClient, DecodedSessionEvent } from "@happy-elves/client";
-import type { MachineSnapshot, SessionSnapshot } from "@happy-elves/shared";
+import type { ControllerClient, DecodedSessionEvent } from "../../../../../packages/client/dist/index.js";
+import type { MachineSnapshot, SessionSnapshot } from "../../../../../packages/shared/dist/index.js";
 import { type MachineMetadata, type OrchestrationSummary, type OrchestrationState } from "./types.js";
 export declare function showMachine(client: ControllerClient, machine: MachineSnapshot): Promise<MachineSnapshot & {
     defaultCwd?: string;

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

@@ -43,7 +43,9 @@ export async function topLevelStatus(flags) {
         } : undefined,
     };
     if (wantsJson(flags)) {
-        ok("status", data);
+        if (!data.relay.ok)
+            process.exitCode = 1;
+        ok("status", data, {}, data.relay.ok);
         return;
     }
     console.log(`Relay: ${config.relayUrl}${relayError ? ` (unreachable: ${relayError})` : ""}`);
@@ -59,5 +61,7 @@ export async function topLevelStatus(flags) {
         console.log(`Result: happy-elves turn result ${latestSession.id}`);
         console.log(`Run: happy-elves turn run ${latestSession.id} --text "..."`);
     }
+    if (!data.relay.ok)
+        process.exitCode = 1;
 }
 //# sourceMappingURL=status.js.map

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

@@ -1,5 +1,5 @@
-import type { ScopedTokenScope } from "@happy-elves/client";
-import type { SessionSnapshot } from "@happy-elves/shared";
+import type { ScopedTokenScope } from "../../../../../packages/client/dist/index.js";
+import type { SessionSnapshot } from "../../../../../packages/shared/dist/index.js";
 export type CliConfig = {
     relayUrl: string;
     controllerToken: string;
@@ -30,6 +30,8 @@ export type SessionMetadata = {
     name?: string;
     requestedRuntimeName?: string;
     runtime?: unknown;
+    tags?: string[];
+    tagKeys?: string[];
 };
 export declare const idleSessionStatuses: SessionSnapshot["status"][];
 export type OrchestrationState = "pending" | "active" | "idle" | "completed" | "blocked" | "needs-user" | "closed";

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

@@ -8,7 +8,7 @@ Start or reuse a local Happy Elves controller, daemon, and invite flow.
 
 Show the current relay, daemon, machine, and latest session state.
 `,
-    doctor: `Usage: happy-elves doctor [--relay <url>] [--json]
+    doctor: `Usage: happy-elves doctor [--relay <url>] [--strict] [--json]
 
 Check local controller config, relay reachability, and daemon state.
 `,
@@ -28,6 +28,7 @@ Check local controller config, relay reachability, and daemon state.
   happy-elves remote invite-controller [--device-name <name>] [--ttl 10m] [--join-url-base <url>] [--json]
   happy-elves remote join-controller (--url <url> | --code <code> --invite-secret <secret>) [--relay <url>] [--device-id <id>] [--device-name <name>] --json
   happy-elves remote add-controller [--device-id <id>] [--device-name <name>] --json
+  happy-elves remote rename <deviceId> --name <name> --json
   happy-elves remote revoke <deviceId> --json
 `,
     machine: `Usage:
@@ -45,11 +46,16 @@ Check local controller config, relay reachability, and daemon state.
   file preview is read-only and limited to files inside --root.
 `,
     session: `Usage:
-  happy-elves session create --machine <machineId> [--agent codex] [--cwd <path>] [--name <name>] [--permission-mode <mode>] --json
-  happy-elves session list [--machine <machineId>] [--agent <agent>] [--cwd <cwd>] [--name <name>] [--limit n] [--all] [--verbose] [--json]
+  happy-elves session create --machine <machineId> [--agent codex] [--cwd <path>] [--name <name>] [--permission-mode <mode>] [--tag <tag>] [--hidden --source dogfood] --json
+  happy-elves session list [--machine <machineId>] [--agent <agent>] [--cwd <cwd>] [--name <name>] [--tag <tag>] [--limit n] [--all] [--verbose] [--json]
+  happy-elves session tag add <sessionId> --tag <tag> --json
+  happy-elves session tag remove <sessionId> --tag <tag> --json
+  happy-elves session tag list <sessionId> --json
   happy-elves session history --machine <machineId> [--cwd <path>] [--agent <agent>] [--include-archived] [--limit 20] --json
   happy-elves session continue <runtimeSessionId> --machine <machineId> [--name <name>] --json
   happy-elves session status <sessionId> [--verbose] [--json]
+  happy-elves session diagnose <sessionId> [--limit 200] [--runtime-limit 500] [--repair-head] [--json]
+  happy-elves session repair-binding <sessionId> [--runtime-session <runtimeSessionId>] [--runtime-limit 500] [--keep-source] --json
   happy-elves session close <sessionId> [--reason <reason>] --json
 
 Session management:
@@ -59,22 +65,32 @@ Session management:
   history hides archived provider sessions unless --include-archived is set.
   continue turns a runtime history row into a loaded session, or returns the
   existing loaded session if it already exists.
+  diagnose reports the selected session's runtime handle metadata, backfill
+  counters, and latest materialized relay page counts for debugging empty or
+  stale transcripts. --repair-head advances a stale canonical head to the
+  latest completed relay event when the relay already has the event basis.
+  repair-binding imports the matching runtime history row as a new loaded
+  session and closes the empty/stale source session unless --keep-source is set.
   close archives a loaded session. There is no separate archive command.
 `,
     turn: `Usage:
   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] [--runtime-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 reconcile <sessionId> [turnId] --json
+  happy-elves turn recover <sessionId> [turnId] --text <continuation> --confirm-risk [--detach] --json
   happy-elves turn cancel <sessionId> <turnId> [--reason <reason>] --json
   happy-elves turn rewind <sessionId> <turn-or-checkpoint-id> --json
-  happy-elves turn fork <sessionId> <turn-or-checkpoint-id> --name <name> --json
+  happy-elves turn fork <sessionId> <turn-or-checkpoint-id> --name <name> [--copy-tags] --json
 
 Turn management:
   run starts one agent execution. It waits by default; use --detach for
   background execution.
   wait/result inspect a specific turn.
+  reconcile checks provider state without starting, resuming, or cancelling work.
+  recover creates a risk-confirmed recovery session and only sends the new continuation.
   rewind/fork operate on a turn or checkpoint id supplied by runtime history.
 `,
     collect: `Usage:
@@ -84,6 +100,71 @@ Turn management:
   happy-elves token create [--name <name>] [--machines a,b] [--sessions a,b] [--loops a,b] --actions a,b [--expires-in 24h] --json
   happy-elves token list [--verbose] [--json]
   happy-elves token revoke <tokenId> --json
+`,
+    workspace: `Usage:
+  happy-elves workspace state --json
+  happy-elves workspace star <sessionId> --json
+  happy-elves workspace unstar <sessionId> --json
+  happy-elves workspace recent <sessionId> --json
+  happy-elves workspace pin-cwd --machine <machineId> --cwd <cwd> [--label <label>] --json
+  happy-elves workspace unpin-cwd --machine <machineId> --cwd <cwd> --json
+  happy-elves workspace prefer --project <projectKey> [--machine <machineId>] [--cwd <cwd>] [--agent <agent>] --json
+
+Workspace sync records account-level UI/library state shared across devices:
+session stars, recent sessions, pinned workspaces, and current project defaults.
+`,
+    gateway: `Usage:
+  happy-elves gateway enable [<channelId>] --channel lark --machine <machineId> (--cwd <cwd> | --session <sessionId>) [--agent codex] [--model <model>] --json
+  happy-elves gateway enable lark-main --channel lark --machine <machineId> (--cwd <cwd> | --session <sessionId>) --app-id <appId> --app-secret-stdin [--domain feishu|lark] [--inbound mention|all] (--allow-any-sender | --allow-chat <id[,id]> | --allow-sender <id[,id]>) --json
+  happy-elves gateway disable [<channelId>] [--machine <machineId>] --json
+  happy-elves gateway status [--machine <machineId>] [--include-debug] [--json]
+  happy-elves gateway test [<channelId>] [--machine <machineId>] --conversation <externalConversationId> --message-id <externalMessageId> --text <prompt> --json
+  happy-elves gateway notify [<channelId>] [--machine <machineId>] --conversation <externalConversationId> [--message-id <id>] --text <message> --json
+  happy-elves gateway serve [--host 127.0.0.1] [--port 8789] --json  # debug only
+
+Gateway v1 official Feishu/Lark path is daemon-backed SDK long connection.
+App secrets are read from stdin and stored only in the target daemon config.
+Lark/Feishu product gateways require an explicit inbound sender/chat policy.
+gateway serve is kept for fake/local debugging only; lark-cli is not a product dependency.
+`,
+    memory: `Usage:
+  happy-elves memory overview [--machine <machineId>] [--project <projectKey>] [--cwd <cwd>] --json
+  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
+
+Memory uses daemon-local Markdown files: USER.md, MEMORY.md, and memory/YYYY-MM-DD.md.
+Session prompts can run memory off, readonly, or readwrite; readwrite writes daily notes.
+`,
+    schedule: `Usage:
+  happy-elves schedule create [--session <sessionId> | --cwd <cwd> --agent codex] (--manual | --at <iso-time> | --every 5m | --cron "*/30 * * * *") (--prompt <text> | --prompt-file <path>) [--execution continue|isolated] [--memory inherit|off|readonly|readwrite] [--name <name>] [--machine <machineId>] --json
+  happy-elves schedule list [--machine <machineId>] --json
+  happy-elves schedule show <scheduleId> [--machine <machineId>] --json
+  happy-elves schedule history <scheduleId> [--machine <machineId>] --json
+  happy-elves schedule run <scheduleId> [--machine <machineId>] --json
+  happy-elves schedule pause <scheduleId> [--machine <machineId>] --json
+  happy-elves schedule resume <scheduleId> [--machine <machineId>] --json
+  happy-elves schedule delete <scheduleId> [--machine <machineId>] --json
+  happy-elves schedule run-due [--machine <machineId>] --json
+  happy-elves schedule run-missed <scheduleId> <occurrenceId> [--machine <machineId>] --json
+
+Schedule v1 is daemon-local repeat automation. Runs use normal Relay admission
+with deterministic requestId/turnId per occurrence. Offline due times are marked
+missed and are never auto-caught-up. Commands that take a scheduleId auto-locate
+the owning online daemon when --machine is omitted.
+`,
+    release: `Usage:
+  happy-elves release profile list --json
+  happy-elves release profile show [--profile happy-elves] --json
+  happy-elves release profile set <name> --release-tag <tag[,tag]> [--reviewer-tag <tag[,tag]>] [--dogfood-tag <tag[,tag]>] --json
+  happy-elves release resolve --profile happy-elves --json
+  happy-elves release notify --profile happy-elves [--text 发布] [--detach] [--timeout 30m] --json
+
+Release routing uses session tags. notify only sends a short prompt to the
+resolved Release Session; it does not run a release runner or arbitrary shell.
 `,
     loop: `Usage:
   happy-elves loop create <sessionId> [--every 15m] (--prompt <text> | --prompt-file <path>) [--stop-on blocked] --json
@@ -95,7 +176,7 @@ Turn management:
   happy-elves loop delete <loopId> --json
 `,
     daemon: `Usage:
-  happy-elves daemon pair --relay <url> --code <code> --secret <account-secret> [--name <machine-name>] --json
+  happy-elves daemon pair --relay <url> --code <code> --secret <account-secret> [--name <machine-name>] [--no-start] --json
   happy-elves daemon start [--relay <url>] [--json]
   happy-elves daemon stop [--json]
   happy-elves daemon restart [--relay <url>] [--json]
@@ -108,6 +189,12 @@ Turn management:
   happy-elves relay serve [--host 0.0.0.0] [--port 8787] --json
   happy-elves relay status [--relay <url>] [--json]
   happy-elves relay doctor [--relay <url>] [--json]
+  happy-elves relay audit-db --path <relay.db> [--output <dir>] --json
+
+  audit-db is the pre-migration data protection gate. It creates a consistent
+  SQLite backup with VACUUM INTO and writes a manifest with row hashes for raw
+  session events, turn aliases, message/turn ids, ciphertext metadata, stars,
+  handoff tables, preferences, workspace sync tables, and unknown tables.
 `,
 };
 export function commandUsageText(command) {
@@ -136,23 +223,45 @@ Core commands:
   session create --machine <machineId> [--agent codex] [--cwd <path>] [--name <name>] --json
   session history --machine <machineId> [--cwd <path>] [--limit 20] --json
   session continue <runtimeSessionId> --machine <machineId> --json
+  session repair-binding <sessionId> [--runtime-session <runtimeSessionId>] --json
   session status <sessionId> [--verbose] [--json]
+  session diagnose <sessionId> [--limit 200] [--runtime-limit 500] [--repair-head] [--json]
   session close <sessionId> [--reason <reason>] --json
+  session tag add <sessionId> --tag <tag> --json
+  release resolve --profile happy-elves --json
+  release notify --profile happy-elves --json
 
   turn list <sessionId> [--limit 10] [--json]
   turn status <sessionId> <turnId> [--json]
   turn run <sessionId> --text <prompt> [--timeout 1000s] [--json]
   turn wait <sessionId> <turnId> [--timeout 1000s] [--json]
   turn result <sessionId> [<turnId>] [--json]
+  turn reconcile <sessionId> [turnId] --json
+  turn recover <sessionId> [turnId] --text <continuation> --confirm-risk [--json]
   turn cancel <sessionId> <turnId> [--reason <reason>] --json
   turn rewind <sessionId> <turn-or-checkpoint-id> --json
-  turn fork <sessionId> <turn-or-checkpoint-id> --name <name> --json
+  turn fork <sessionId> <turn-or-checkpoint-id> --name <name> [--copy-tags] --json
 
   remote status --json
   remote devices [--json]
   remote invite-controller [--device-name <name>] [--ttl 10m] --json
   remote join-controller --url <url> [--device-name <name>] --json
 
+  workspace state --json
+  workspace star <sessionId> --json
+  workspace pin-cwd --machine <machineId> --cwd <cwd> --json
+
+  gateway status --json
+  gateway enable --channel fake --machine <machineId> --cwd <cwd> --json  # debug only
+  gateway test --conversation <id> --message-id <id> --text <prompt> --json
+  gateway notify --conversation <id> --text <message> --json
+
+  memory save --project <key> --text <fact> --json
+  memory search --project <key> --query <prompt> --json
+
+  schedule create --session <sessionId> --at <iso-time> --prompt <prompt> --json
+  schedule run-due --json
+
   relay serve [--host 0.0.0.0] [--port 8787] [--json]
   relay status [--relay <url>] [--json]
   relay doctor [--relay <url>] [--json]
@@ -171,7 +280,7 @@ Common flows:
 More:
   happy-elves --skill
   happy-elves <domain> --help
-  start, status, doctor, collect, config, account, daemon, relay, token, loop.
+  start, status, doctor, collect, config, account, daemon, relay, token, workspace, gateway, memory, schedule, loop.
 `;
 }
 export function skillText() {
@@ -211,6 +320,9 @@ Session management:
   provider sessions unless --include-archived is set.
   session continue <runtimeSessionId> --machine <machineId> --json continues a
   runtime history row as a loaded session, or returns an existing sessionId.
+  session repair-binding <sessionId> --json recovers a loaded session that was
+  bound to the wrong/empty provider history by importing the matching runtime
+  history row as a new loaded session.
   session close <sessionId> --reason "archived" --json archives a loaded
   session. There is no separate archive command.
 
@@ -221,8 +333,9 @@ Output modes:
   not raw metadata or event streams.
   Add --verbose to status, list, history, turn list, or collect when internal
   details are needed for debugging.
-  turn run waits for completion by default with a 1000s timeout. Use --detach
-  only when you intentionally want background execution.
+  turn run waits for completion by default with a 1000s client wait timeout. The
+  runtime inactivity watchdog does not limit total runtime and does not cancel
+  provider work.
 
 Security notes:
   Account secrets stay on controllers and daemons.

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

@@ -1,5 +1,5 @@
-import type { ControllerClient } from "@happy-elves/client";
-import type { HistoricalSessionSnapshot } from "@happy-elves/shared";
+import type { ControllerClient } from "../../../../../packages/client/dist/index.js";
+import type { HistoricalSessionSnapshot } from "../../../../../packages/shared/dist/index.js";
 export type WorkspaceHistoricalSession = HistoricalSessionSnapshot & {
     machineId: string;
     machineName: string;