@amoree-code/ocean 0.0.0-stage → 1.1.0

package/dist/interfaces/cli/command-registry.js

@@ -0,0 +1,1211 @@
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { learnFromSession } from "@ocean/brain/memory/lesson-learning.js";
+import { addLesson, effectiveConfidence, listLessons, migrateLegacyLessons, readLesson, setLessonStatus, } from "@ocean/brain/memory/lessons.js";
+import { promoteSessionToKnowledge } from "@ocean/brain/memory/session-promotion.js";
+import { classifyIntent } from "@ocean/context/context/intent-router.js";
+import { resolveProfileName } from "@ocean/core/domain/profiles/runtime-config.js";
+import { oceanEnv, oceanPath, oceanRoot, SYSTEM_DIR, } from "@ocean/core/shared/paths.js";
+import { autoRegisterProject, bindProject, findGitRoot, knownTaskPrefixes, listProjectBindings, migrateProjectBindings, moveProject, PROJECT_CATEGORIES, projectCategory, renameProject, renderProjectIndex, resolveProject, scanProjectManifests, unbindProjectPath, writeProjectIndex, } from "@ocean/core/shared/project-resolution.js";
+import { claudeSessionEndHook, isSessionEndClient, SESSION_END_CLIENTS, } from "@ocean/loop/hooks/session-end-hook.js";
+import { isSessionStartClient, readBoundedStdin, SESSION_START_CLIENTS, sessionStartHookForClient, } from "@ocean/loop/hooks/session-start-hook.js";
+import { openSessionStore } from "@ocean/loop/infrastructure/persistence/session-store.js";
+import { listTaskLoops, runTaskLoopsOnce, runTaskLoopWorker, startTaskLoop, stopTaskLoop, } from "@ocean/loop/loops/task-loop.js";
+import { resumeAgent, runAgent } from "@ocean/loop/runs/run-agent.js";
+import { applyRetention, DEFAULT_KEEP_DAYS, planRetention, simulateRetention, } from "@ocean/loop/sessions/session-retention.js";
+import { browserBridgeConfig } from "@ocean/market/mcp/browser-bridge.js";
+import { mcpClientConfig, oceanMcpConfig, playwrightMcpConfig, } from "@ocean/market/mcp/mcp-connection.js";
+import { GATEWAY_CAPABILITY } from "@ocean/market/mcp/mcp-gateway.js";
+import { coreSkillReports, syncCoreSkills, } from "@ocean/market/skills/core-skill-sync.js";
+import { copyClientSkills, linkClientSkills, populateSkillHub, } from "@ocean/market/skills/skill-hub.js";
+import { hasFailures, repairWorkspace, workspaceReport, } from "@ocean/services/doctor/workspace-doctor.js";
+import { runObsidianMcpServer } from "@ocean/services/infrastructure/mcp/obsidian-server.js";
+import { runOceanMcpServer } from "@ocean/services/infrastructure/mcp/ocean-server.js";
+import { parseConflictSide, resolveConflict, } from "@ocean/services/obsidian/conflict-log.js";
+import { listInboxCandidates, promoteInboxNote, } from "@ocean/services/obsidian/inbox-promotion.js";
+import { connectObsidianVault, discoverObsidianVault, loadObsidianConnection, } from "@ocean/services/obsidian/vault-discovery.js";
+import { syncObsidianVault, watchObsidianVault, } from "@ocean/services/obsidian/vault-sync.js";
+import { writeObsidianNote } from "@ocean/services/obsidian/vault-writer.js";
+import { clientFindings, repairClients, } from "../../application/clients/clients.js";
+import { nativeFindings } from "../../application/clients/native.js";
+import { createWebhookGateway } from "../../application/gateway/webhook-gateway.js";
+import { findInstallSpec, installPlan, installProvider, listInstallSpecs, removeInstalledProvider, updateProvider, } from "../../application/install/provider-installer.js";
+import { syncCharterCopies } from "../../application/integrations/charter-copies.js";
+import { configureClaudeCodeWrapper } from "../../application/integrations/claude-vscode.js";
+import { repairEngineEntries } from "../../application/integrations/engine-entry-repair.js";
+import { syncSkillFilter } from "../../application/integrations/skill-filter.js";
+import { selectProfileForTask } from "../../application/profiles/profile-suggestion.js";
+import { listSchedules, runDueSchedules, runSchedule, runSchedulerWorker, runSchedulerWorkerOnce, saveSchedule, setScheduleEnabled, } from "../../application/scheduler/local-scheduler.js";
+import { defaultAgentRuntime, defaultBrainIndexPort, defaultProviderRegistry, defaultSessionStoreFactory, defaultSessionStoreOpener, defaultWrapperManager, } from "../../composition/runtime.js";
+import { loadRuntimeConfig } from "../../infrastructure/filesystem/runtime-config-loader.js";
+import { ensureService, restartService, runService, startBackgroundPull, } from "../../infrastructure/process/service.js";
+import { createOllamaEmbedder } from "../../infrastructure/providers/ollama-embedder.js";
+import { loadProviderRegistry } from "../../infrastructure/providers/provider-registry.js";
+import { installShellPath, registerProvider, setProviderEnabled, syncProviderWrappers, wrapperDoctor, wrapperStatus, } from "../../infrastructure/wrappers/wrapper-manager.js";
+import { runAuthCommand } from "./auth-command.js";
+import { browserBridgeFindings, runBrowserBridgeCommand, runBrowserServiceCommand, } from "./browser-bridge-command.js";
+import { runBrowserCommand } from "./browser-command.js";
+import { runCaptureCommand } from "./capture-command.js";
+import { runClientTestCommand } from "./client-test-command.js";
+import { runClientsCommand } from "./clients-command.js";
+import { runContextCommand, runContextCostCommand } from "./context-command.js";
+import { runDailyCommand } from "./daily-command.js";
+import { runLifecycleCommand, runPolicyCommand } from "./governance-command.js";
+import { runHandoffCommand } from "./handoff-command.js";
+import { runIdeaCommand } from "./idea-command.js";
+import { intercept } from "./intercept-command.js";
+import { runLayoutCommand } from "./layout-command.js";
+import { runMarketCommand } from "./market-command.js";
+import { runMcpGatewayCommand } from "./mcp-gateway-command.js";
+import { runMemoryCommand } from "./memory-command.js";
+import { runMigrateCommand } from "./migrate-command.js";
+import { runObserveCommand } from "./observe-command.js";
+import { manageClients, runOnboardCommand } from "./onboard-command.js";
+import { runOperateCommand } from "./operate-command.js";
+import { runProfilesCommand } from "./profiles-command.js";
+import { runPullCommand } from "./pull-command.js";
+import { parseSetupArgs, SETUP_USAGE, setup } from "./setup-command.js";
+import { runTasksCommand } from "./tasks-command.js";
+// brain_search over MCP uses vectors when the local embedder answers (T-307), and full text when
+// it does not; a working embedder is kept, a failure is retried on the next search.
+function mcpEmbedder() {
+    let ready = null;
+    return async () => {
+        if (!ready)
+            ready = await createOllamaEmbedder().catch(() => null);
+        return ready;
+    };
+}
+async function commandSetup() {
+    const parsed = parseSetupArgs(process.argv.slice(3));
+    if (parsed.kind === "help")
+        console.log(SETUP_USAGE);
+    else if (parsed.kind === "error") {
+        console.error(`${parsed.message}\n${SETUP_USAGE}`);
+        process.exitCode = 1;
+    }
+    else
+        await setup(parsed.options);
+}
+async function commandService() {
+    // `ocean service restart` (T-307): a new build reaches the service without unloading it.
+    if (process.argv[3] === "restart") {
+        const restarted = await restartService({ reload: false });
+        console.log(JSON.stringify({ service: restarted }, null, 2));
+        if (typeof restarted === "object")
+            process.exitCode = 1;
+        return;
+    }
+    const shutdownAfterMs = Number(oceanEnv("SERVICE_TEST_SHUTDOWN_MS"));
+    await runService(Number.isFinite(shutdownAfterMs) && shutdownAfterMs > 0
+        ? shutdownAfterMs
+        : undefined);
+}
+async function commandIntercept() {
+    const clientIndex = process.argv.indexOf("--client");
+    const executableIndex = process.argv.indexOf("--executable");
+    const separatorIndex = process.argv.indexOf("--");
+    const client = clientIndex >= 0 ? process.argv[clientIndex + 1] : "";
+    const args = separatorIndex >= 0 ? process.argv.slice(separatorIndex + 1) : [];
+    if (!client) {
+        console.error("Usage: ocean intercept --client <provider> -- [args]");
+        process.exitCode = 1;
+    }
+    else {
+        process.exitCode = await intercept(client, args, executableIndex >= 0
+            ? {
+                originalExecutable: process.argv[executableIndex + 1],
+                entryPoint: "desktop-wrapper",
+                controlLevel: "managed-partial",
+            }
+            : undefined);
+    }
+}
+async function commandClient() {
+    const action = process.argv[3] ?? "list";
+    if (action === "list") {
+        console.log(JSON.stringify(loadProviderRegistry(), null, 2));
+    }
+    else if (action === "open") {
+        const provider = process.argv[4];
+        if (!provider) {
+            console.error("Usage: ocean client open <provider> [provider-args]");
+            process.exitCode = 1;
+        }
+        else {
+            // After `--`, arguments go to the provider untouched (a help flag before it is Ocean's).
+            const rest = process.argv.slice(5);
+            const separator = rest.indexOf("--");
+            const providerArgs = separator >= 0 ? rest.slice(0, separator) : rest;
+            const passed = separator >= 0 ? rest.slice(separator + 1) : [];
+            const taskIndex = providerArgs.indexOf("--task");
+            const handoffIndex = providerArgs.indexOf("--handoff");
+            const taskId = taskIndex >= 0 ? providerArgs[taskIndex + 1] : undefined;
+            const handoffId = handoffIndex >= 0 ? providerArgs[handoffIndex + 1] : undefined;
+            const metadataFlags = new Set();
+            if (taskIndex >= 0) {
+                metadataFlags.add(taskIndex);
+                metadataFlags.add(taskIndex + 1);
+            }
+            if (handoffIndex >= 0) {
+                metadataFlags.add(handoffIndex);
+                metadataFlags.add(handoffIndex + 1);
+            }
+            process.exitCode = await intercept(provider, [
+                ...providerArgs.filter((_, index) => !metadataFlags.has(index)),
+                ...passed,
+            ], {
+                entryPoint: "interactive-managed",
+                controlLevel: "managed-partial",
+                taskId,
+                handoffId,
+            });
+        }
+    }
+    else if (action === "sync") {
+        const result = await syncProviderWrappers();
+        // Runs at every session start (the SessionStart hook calls `client sync`), so an edit
+        // to core.md reaches the clients that carry a copy without a manual step.
+        const charter = await syncCharterCopies();
+        const skillFilter = await syncSkillFilter();
+        const engineEntries = await repairEngineEntries();
+        // T-305: a repointed service start file only takes effect once the service restarts.
+        const service = engineEntries.some((repair) => repair.kind === "service" && repair.status === "updated")
+            ? await restartService()
+            : await ensureService();
+        // T-296: re-applies the `ocean` entry only for clients the owner approved with
+        // `ocean clients apply --yes`; never a client that was not approved.
+        const clients = await repairClients().catch((error) => ({
+            error: error instanceof Error ? error.message : String(error),
+        }));
+        console.log(JSON.stringify({
+            directory: result.directory,
+            providers: result.providers,
+            charter,
+            skillFilter,
+            engineEntries,
+            service,
+            clients,
+        }, null, 2));
+    }
+    else if (action === "register") {
+        const id = process.argv[4];
+        const provider = await registerProvider(id ?? "", process.argv[5] ?? id ?? "");
+        console.log(JSON.stringify(provider, null, 2));
+    }
+    else if (action === "enable" || action === "disable") {
+        const id = process.argv[4];
+        if (!id) {
+            console.error(`Usage: ocean client ${action} <provider>`);
+            process.exitCode = 1;
+        }
+        else {
+            const provider = await setProviderEnabled(id, action === "enable");
+            console.log(JSON.stringify(provider, null, 2));
+        }
+    }
+    else if (action === "manage") {
+        await manageClients();
+    }
+    else if (action === "doctor") {
+        const findings = await wrapperDoctor(process.argv[4]);
+        if (findings.length) {
+            findings.forEach((finding) => {
+                console.error(`NOT READY: ${finding}`);
+            });
+            process.exitCode = 1;
+        }
+        else {
+            console.log("PROVEN: Ocean wrappers are configured and provider binaries resolve outside the shim directory.");
+        }
+    }
+    else if (action === "status") {
+        console.log(JSON.stringify(await wrapperStatus(), null, 2));
+    }
+    else if (action === "vscode-wrapper") {
+        const settingsIndex = process.argv.indexOf("--settings");
+        const settingsPath = settingsIndex >= 0 ? process.argv[settingsIndex + 1] : undefined;
+        console.log(JSON.stringify(await configureClaudeCodeWrapper(defaultWrapperManager, settingsPath, process.argv.includes("--apply")), null, 2));
+    }
+    else if (action === "test") {
+        const provider = process.argv[4] === "--json" ? "" : (process.argv[4] ?? "");
+        await runClientTestCommand(provider, process.argv.includes("--json"));
+    }
+    else {
+        console.error("Usage: ocean client list|status|test [provider] [--json]|open <provider> [provider-args]|vscode-wrapper [--settings <path>] [--apply]|sync|register <id> [command]|enable <id>|disable <id>|manage|doctor [absolute-provider-path]");
+        process.exitCode = 1;
+    }
+}
+async function commandInstall() {
+    const id = process.argv[3];
+    if (!id) {
+        console.error("Usage: ocean install <client> [--yes]");
+        process.exitCode = 1;
+    }
+    else {
+        try {
+            const spec = findInstallSpec(id);
+            if (!process.argv.includes("--yes")) {
+                console.log(JSON.stringify({ approvalRequired: true, plan: installPlan(spec.provider.id) }, null, 2));
+                process.exitCode = 2;
+            }
+            else {
+                const result = await installProvider(spec.provider.id, true, defaultWrapperManager, defaultProviderRegistry);
+                console.log(JSON.stringify({
+                    installed: true,
+                    provider: result.provider,
+                    executable: result.executable,
+                }, null, 2));
+            }
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    }
+}
+async function commandAuth() {
+    await runAuthCommand(process.argv[3] ?? "", process.argv[4] ?? "");
+}
+async function commandTasks() {
+    await runTasksCommand(process.argv[3] ?? "", process.argv.slice(4));
+}
+async function commandPolicy() {
+    try {
+        await runPolicyCommand(process.argv[3] ?? "list");
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+async function commandMarket() {
+    try {
+        await runMarketCommand(process.argv[3] ?? "", process.argv.slice(4));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+async function commandLifecycle() {
+    await runLifecycleCommand(process.argv.slice(3));
+}
+async function commandObserve() {
+    try {
+        await runObserveCommand(process.argv.slice(3));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+async function commandLayout() {
+    try {
+        await runLayoutCommand(process.argv.slice(3));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+async function commandMigrate() {
+    await runMigrateCommand(process.argv.includes("--apply"));
+}
+async function commandMemory() {
+    await runMemoryCommand(process.argv[3] ?? "", process.argv.slice(4));
+}
+async function commandMcp() {
+    const action = process.argv[3] ?? "config";
+    if (action === "config")
+        console.log(JSON.stringify(oceanMcpConfig(), null, 2));
+    else if (action === "playwright-config")
+        console.log(JSON.stringify(playwrightMcpConfig(), null, 2));
+    else if (action === "gateway-config")
+        console.log(JSON.stringify(mcpClientConfig(GATEWAY_CAPABILITY), null, 2));
+    else if (action === "serve")
+        await runOceanMcpServer({
+            brainIndex: defaultBrainIndexPort,
+            sessionStoreFactory: defaultSessionStoreFactory,
+            wrapperManager: defaultWrapperManager,
+            embedder: mcpEmbedder(),
+        });
+    else if (action === "gateway")
+        await runMcpGatewayCommand();
+    else if (action === "browser-config")
+        console.log(JSON.stringify(browserBridgeConfig(), null, 2));
+    else if (action === "browser-bridge")
+        await runBrowserBridgeCommand();
+    else if (action === "browser-service")
+        await runBrowserServiceCommand(process.argv[4] ?? "");
+    else {
+        console.error("Usage: ocean mcp config|playwright-config|gateway-config|browser-config|browser-bridge|browser-service install|uninstall|serve|gateway");
+        process.exitCode = 1;
+    }
+}
+async function commandObsidian() {
+    const action = process.argv[3] ?? "discover";
+    if (action === "mcp")
+        await runObsidianMcpServer();
+    else if (![
+        "connect",
+        "discover",
+        "sync",
+        "watch",
+        "inbox",
+        "write",
+        "conflicts",
+    ].includes(action)) {
+        console.error("Usage: ocean obsidian connect <vault-path> [--read-write]|discover|sync|watch|inbox|write|conflicts resolve <id> --keep=vault|ocean");
+        process.exitCode = 1;
+    }
+    else {
+        try {
+            if (action === "connect") {
+                const vaultPath = process.argv[4];
+                if (!vaultPath)
+                    throw new Error("Usage: ocean obsidian connect <vault-path> [--read-write]");
+                const readWrite = process.argv.includes("--read-write");
+                const mode = readWrite
+                    ? "read-write"
+                    : "read-only";
+                const result = await connectObsidianVault(vaultPath, mode);
+                const synced = await syncObsidianVault(await loadObsidianConnection());
+                console.log(JSON.stringify({
+                    connected: true,
+                    mode,
+                    vaultPath: result.vaultPath,
+                    noteCount: synced.noteCount,
+                    added: synced.added,
+                    changed: synced.changed,
+                    removed: synced.removed,
+                    issues: synced.issues,
+                }, null, 2));
+            }
+            else {
+                const connection = await loadObsidianConnection();
+                if (action === "conflicts") {
+                    if (process.argv[4] !== "resolve")
+                        throw new Error("Usage: ocean obsidian conflicts resolve <id> --keep=vault|ocean");
+                    const id = process.argv[5];
+                    const keepArg = process.argv.find((arg) => arg.startsWith("--keep="));
+                    const keep = keepArg?.slice("--keep=".length);
+                    if (!id || !keep || !parseConflictSide(keep))
+                        throw new Error("Usage: ocean obsidian conflicts resolve <id> --keep=vault|ocean");
+                    console.log(JSON.stringify(await resolveConflict(id, keep), null, 2));
+                }
+                else if (action === "write") {
+                    const relative = process.argv[4];
+                    const content = process.argv[5];
+                    const expectedSha256 = process.argv[6] ?? null;
+                    if (!relative || content === undefined)
+                        throw new Error("Usage: ocean obsidian write <relative.md> <content> [expected-sha256] [--apply]");
+                    console.log(JSON.stringify(await writeObsidianNote(connection, relative, content, expectedSha256 === "-" ? null : expectedSha256, process.argv.includes("--apply")), null, 2));
+                }
+                else if (action === "inbox") {
+                    const inboxAction = process.argv[4] ?? "list";
+                    if (inboxAction === "list")
+                        console.log(JSON.stringify(await listInboxCandidates(connection), null, 2));
+                    else if (inboxAction === "promote") {
+                        const source = process.argv[5];
+                        const target = process.argv[6];
+                        if (!source || !target)
+                            throw new Error("Usage: ocean obsidian inbox promote <source.md> <target-directory> [--apply]");
+                        console.log(JSON.stringify(await promoteInboxNote(connection, source, target, process.argv.includes("--apply")), null, 2));
+                    }
+                    else
+                        throw new Error("Usage: ocean obsidian inbox list|promote <source.md> <target-directory> [--apply]");
+                }
+                else if (action === "discover")
+                    console.log(JSON.stringify(await discoverObsidianVault(connection), null, 2));
+                else if (action === "sync")
+                    console.log(JSON.stringify(await syncObsidianVault(connection), null, 2));
+                else {
+                    const controller = new AbortController();
+                    process.once("SIGINT", () => controller.abort());
+                    process.once("SIGTERM", () => controller.abort());
+                    await watchObsidianVault(connection, undefined, controller.signal);
+                }
+            }
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    }
+}
+async function commandCapture() {
+    await runCaptureCommand(process.argv[3] ?? "", process.argv.slice(4));
+}
+async function commandHandoff() {
+    try {
+        await runHandoffCommand(process.argv[3] ?? "list", process.argv.slice(4));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+async function commandContext() {
+    if (process.argv[3] === "cost") {
+        await runContextCostCommand(process.argv.slice(4));
+        return;
+    }
+    await runContextCommand(process.argv.includes("--json"));
+}
+async function commandProject() {
+    const action = process.argv[3] ?? "resolve";
+    if (action === "resolve") {
+        console.log(JSON.stringify(await resolveProject(process.argv[4] ?? process.cwd()), null, 2));
+    }
+    else if (action === "bind") {
+        const args = process.argv.slice(4);
+        const addPath = args.includes("--add");
+        const [name, targetPath] = args.filter((arg) => arg !== "--add");
+        if (!name || !targetPath) {
+            console.error("Usage: ocean project bind <name> <path> [--add]");
+            process.exitCode = 1;
+        }
+        else {
+            const result = await bindProject(name, targetPath, { addPath });
+            console.log(JSON.stringify(result, null, 2));
+            if (result.conflict)
+                process.exitCode = 2;
+        }
+    }
+    else if (action === "list") {
+        const flag = process.argv.indexOf("--category");
+        const wanted = flag >= 0 ? process.argv[flag + 1] : undefined;
+        if (flag >= 0 &&
+            !PROJECT_CATEGORIES.includes(wanted ?? "")) {
+            console.error(`Usage: ocean project list [--category ${PROJECT_CATEGORIES.join("|")}]`);
+            process.exitCode = 1;
+            return;
+        }
+        const { manifests, errors } = await scanProjectManifests();
+        for (const { file, error } of errors)
+            console.error(`skipped invalid ${file}: ${error}`);
+        const categories = new Map();
+        for (const manifest of manifests) {
+            try {
+                const category = projectCategory(manifest);
+                if (category)
+                    categories.set(manifest.id, category);
+            }
+            catch (error) {
+                console.error(`${manifest.id}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        const bindings = (await listProjectBindings())
+            .map((binding) => ({
+            ...binding,
+            gitRoot: binding.gitRoot ?? findGitRoot(binding.path),
+            ...(categories.has(binding.id)
+                ? { category: categories.get(binding.id) }
+                : {}),
+        }))
+            .filter((binding) => !wanted || binding.category === wanted);
+        console.log(JSON.stringify(bindings, null, 2));
+        if (errors.length)
+            process.exitCode = 2;
+    }
+    else if (action === "register") {
+        const result = await autoRegisterProject(process.argv[4] ?? process.cwd(), {
+            explicit: true,
+        });
+        console.log(JSON.stringify(result, null, 2));
+        if (result.status !== "registered")
+            process.exitCode = 2;
+    }
+    else if (action === "unbind") {
+        const target = process.argv[4];
+        if (!target) {
+            console.error("Usage: ocean project unbind <path>");
+            process.exitCode = 1;
+        }
+        else {
+            const result = await unbindProjectPath(target);
+            console.log(JSON.stringify(result, null, 2));
+            if (!result.removed)
+                process.exitCode = 2;
+        }
+    }
+    else if (action === "rename") {
+        const [from, to] = process.argv.slice(4);
+        if (!from || !to) {
+            console.error("Usage: ocean project rename <id> <new-id>");
+            process.exitCode = 1;
+        }
+        else {
+            try {
+                console.log(JSON.stringify(await renameProject(from, to), null, 2));
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+                process.exitCode = 2;
+            }
+        }
+    }
+    else if (action === "move") {
+        const args = process.argv.slice(4);
+        const [id, category] = args.filter((arg) => arg !== "--write");
+        if (!id || !category) {
+            console.error(`Usage: ocean project move <id> <${PROJECT_CATEGORIES.join("|")}> [--write]`);
+            process.exitCode = 1;
+        }
+        else {
+            try {
+                console.log(JSON.stringify(await moveProject(id, category, args.includes("--write")), null, 2));
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+                process.exitCode = 2;
+            }
+        }
+    }
+    else if (action === "migrate") {
+        const result = await migrateProjectBindings(process.argv.includes("--write"));
+        console.log(JSON.stringify(result, null, 2));
+    }
+    else if (action === "index") {
+        if (process.argv.includes("--write"))
+            console.log(JSON.stringify(await writeProjectIndex(), null, 2));
+        else
+            console.log(await renderProjectIndex());
+    }
+    else {
+        console.error("Usage: ocean project resolve [path]|bind <name> <path> [--add]|register [path]|unbind <path>|rename <id> <new-id>|move <id> <category> [--write]|list [--category <name>]|migrate [--write]|index [--write]");
+        process.exitCode = 1;
+    }
+}
+// `--repair` (the hook entries `ocean clients` writes, T-296): `client sync` in the background,
+// as the Claude Code bootstrap script does; it never delays or fails the session.
+function startBackgroundSync() {
+    try {
+        spawn(process.execPath, [process.argv[1], "client", "sync"], {
+            detached: true,
+            stdio: "ignore",
+        })
+            .on("error", () => { })
+            .unref();
+    }
+    catch {
+        // no repair this time; the next session start tries again
+    }
+}
+async function commandHook() {
+    const action = process.argv[3] ?? "";
+    if (action === "session-start") {
+        const flags = process.argv.slice(4);
+        if (flags.includes("--repair"))
+            startBackgroundSync();
+        startBackgroundPull();
+        const inline = flags.find((arg) => arg.startsWith("--client="));
+        const clientIndex = flags.indexOf("--client");
+        const client = inline
+            ? inline.slice("--client=".length)
+            : clientIndex >= 0
+                ? (flags[clientIndex + 1] ?? "")
+                : "claude";
+        if (!isSessionStartClient(client)) {
+            console.error(sessionStartUsage);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const raw = await readBoundedStdin();
+            const parsed = raw.trim() ? JSON.parse(raw) : {};
+            const payload = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? parsed
+                : {};
+            console.log(JSON.stringify(await sessionStartHookForClient(client, payload)));
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    }
+    else if (action === "session-end") {
+        const flags = process.argv.slice(4);
+        const inline = flags.find((arg) => arg.startsWith("--client="));
+        const clientIndex = flags.indexOf("--client");
+        const client = inline
+            ? inline.slice("--client=".length)
+            : clientIndex >= 0
+                ? (flags[clientIndex + 1] ?? "")
+                : "claude";
+        if (!isSessionEndClient(client)) {
+            console.error(sessionEndUsage);
+            process.exitCode = 1;
+            return;
+        }
+        try {
+            const raw = await readBoundedStdin();
+            const payload = raw.trim() ? JSON.parse(raw) : {};
+            await claudeSessionEndHook(payload, defaultSessionStoreFactory, client);
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    }
+    else {
+        console.error(`${sessionStartUsage}|${sessionEndUsage.slice("Usage: ocean hook ".length)}`);
+        process.exitCode = 1;
+    }
+}
+const sessionEndUsage = `Usage: ocean hook session-end [--client ${SESSION_END_CLIENTS.join("|")}] (reads a hook payload from stdin)`;
+const sessionStartUsage = `Usage: ocean hook session-start [--client ${SESSION_START_CLIENTS.join("|")}] [--repair]`;
+async function commandIntent() {
+    const action = process.argv[3] ?? "classify";
+    if (action !== "classify") {
+        console.error("Usage: ocean intent classify <text>");
+        process.exitCode = 1;
+    }
+    else {
+        const text = process.argv.slice(4).join(" ");
+        console.log(JSON.stringify(classifyIntent(text, await knownTaskPrefixes())));
+    }
+}
+async function commandOperate() {
+    const args = process.argv.slice(3);
+    const text = (args[0] === "--" ? args.slice(1) : args).join(" ");
+    await runOperateCommand(text);
+}
+async function commandIdea() {
+    try {
+        await runIdeaCommand(process.argv[3] ?? "list", process.argv.slice(4));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+async function commandDaily() {
+    try {
+        await runDailyCommand(process.argv[3] ?? "start", process.argv.slice(4));
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    }
+}
+async function commandSchedule() {
+    const action = process.argv[3] ?? "list";
+    if (action === "list")
+        console.log(JSON.stringify(await listSchedules(), null, 2));
+    else if (action === "add") {
+        const [id, profile, intervalMs, ...prompt] = process.argv.slice(4);
+        if (!id || !profile || !intervalMs || !prompt.length) {
+            console.error("Usage: ocean schedule add <id> <profile> <interval-ms> <prompt>");
+            process.exitCode = 1;
+        }
+        else
+            await saveSchedule({
+                id,
+                profile,
+                prompt: prompt.join(" "),
+                intervalMs: Number(intervalMs),
+                nextRunAt: new Date().toISOString(),
+                enabled: true,
+            });
+    }
+    else if (action === "run-due")
+        console.log(JSON.stringify({ ran: await runDueSchedules(oceanRoot(), defaultAgentRuntime) }, null, 2));
+    else if (action === "worker-once")
+        console.log(JSON.stringify({ ran: await runSchedulerWorkerOnce(oceanRoot(), defaultAgentRuntime) }, null, 2));
+    else if (action === "worker") {
+        const controller = new AbortController();
+        const stop = () => controller.abort();
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        await runSchedulerWorker(oceanRoot(), defaultAgentRuntime, {
+            signal: controller.signal,
+            pollMs: Number(oceanEnv("SCHEDULER_POLL_MS") ?? 30_000),
+        });
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+    }
+    else if (action === "enable" || action === "disable")
+        console.log(JSON.stringify(await setScheduleEnabled(process.argv[4] ?? "", action === "enable"), null, 2));
+    else if (action === "run-now")
+        await runSchedule(process.argv[4] ?? "", oceanRoot(), defaultAgentRuntime);
+    else {
+        console.error("Usage: ocean schedule list|add|enable|disable|run-due|run-now|worker-once|worker");
+        process.exitCode = 1;
+    }
+}
+async function commandLoop() {
+    const action = process.argv[3] ?? "status";
+    if (action === "status")
+        console.log(JSON.stringify(await listTaskLoops(), null, 2));
+    else if (action === "start") {
+        const taskId = process.argv[4];
+        const profile = process.argv[5] ?? "developer";
+        const promptIndex = process.argv.indexOf("--prompt");
+        const prompt = promptIndex >= 0 ? process.argv.slice(promptIndex + 1).join(" ") : "";
+        if (!taskId || !prompt || !process.argv.includes("--approve")) {
+            console.error("Usage: ocean loop start <task-id> <profile> --prompt <text> --approve [--max-iterations N] [--interval-ms N] [--max-attempts N]");
+            process.exitCode = 1;
+        }
+        else {
+            const value = (flag, fallback) => {
+                const index = process.argv.indexOf(flag);
+                return index >= 0 ? Number(process.argv[index + 1]) : fallback;
+            };
+            console.log(JSON.stringify(await startTaskLoop({
+                taskId,
+                profile,
+                prompt,
+                cwd: oceanRoot(),
+                approved: true,
+                maxIterations: value("--max-iterations", 10),
+                intervalMs: value("--interval-ms", 60_000),
+                maxAttempts: value("--max-attempts", 2),
+            }), null, 2));
+        }
+    }
+    else if (action === "worker-once") {
+        console.log(JSON.stringify({ ran: await runTaskLoopsOnce(oceanRoot(), defaultAgentRuntime) }, null, 2));
+    }
+    else if (action === "worker") {
+        const controller = new AbortController();
+        const stop = () => controller.abort();
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        await runTaskLoopWorker(oceanRoot(), defaultAgentRuntime, {
+            signal: controller.signal,
+            pollMs: Number(oceanEnv("LOOP_POLL_MS") ?? 30_000),
+        });
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+    }
+    else if (action === "stop") {
+        const id = process.argv[4];
+        if (!id) {
+            console.error("Usage: ocean loop stop <loop-id>");
+            process.exitCode = 1;
+        }
+        else
+            console.log(JSON.stringify(await stopTaskLoop(id), null, 2));
+    }
+    else {
+        console.error("Usage: ocean loop start|status|stop|worker-once|worker");
+        process.exitCode = 1;
+    }
+}
+async function commandGateway() {
+    const port = Number(oceanEnv("GATEWAY_PORT") ?? 8787);
+    const token = oceanEnv("GATEWAY_TOKEN");
+    if (!token) {
+        console.error("OCEAN_GATEWAY_TOKEN is required");
+        process.exitCode = 1;
+    }
+    else {
+        const server = createWebhookGateway(oceanRoot(), token, defaultAgentRuntime);
+        server.listen(port, "127.0.0.1", () => console.log(`Ocean webhook gateway listening on 127.0.0.1:${port}`));
+    }
+}
+async function commandSkill() {
+    const action = process.argv[3] ?? "list";
+    if (action === "sync")
+        console.log(JSON.stringify(await syncCoreSkills(), null, 2));
+    else if (action === "hub") {
+        const sources = process.argv
+            .slice(4)
+            .filter((arg) => !arg.startsWith("--"));
+        console.log(JSON.stringify(await populateSkillHub(sources), null, 2));
+    }
+    else if (action === "copy") {
+        console.log(JSON.stringify(await copyClientSkills({ apply: process.argv.includes("--apply") }), null, 2));
+    }
+    else if (action === "link") {
+        console.log(JSON.stringify(await linkClientSkills({
+            apply: process.argv.includes("--apply"),
+            all: process.argv.includes("--all"),
+        }), null, 2));
+    }
+    else if (action === "doctor")
+        console.log(JSON.stringify(await coreSkillReports(), null, 2));
+    else if (action === "list") {
+        // [status] filters; any other argument is a lesson id (what a truncated lesson points at).
+        const filter = process.argv[4];
+        const isStatus = filter === "candidate" || filter === "active" || filter === "retired";
+        const lessons = filter && !isStatus
+            ? [await readLesson(filter)].filter((lesson) => lesson !== null)
+            : await listLessons(isStatus ? { status: filter } : {});
+        if (filter && !isStatus && !lessons.length) {
+            console.error(`Lesson not found: ${filter}`);
+            process.exitCode = 1;
+        }
+        else
+            console.log(JSON.stringify(lessons.map((lesson) => ({
+                ...lesson,
+                effectiveConfidence: Number(effectiveConfidence(lesson).toFixed(4)),
+            })), null, 2));
+    }
+    else if (action === "observe" || action === "learn") {
+        // Scores one closed session into the lessons store (the same step closeout runs).
+        const sessionId = process.argv[4];
+        if (!sessionId && action === "observe")
+            console.log(JSON.stringify(await listLessons({ status: "candidate" }), null, 2));
+        else if (!sessionId) {
+            console.error("Usage: ocean skill learn <session-id>");
+            process.exitCode = 1;
+        }
+        else {
+            const store = await defaultSessionStoreFactory();
+            try {
+                console.log(JSON.stringify(await learnFromSession(store, sessionId), null, 2));
+            }
+            finally {
+                store.close();
+            }
+        }
+    }
+    else if (action === "add") {
+        const [id, name, ...instructions] = process.argv.slice(4);
+        if (!id || !name || !instructions.length) {
+            console.error("Usage: ocean skill add <id> <name> <instructions>");
+            process.exitCode = 1;
+        }
+        else
+            console.log(JSON.stringify(await addLesson({ id, title: name, body: instructions.join(" ") }), null, 2));
+    }
+    else if (action === "review") {
+        // The owner's call: promoted activates a lesson without waiting for the replay eval,
+        // rejected retires it. Run `ocean memory reindex` afterwards so runs can find it.
+        const [id, status] = process.argv.slice(4);
+        if (!id || (status !== "promoted" && status !== "rejected")) {
+            console.error("Usage: ocean skill review <id> promoted|rejected");
+            process.exitCode = 1;
+        }
+        else
+            console.log(JSON.stringify(await setLessonStatus(id, status === "promoted" ? "active" : "retired"), null, 2));
+    }
+    else if (action === "migrate") {
+        console.log(JSON.stringify(await migrateLegacyLessons(), null, 2));
+    }
+    else {
+        console.error("Usage: ocean skill sync|doctor|list [status|id]|observe [session-id]|add|review <id> promoted|rejected|migrate");
+        process.exitCode = 1;
+    }
+}
+async function commandCatalog() {
+    console.log(JSON.stringify(listInstallSpecs().map((spec) => ({
+        id: spec.provider.id,
+        command: spec.provider.command,
+        installer: installPlan(spec.provider.id),
+    })), null, 2));
+}
+async function commandEnv() {
+    console.log(await installShellPath());
+}
+async function commandUpdateOrRemove(command) {
+    const id = process.argv[3];
+    if (!id || !process.argv.includes("--yes")) {
+        console.error(`Usage: ocean ${command} <client> --yes`);
+        process.exitCode = 2;
+    }
+    else {
+        try {
+            const result = command === "update"
+                ? await updateProvider(id, true, defaultWrapperManager, defaultProviderRegistry)
+                : await removeInstalledProvider(id, true, defaultWrapperManager);
+            console.log(JSON.stringify({
+                [command === "update" ? "updated" : "removed"]: true,
+                provider: result,
+            }, null, 2));
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            process.exitCode = 1;
+        }
+    }
+}
+async function commandDoctor() {
+    const report = await workspaceReport(defaultWrapperManager);
+    // T-296: every installed AI client's `ocean` entry (supported fail, unknown warn).
+    report.findings.push(...(await clientFindings()), ...(await nativeFindings()), ...(await browserBridgeFindings()));
+    if (process.argv.includes("--json"))
+        console.log(JSON.stringify(report, null, 2));
+    else
+        report.findings.forEach((finding) => {
+            console.log(`${finding.severity}: ${finding.code} — ${finding.message}`);
+        });
+    if (hasFailures(report.findings))
+        process.exitCode = 1;
+}
+async function commandRepair() {
+    const apply = process.argv.includes("--apply");
+    if (!apply) {
+        const report = await workspaceReport(defaultWrapperManager);
+        console.log(JSON.stringify({
+            dryRun: true,
+            fixable: report.findings.filter((finding) => finding.fixable),
+            findings: report.findings,
+        }, null, 2));
+    }
+    else {
+        const result = await repairWorkspace(defaultWrapperManager);
+        console.log(JSON.stringify({ applied: result.changes, findings: result.findings }, null, 2));
+        if (hasFailures(result.findings))
+            process.exitCode = 1;
+    }
+}
+async function commandBrowser() {
+    await runBrowserCommand(process.argv[3] ?? "", process.argv.slice(4));
+}
+async function commandRun() {
+    const profileIndex = process.argv.indexOf("--profile");
+    const promptIndex = process.argv.indexOf("--prompt");
+    const clientIndex = process.argv.indexOf("--client");
+    const taskIndex = process.argv.indexOf("--task");
+    const handoffIndex = process.argv.indexOf("--handoff");
+    // --profile, then runtime.json's defaultProfile, then the historical "default" while no
+    // runtime.json exists. A named profile that does not exist fails; nothing falls back.
+    const explicitProfile = profileIndex >= 0 ? process.argv[profileIndex + 1] : undefined;
+    if (profileIndex >= 0 &&
+        (!explicitProfile || explicitProfile.startsWith("--"))) {
+        console.error("Usage: ocean run --profile <name> ... --prompt <text>");
+        process.exitCode = 1;
+        return;
+    }
+    // runtime.json is read only when it is needed, so a broken one cannot block an explicit run.
+    const runtimeConfig = explicitProfile ? null : await loadRuntimeConfig();
+    const client = clientIndex >= 0 ? process.argv[clientIndex + 1] : undefined;
+    const taskId = taskIndex >= 0 ? process.argv[taskIndex + 1] : undefined;
+    // T-296: with `autoProfile` on, a run for a task without --profile takes the suggested one.
+    const profileName = runtimeConfig?.autoProfile && taskId
+        ? (await selectProfileForTask(taskId, { cwd: process.cwd() })).profile
+        : resolveProfileName(explicitProfile, runtimeConfig);
+    const handoffId = handoffIndex >= 0 ? process.argv[handoffIndex + 1] : undefined;
+    const prompt = promptIndex >= 0 ? process.argv.slice(promptIndex + 1).join(" ") : "";
+    if (!profileName || !prompt) {
+        console.error("Usage: ocean run --profile <name> [--client <client>] [--task <id>] [--handoff <id>] --prompt <text>");
+        process.exitCode = 1;
+    }
+    else {
+        const session = await runAgent({ profileName, client, taskId, handoffId, prompt, cwd: oceanRoot() }, defaultAgentRuntime);
+        console.log(JSON.stringify({ sessionId: session.sessionId, status: session.status }));
+    }
+}
+async function commandSession() {
+    const action = process.argv[3] ?? "list";
+    const store = await openSessionStore();
+    if (action === "list") {
+        console.log(JSON.stringify(store.list()));
+        store.close();
+    }
+    else if (action === "show") {
+        const sessionId = process.argv[4] ?? "";
+        const session = store.get(sessionId);
+        const entryEvent = session
+            ? store
+                .listEvents(sessionId)
+                .find((event) => event.type === "session_entry_contract")
+            : undefined;
+        store.close();
+        if (!session) {
+            console.error("Session not found");
+            process.exitCode = 1;
+        }
+        else
+            console.log(JSON.stringify({
+                ...session,
+                entryContract: entryEvent ? JSON.parse(entryEvent.data) : null,
+            }));
+    }
+    else if (action === "summary") {
+        const sessionId = process.argv[4] ?? "";
+        const session = store.get(sessionId);
+        store.close();
+        if (!session) {
+            console.error("Session not found");
+            process.exitCode = 1;
+        }
+        else if (!session.summaryPath) {
+            console.error("Session summary not available");
+            process.exitCode = 1;
+        }
+        else {
+            try {
+                console.log(await readFile(path.resolve(oceanRoot(), session.summaryPath), "utf8"));
+            }
+            catch {
+                console.error("Session summary file is missing");
+                process.exitCode = 1;
+            }
+        }
+    }
+    else if (action === "events") {
+        const sessionId = process.argv[4] ?? "";
+        const session = store.get(sessionId);
+        const events = session ? store.listEvents(sessionId) : [];
+        store.close();
+        if (!session) {
+            console.error("Session not found");
+            process.exitCode = 1;
+        }
+        else
+            console.log(JSON.stringify(events, null, 2));
+    }
+    else if (action === "resume") {
+        const sessionId = process.argv[4];
+        const prompt = process.argv.slice(5).join(" ");
+        store.close();
+        if (!sessionId || !prompt) {
+            console.error("Usage: ocean session resume <session-id> <prompt>");
+            process.exitCode = 1;
+        }
+        else {
+            const session = await resumeAgent(sessionId, prompt, defaultAgentRuntime);
+            console.log(JSON.stringify({
+                sessionId: session.sessionId,
+                status: session.status,
+            }));
+        }
+    }
+    else if (action === "promote") {
+        const sessionId = process.argv[4];
+        const target = process.argv[5] ?? "knowledge/results";
+        store.close();
+        if (!sessionId) {
+            console.error("Usage: ocean session promote <session-id> [knowledge/<kind>] --approve");
+            process.exitCode = 1;
+        }
+        else {
+            try {
+                console.log(JSON.stringify(await promoteSessionToKnowledge(sessionId, defaultSessionStoreFactory, target, process.argv.includes("--approve")), null, 2));
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+                process.exitCode = 1;
+            }
+        }
+    }
+    else if (action === "doctor") {
+        const thresholdHours = Number(process.argv[4] ?? "24");
+        const apply = process.argv.includes("--apply");
+        if (!Number.isFinite(thresholdHours) || thresholdHours <= 0) {
+            store.close();
+            console.error("Usage: ocean session doctor [hours] [--apply]");
+            process.exitCode = 1;
+        }
+        else {
+            const thresholdMs = thresholdHours * 60 * 60 * 1000;
+            const stale = apply
+                ? store.reconcileStaleRunning(thresholdMs)
+                : store.listStaleRunning(thresholdMs);
+            console.log(JSON.stringify({
+                apply,
+                thresholdHours,
+                stale: stale.map((session) => ({
+                    sessionId: session.sessionId,
+                    provider: session.provider,
+                    updatedAt: session.updatedAt,
+                })),
+                integrity: store.integrityCheck(),
+            }));
+            store.close();
+        }
+    }
+    else if (action === "compact") {
+        const keepDaysIndex = process.argv.indexOf("--keep-days");
+        const keepDays = keepDaysIndex >= 0
+            ? Number(process.argv[keepDaysIndex + 1])
+            : DEFAULT_KEEP_DAYS;
+        const simulate = process.argv.includes("--simulate");
+        const apply = process.argv.includes("--apply");
+        const beforeIndex = process.argv.indexOf("--before");
+        const before = beforeIndex >= 0 ? process.argv[beforeIndex + 1] : undefined;
+        const planIndex = process.argv.indexOf("--plan");
+        const fingerprint = planIndex >= 0 ? process.argv[planIndex + 1] : undefined;
+        if (!Number.isFinite(keepDays) || keepDays <= 0) {
+            store.close();
+            console.error("Usage: ocean session compact [--keep-days N] [--simulate|--apply --before <iso> --plan <fingerprint>] [--json]");
+            process.exitCode = 1;
+            return;
+        }
+        const plan = planRetention(store, { keepDays, before });
+        if (apply) {
+            if (!before || !fingerprint) {
+                store.close();
+                console.error("ocean session compact --apply requires --before <iso> and --plan <fingerprint> from a prior plan/--simulate run");
+                process.exitCode = 1;
+                return;
+            }
+            try {
+                const result = await applyRetention(store, oceanPath(SYSTEM_DIR, "sessions", "sessions.sqlite"), plan, fingerprint);
+                console.log(JSON.stringify({ apply: true, plan, result }, null, 2));
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+                process.exitCode = 1;
+            }
+            finally {
+                store.close();
+            }
+            return;
+        }
+        if (simulate) {
+            const result = await simulateRetention(store, oceanPath(SYSTEM_DIR, "sessions", "sessions.sqlite"), plan, defaultSessionStoreOpener);
+            store.close();
+            console.log(JSON.stringify({ simulate: true, plan, result }, null, 2));
+            return;
+        }
+        store.close();
+        console.log(JSON.stringify({ dryRun: true, plan }, null, 2));
+    }
+    else {
+        store.close();
+        console.error("Usage: ocean session list|show <session-id>|summary <session-id>|events <session-id>|resume <session-id> <prompt>|promote <session-id> [knowledge/<kind>] --approve|doctor [hours] [--apply]|compact [--keep-days N] [--simulate]|compact --apply --before <iso> --plan <fingerprint>");
+        process.exitCode = 1;
+    }
+}
+export const commandRegistry = {
+    setup: commandSetup,
+    onboard: () => runOnboardCommand(process.argv.slice(3)),
+    service: commandService,
+    intercept: commandIntercept,
+    client: commandClient,
+    clients: () => runClientsCommand(process.argv.slice(3)),
+    install: commandInstall,
+    auth: commandAuth,
+    tasks: commandTasks,
+    policy: commandPolicy,
+    lifecycle: commandLifecycle,
+    observe: commandObserve,
+    migrate: commandMigrate,
+    layout: commandLayout,
+    memory: commandMemory,
+    pull: () => runPullCommand(process.argv.slice(3)),
+    mcp: commandMcp,
+    market: commandMarket,
+    obsidian: commandObsidian,
+    capture: commandCapture,
+    handoff: commandHandoff,
+    context: commandContext,
+    project: commandProject,
+    hook: commandHook,
+    intent: commandIntent,
+    operate: commandOperate,
+    idea: commandIdea,
+    daily: commandDaily,
+    schedule: commandSchedule,
+    loop: commandLoop,
+    gateway: commandGateway,
+    skill: commandSkill,
+    catalog: commandCatalog,
+    env: commandEnv,
+    update: () => commandUpdateOrRemove("update"),
+    remove: () => commandUpdateOrRemove("remove"),
+    doctor: commandDoctor,
+    repair: commandRepair,
+    browser: commandBrowser,
+    run: commandRun,
+    profiles: () => runProfilesCommand(process.argv.slice(3)),
+    session: commandSession,
+};
+//# sourceMappingURL=command-registry.js.map