@cydm/happy-elves 0.1.0-beta.82 → 0.1.0-beta.83

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

@@ -57,9 +57,13 @@ export async function handleDaemon({ domain, action, flags }) {
             for (const check of checks) {
                 console.log(`${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`);
             }
+            if (!data.ok)
+                process.exitCode = 1;
             return true;
         }
-        ok("daemon.doctor", data);
+        if (!data.ok)
+            process.exitCode = 1;
+        ok("daemon.doctor", data, {}, data.ok);
         return true;
     }
     if (domain === "daemon" && action === "config") {

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

@@ -1,71 +1,98 @@
 import { createHash } from "node:crypto";
 import { createServer } from "node:http";
 import { encryptJson } from "../../../../packages/shared/dist/index.js";
-import { CliError, ControllerClient, ok, readConfig, readGatewayStore, redactedGatewayChannel, requireString, updateGatewayStore, wantsJson, } from "./lib/index.js";
+import { CliError, ControllerClient, ok, readConfig, readGatewayStore, requireString, updateGatewayStore, wantsJson, } from "./lib/index.js";
 export async function handleGateway({ domain, action, positional, flags }) {
     if (domain !== "gateway")
         return false;
     if (action === "enable") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
         const type = gatewayChannelType(typeof flags.channel === "string" ? flags.channel : "fake");
         const id = gatewayChannelId(flags, positional[0], type);
         const targetMachineId = requireString(flags, "machine");
-        const targetCwd = requireString(flags, "cwd");
+        const targetCwd = typeof flags.cwd === "string" ? flags.cwd : undefined;
+        const targetSessionId = typeof flags.session === "string" ? flags.session : undefined;
+        if (!targetCwd && !targetSessionId)
+            throw new CliError("Gateway enable requires --cwd or --session", "MISSING_ARGUMENT");
         const defaultAgent = typeof flags.agent === "string" ? flags.agent : "codex";
         const defaultModel = typeof flags.model === "string" ? flags.model : undefined;
-        const localToken = typeof flags.token === "string" ? flags.token : undefined;
-        const localSecret = typeof flags.secret === "string" ? flags.secret : undefined;
-        if (type === "lark" && (!localToken || !localSecret)) {
-            throw new CliError("Lark gateway requires --token and --secret; they are stored only in the local gateway config.", "MISSING_ARGUMENT");
+        const appId = typeof flags["app-id"] === "string" ? flags["app-id"] : undefined;
+        const appSecret = flags["app-secret-stdin"] === true ? await readSecretFromStdin() : undefined;
+        const domainValue = typeof flags.domain === "string" ? flags.domain : "feishu";
+        if (domainValue !== "feishu" && domainValue !== "lark")
+            throw new CliError("Gateway --domain must be feishu or lark", "INVALID_ARGUMENT");
+        const inboundMode = typeof flags.inbound === "string" ? flags.inbound : "mention";
+        if (inboundMode !== "mention" && inboundMode !== "all")
+            throw new CliError("Gateway --inbound must be mention or all", "INVALID_ARGUMENT");
+        const reactionEmoji = typeof flags["reaction-emoji"] === "string" ? flags["reaction-emoji"] : "Typing";
+        const allowedChatIds = csvFlag(flags["allow-chat"]);
+        const allowedSenderIds = csvFlag(flags["allow-sender"]);
+        const allowAnySender = flags["allow-any-sender"] === true;
+        if (type === "lark" && (!appId || !appSecret)) {
+            throw new CliError("Lark gateway requires --app-id and --app-secret-stdin; appSecret is stored only in the target daemon config.", "MISSING_ARGUMENT");
         }
-        const now = new Date().toISOString();
-        const store = await updateGatewayStore((current) => {
-            const existing = current.channels.find((item) => item.id === id);
-            const next = {
-                ...(existing ?? { createdAt: now }),
+        if (type === "lark" && !allowAnySender && allowedChatIds.length === 0 && allowedSenderIds.length === 0) {
+            throw new CliError("Lark gateway requires --allow-any-sender or at least one --allow-chat/--allow-sender policy.", "MISSING_ARGUMENT");
+        }
+        if (type === "lark" && (typeof flags.token === "string" || typeof flags.secret === "string")) {
+            throw new CliError("Lark gateway no longer accepts --token/--secret; use --app-id and --app-secret-stdin.", "INVALID_ARGUMENT");
+        }
+        const result = await client.gateway({
+            machineId: targetMachineId,
+            action: "upsert",
+            channel: {
                 id,
                 type,
                 enabled: true,
                 targetMachineId,
+                targetSessionId,
                 targetCwd,
                 defaultAgent,
                 ...(defaultModel ? { defaultModel } : {}),
-                ...(localToken ? { localToken } : existing?.localToken ? { localToken: existing.localToken } : {}),
-                ...(localSecret ? { localSecret } : existing?.localSecret ? { localSecret: existing.localSecret } : {}),
-                updatedAt: now,
-            };
-            return {
-                ...current,
-                channels: [next, ...current.channels.filter((item) => item.id !== id)],
-            };
+                ...(type === "lark" ? {
+                    domain: domainValue,
+                    appId,
+                    appSecret,
+                    inboundMode,
+                    allowAnySender,
+                    ...(allowedChatIds.length > 0 ? { allowedChatIds } : {}),
+                    ...(allowedSenderIds.length > 0 ? { allowedSenderIds } : {}),
+                    processingReaction: {
+                        enabled: flags["disable-reaction"] !== true,
+                        emojiType: reactionEmoji,
+                    },
+                } : {}),
+            },
         });
-        const channel = mustFindChannel(store, id);
-        ok("gateway.enable", { channel: redactedGatewayChannel(channel) });
+        ok("gateway.enable", { channel: result.channel });
         return true;
     }
     if (action === "disable") {
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const machineId = await resolveGatewayMachineId(client, flags);
         const id = gatewayChannelId(flags, positional[0], "fake");
-        const now = new Date().toISOString();
-        const store = await updateGatewayStore((current) => ({
-            ...current,
-            channels: current.channels.map((channel) => channel.id === id ? { ...channel, enabled: false, updatedAt: now } : channel),
-        }));
-        const channel = mustFindChannel(store, id);
-        ok("gateway.disable", { channel: redactedGatewayChannel(channel) });
+        const result = await client.gateway({ machineId, action: "disable", channelId: id });
+        ok("gateway.disable", { channel: result.channel });
         return true;
     }
     if (action === "status") {
-        const store = await readGatewayStore();
-        const data = {
-            channels: store.channels.map(redactedGatewayChannel),
-            mappings: store.mappings,
-        };
+        const config = await readConfig(flags);
+        const client = new ControllerClient(config);
+        const machineId = await resolveGatewayMachineId(client, flags);
+        const result = await client.gateway({ machineId, action: "list" });
+        const includeDebug = flags["include-debug"] === true;
+        const channels = (result.channels ?? []).filter((channel) => includeDebug || channel.type === "lark");
+        const data = { machineId, channels };
         if (!wantsJson(flags)) {
             if (data.channels.length === 0) {
-                console.log("No gateways configured.");
+                console.log(includeDebug ? "No gateways configured." : "No product gateways configured.");
                 return true;
             }
             for (const channel of data.channels) {
-                console.log(`${channel.id}  ${channel.type}  ${channel.enabled ? "enabled" : "disabled"}  ${channel.targetMachineId}  ${channel.targetCwd}`);
+                const target = channel.targetSessionId ? `session:${channel.targetSessionId}` : channel.targetCwd ?? "";
+                console.log(`${channel.id}  ${channel.type}  ${channel.enabled ? "enabled" : "disabled"}  ${target}  ${channel.listening ? "listening" : "stopped"}`);
             }
             return true;
         }
@@ -75,13 +102,19 @@ export async function handleGateway({ domain, action, positional, flags }) {
     if (action === "test") {
         const config = await readConfig(flags);
         const client = new ControllerClient(config);
+        const machineId = await resolveGatewayMachineId(client, flags);
         const channelId = gatewayChannelId(flags, positional[0], "fake");
         const externalConversationId = requireString(flags, "conversation");
         const externalMessageId = requireString(flags, "message-id");
         const text = requireString(flags, "text");
-        const store = await readGatewayStore();
-        const channel = mustFindEnabledChannel(store, channelId);
-        const result = await deliverGatewayMessage({ store, channel, client, accountSecret: config.accountSecret, externalConversationId, externalMessageId, text });
+        const result = await client.gateway({
+            machineId,
+            action: "test",
+            channelId,
+            externalConversationId,
+            externalMessageId,
+            text,
+        });
         ok("gateway.test", result);
         return true;
     }
@@ -337,6 +370,31 @@ function gatewayChannelType(value) {
 function gatewayChannelId(flags, positional, fallbackType) {
     return positional || (typeof flags.name === "string" ? flags.name : undefined) || (typeof flags.channel === "string" ? flags.channel : fallbackType);
 }
+function csvFlag(value) {
+    if (typeof value !== "string")
+        return [];
+    return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+async function readSecretFromStdin() {
+    let value = "";
+    process.stdin.setEncoding("utf8");
+    for await (const chunk of process.stdin) {
+        value += chunk;
+    }
+    const secret = value.trim();
+    if (!secret)
+        throw new CliError("--app-secret-stdin was set but stdin was empty", "MISSING_ARGUMENT");
+    return secret;
+}
+async function resolveGatewayMachineId(client, flags) {
+    if (typeof flags.machine === "string" && flags.machine.length > 0)
+        return flags.machine;
+    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;
+}
 function mustFindChannel(store, id) {
     const channel = store.channels.find((item) => item.id === id);
     if (!channel)

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

@@ -2,22 +2,32 @@ import { parseFlags as parseSharedFlags } from "../../../../../packages/shared/d
 import { CliError } from "../../errors.js";
 const valueFlags = new Set([
     "agent",
+    "app-id",
     "at",
     "channel",
     "code",
     "conversation",
+    "cron",
     "controller",
     "cwd",
+    "date",
     "device-id",
     "device-name",
+    "every-ms",
+    "execution",
     "from",
     "host",
+    "domain",
     "invite-secret",
+    "inbound",
     "join-url-base",
     "label",
+    "layer",
     "limit",
     "machine",
     "machine-id",
+    "memory",
+    "memory-mode",
     "message-id",
     "memory-project",
     "memory-top-n",
@@ -35,6 +45,7 @@ const valueFlags = new Set([
     "prompt-file",
     "every",
     "reason",
+    "reaction-emoji",
     "relay",
     "root",
     "runtime-limit",
@@ -56,6 +67,7 @@ const valueFlags = new Set([
     "text-file",
     "timeout",
     "timeout-ms",
+    "timezone",
     "wait-timeout-ms",
     "inactivity-timeout",
     "runtime-timeout",
@@ -69,10 +81,14 @@ const valueFlags = new Set([
 ]);
 const booleanFlags = new Set([
     "all",
+    "allow-any-sender",
+    "app-secret-stdin",
     "detach",
+    "disable-reaction",
     "help",
     "h",
     "include-archived",
+    "include-debug",
     "json",
     "keep-source",
     "local",
@@ -82,6 +98,7 @@ const booleanFlags = new Set([
     "summary",
     "verbose",
     "wait",
+    "manual",
 ]);
 const knownFlags = new Set([...valueFlags, ...booleanFlags]);
 const dashPrefixedValueFlags = new Set(["secret"]);

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

@@ -1,49 +1,171 @@
 import path from "node:path";
+import cliPackage from "../../../package.json" with { type: "json" };
+import { ControllerClient } from "../../../../../packages/client/dist/index.js";
 import { configDir, configPath } from "./paths.js";
 import { redactedControllerConfig, redactedDaemonConfig } from "./config.js";
 import { ok, wantsJson } from "./json.js";
-import { localDaemonStatus } from "./local-daemon.js";
+import { daemonBinaryUpdatedAfterStart, localDaemonStatus } from "./local-daemon.js";
 import { readExistingControllerConfig, readExistingDaemonConfig, relayHealth } from "./relay-http.js";
 import { startRelayUrl } from "./bootstrap-config.js";
 export async function topLevelDoctor(flags) {
+    const strict = flags.strict === true;
     const checks = [];
     const existingController = await readExistingControllerConfig().catch((error) => {
-        checks.push({ name: "controller-config", ok: false, message: error instanceof Error ? error.message : String(error) });
+        checks.push({
+            name: "controller-config",
+            ok: false,
+            severity: "error",
+            layer: "compatible",
+            message: error instanceof Error ? error.message : String(error),
+        });
         return undefined;
     });
     if (existingController) {
-        checks.push({ name: "controller-config", ok: true, message: configPath, details: redactedControllerConfig(existingController) });
+        checks.push({
+            name: "controller-config",
+            ok: true,
+            severity: "info",
+            layer: "compatible",
+            message: configPath,
+            details: redactedControllerConfig(existingController),
+        });
     }
     const relay = startRelayUrl(flags, existingController);
+    let relayReachable = false;
     try {
         const health = await relayHealth(relay.relayUrl);
+        relayReachable = health.ok;
         checks.push({
             name: "relay",
             ok: health.ok,
+            severity: health.ok ? "info" : "error",
+            layer: "compatible",
             message: health.ok ? "reachable" : `HTTP ${health.status}`,
             details: { relayUrl: relay.relayUrl, body: health.body },
         });
     }
     catch (error) {
-        checks.push({ name: "relay", ok: false, message: error instanceof Error ? error.message : String(error), details: { relayUrl: relay.relayUrl } });
+        checks.push({
+            name: "relay",
+            ok: false,
+            severity: "error",
+            layer: "compatible",
+            message: error instanceof Error ? error.message : String(error),
+            details: { relayUrl: relay.relayUrl },
+        });
+    }
+    let snapshot;
+    if (existingController && relayReachable) {
+        try {
+            snapshot = await new ControllerClient({ ...existingController, relayUrl: relay.relayUrl }).snapshot();
+            checks.push({
+                name: "controller-snapshot",
+                ok: true,
+                severity: "info",
+                layer: "compatible",
+                message: "controller token accepted",
+                details: { machines: snapshot.machines.length, sessions: snapshot.sessions.length },
+            });
+        }
+        catch (error) {
+            checks.push({
+                name: "controller-snapshot",
+                ok: false,
+                severity: "error",
+                layer: "compatible",
+                message: error instanceof Error ? error.message : String(error),
+                details: { relayUrl: relay.relayUrl },
+            });
+        }
     }
     const existingDaemon = await readExistingDaemonConfig().catch((error) => {
-        checks.push({ name: "daemon-config", ok: false, message: error instanceof Error ? error.message : String(error) });
+        checks.push({
+            name: "daemon-config",
+            ok: false,
+            severity: "error",
+            layer: "compatible",
+            message: error instanceof Error ? error.message : String(error),
+        });
         return undefined;
     });
     if (existingDaemon) {
-        checks.push({ name: "daemon-config", ok: true, message: path.join(configDir, "daemon.json"), details: redactedDaemonConfig(existingDaemon) });
+        checks.push({
+            name: "daemon-config",
+            ok: true,
+            severity: "info",
+            layer: "compatible",
+            message: path.join(configDir, "daemon.json"),
+            details: redactedDaemonConfig(existingDaemon),
+        });
     }
     const local = await localDaemonStatus();
-    checks.push({ name: "daemon-process", ok: local.running, message: local.running ? "running" : "not running", details: local });
+    checks.push({
+        name: "daemon-process",
+        ok: local.running,
+        severity: local.running ? "info" : "error",
+        layer: "compatible",
+        message: local.running ? "running" : "not running",
+        details: local,
+    });
+    const binaryStale = await daemonBinaryUpdatedAfterStart(local);
+    checks.push({
+        name: "daemon-binary-alignment",
+        ok: !binaryStale,
+        severity: binaryStale ? "warning" : "info",
+        layer: "aligned",
+        message: binaryStale ? "daemon binary changed after daemon start; restart daemon to align" : "daemon binary is not newer than running daemon",
+    });
+    if (existingDaemon && snapshot) {
+        const daemonMachine = snapshot.machines.find((machine) => machine.id === existingDaemon.machineId);
+        const daemonVersion = daemonMachine?.capabilities.daemonVersion;
+        const aligned = !daemonVersion || daemonVersion === cliPackage.version;
+        checks.push({
+            name: "cli-daemon-version-alignment",
+            ok: aligned,
+            severity: aligned ? "info" : "warning",
+            layer: "aligned",
+            message: aligned
+                ? "CLI and daemon package versions are aligned or daemon version is unavailable"
+                : `CLI ${cliPackage.version} differs from daemon ${daemonVersion}`,
+            details: { cliVersion: cliPackage.version, daemonVersion, machineId: existingDaemon.machineId },
+        });
+    }
+    const compatible = checks.filter((check) => check.layer === "compatible" && check.severity === "error").every((check) => check.ok);
+    const aligned = checks.filter((check) => check.layer === "aligned" && check.severity === "warning").every((check) => check.ok);
+    const warnings = checks.filter((check) => !check.ok && check.severity === "warning").map((check) => ({
+        name: check.name,
+        message: check.message,
+        details: check.details,
+    }));
+    const healthy = compatible && (strict ? aligned : true);
     if (wantsJson(flags)) {
-        ok("doctor", { ok: checks.every((check) => check.ok), checks });
+        if (!healthy)
+            process.exitCode = 1;
+        ok("doctor", { ok: healthy, compatible, aligned, strict, warnings, checks }, {}, healthy);
         return;
     }
-    const allOk = checks.every((check) => check.ok);
-    console.log(`Happy Elves doctor: ${allOk ? "ok" : "issues found"}`);
+    console.log(`Happy Elves doctor: ${healthy ? "ok" : "issues found"}`);
+    console.log(`compatible: ${compatible ? "yes" : "no"}`);
+    console.log(`aligned: ${aligned ? "yes" : "no"}${strict ? " (strict)" : ""}`);
+    const failures = checks.filter((check) => !check.ok && check.severity === "error");
+    if (failures.length > 0)
+        console.log("Failures:");
+    for (const check of failures) {
+        console.log(`fail ${check.name}: ${check.message}`);
+    }
+    const warningChecks = checks.filter((check) => !check.ok && check.severity === "warning");
+    if (warningChecks.length > 0)
+        console.log("Warnings:");
+    for (const check of warningChecks) {
+        console.log(`warn ${check.name}: ${check.message}`);
+    }
+    if (failures.length === 0 && warningChecks.length === 0)
+        console.log("Checks:");
     for (const check of checks) {
-        console.log(`${check.ok ? "ok" : "fail"} ${check.name}: ${check.message}`);
+        if (check.ok)
+            console.log(`ok ${check.name}: ${check.message}`);
     }
+    if (!healthy)
+        process.exitCode = 1;
 }
 //# sourceMappingURL=doctor.js.map

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

@@ -1,5 +1,5 @@
 import type { JsonEnvelope } from "../../../../../packages/shared/dist/index.js";
-export declare function ok<T>(type: string, data: T, meta?: JsonEnvelope["meta"]): void;
+export declare function ok<T>(type: string, data: T, meta?: JsonEnvelope["meta"], success?: boolean): void;
 export declare function writeError(code: string, message: string, meta?: JsonEnvelope["meta"], capability?: string): void;
 export declare function wantsJson(flags: Record<string, string | boolean>): boolean;
 export declare function wantsVerbose(flags: Record<string, string | boolean>): boolean;

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

@@ -1,5 +1,8 @@
-export function ok(type, data, meta = {}) {
-    console.log(JSON.stringify({ ok: true, type, data, meta }, null, 2));
+export function ok(type, data, meta = {}, success = true) {
+    const envelope = success
+        ? { ok: true, type, data, meta }
+        : { ok: false, type, data, meta };
+    console.log(JSON.stringify(envelope, null, 2));
 }
 export function writeError(code, message, meta = {}, capability) {
     console.error(JSON.stringify({

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/usage.js

@@ -107,43 +107,42 @@ 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 fake|lark --machine <machineId> --cwd <cwd> [--agent codex] [--model <model>] [--token <token>] [--secret <secret>] --json
-  happy-elves gateway disable [<channelId>] --json
-  happy-elves gateway status [--json]
-  happy-elves gateway test [<channelId>] --conversation <externalConversationId> --message-id <externalMessageId> --text <prompt> --json
-  happy-elves gateway serve [--host 127.0.0.1] [--port 8789] --json
+  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] --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 serve [--host 127.0.0.1] [--port 8789] --json  # debug only
 
-Gateway v1 is a thin local entrypoint from external messages into Happy Elves
-session create/send. Channel token/secret values stay in the local gateway
-config; Relay only receives normal encrypted session and prompt admissions.
+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.
+gateway serve is kept for fake/local debugging only; lark-cli is not a product dependency.
 `,
     memory: `Usage:
-  happy-elves memory save --project <projectKey> (--text <text> | --text-file <path>) [--title <title>] [--tags a,b] --json
-  happy-elves memory list [--project <projectKey>] [--verbose] [--json]
-  happy-elves memory search --project <projectKey> --query <text> [--limit 5] --json
-  happy-elves memory delete <memoryId> --json
-  happy-elves memory status [--project <projectKey>] --json
-  happy-elves memory enable --project <projectKey> --json
-  happy-elves memory disable --project <projectKey> --json
-  happy-elves memory enable-injection --project <projectKey> --json
-  happy-elves memory disable-injection --project <projectKey> --json
+  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 reindex [--project <projectKey>] --json
+  happy-elves memory sync [--project <projectKey>] --json
 
-Memory v1 is explicit. It never writes automatically. Relay stores encrypted
-memory envelopes; search runs after local controller-side decryption.
+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> --at <iso-time> (--prompt <text> | --prompt-file <path>) [--name <name>] --json
-  happy-elves schedule list --json
-  happy-elves schedule show <scheduleId> --json
-  happy-elves schedule history <scheduleId> --json
-  happy-elves schedule pause <scheduleId> --json
-  happy-elves schedule resume <scheduleId> --json
-  happy-elves schedule delete <scheduleId> --json
-  happy-elves schedule run-due --json
-  happy-elves schedule run-missed <scheduleId> <occurrenceId> --json
+  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 explicit one-shot prompt scheduling. Due runs use normal Relay
-admission with deterministic requestId/turnId. Offline targets are marked
+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.
 `,
     loop: `Usage:
@@ -227,7 +226,7 @@ Core commands:
   workspace pin-cwd --machine <machineId> --cwd <cwd> --json
 
   gateway status --json
-  gateway enable --channel fake --machine <machineId> --cwd <cwd> --json
+  gateway enable --channel fake --machine <machineId> --cwd <cwd> --json  # debug only
   gateway test --conversation <id> --message-id <id> --text <prompt> --json
 
   memory save --project <key> --text <fact> --json