@oxagen/cli 0.5.0 → 0.6.1

package/dist/index.js

@@ -1,364 +1,566 @@
-#!/usr/bin/env node
-import { jsx as _jsx } from "react/jsx-runtime";
+#!/usr/bin/env tsx
+/**
+ * oxagen — agentic coding CLI powered by the Oxagen context engine.
+ *
+ * Usage:
+ *   oxagen                     Interactive REPL (default)
+ *   oxagen "fix the login bug" One-shot prompt
+ *   oxagen agents [goal...]    Agents screen — plan, dispatch & watch a fleet
+ *   oxagen view                Agent dashboard (memory, compile, sessions)
+ *   oxagen daemon start|stop|status
+ *   oxagen config [key] [value]
+ */
+import { createRequire } from "node:module";
 import { Command } from "commander";
-import { render } from "ink";
-import React from "react";
-import { DevStatus } from "./components/DevStatus.js";
-import { version } from "../package.json" with { type: "json" };
-import { authLoginCommand } from "./commands/auth.login.js";
-import { authLogoutCommand } from "./commands/auth.logout.js";
-import { authWhoamiCommand } from "./commands/auth.whoami.js";
-import { orgListCommand } from "./commands/org.list.js";
-import { orgCreateCommand } from "./commands/org.create.js";
-import { orgMemberAddCommand } from "./commands/org.member.add.js";
-import { orgMemberRemoveCommand } from "./commands/org.member.remove.js";
-import { workspaceListCommand } from "./commands/workspace.list.js";
-import { workspaceCreateCommand } from "./commands/workspace.create.js";
-import { chatSendCommand } from "./commands/chat.send.js";
-import { conversationListCommand } from "./commands/conversation.list.js";
-import { conversationDeleteCommand } from "./commands/conversation.delete.js";
-import { conversationArchiveCommand } from "./commands/conversation.archive.js";
-import { conversationRenameCommand } from "./commands/conversation.rename.js";
-import { apiKeyCreateCommand } from "./commands/api-key.create.js";
-import { apiKeyRevokeCommand } from "./commands/api-key.revoke.js";
-import { notificationsListCommand } from "./commands/notifications.list.js";
-import { notificationsMarkCommand } from "./commands/notifications.mark.js";
-import { pluginListCommand } from "./commands/plugin.list.js";
-import { pluginInstallCommand } from "./commands/plugin.install.js";
-import { pluginUninstallCommand } from "./commands/plugin.uninstall.js";
-import { pluginOrgInstallCommand } from "./commands/plugin.org.install.js";
-import { pluginOrgUninstallCommand } from "./commands/plugin.org.uninstall.js";
-import { pluginCatalogGetCommand } from "./commands/plugin.catalog.get.js";
-import { billingStatusCommand } from "./commands/billing.status.js";
-import { billingCreditsPurchaseCommand } from "./commands/billing.credits.purchase.js";
-import { billingSubscriptionReadCommand } from "./commands/billing.subscription.read.js";
-import { agentMcpListCommand } from "./commands/agent.mcp.list.js";
-import { agentSkillListCommand } from "./commands/agent.skill.list.js";
-import { agentToolListCommand } from "./commands/agent.tool.list.js";
-import { agentApprovalResolveCommand } from "./commands/agent.approval.resolve.js";
-import { orgMemberRoleChangeCommand } from "./commands/org.member.role.change.js";
-import { archiveCreateCommand } from "./commands/archive.create.js";
-import { workflowRunCommand } from "./commands/workflow.run.js";
-import { userPreferencesGetCommand } from "./commands/user.preferences.get.js";
-import { userPreferencesUpdateCommand } from "./commands/user.preferences.update.js";
-import { workspaceMemberListCommand } from "./commands/workspace.member.list.js";
-import { workspaceInviteSendCommand } from "./commands/workspace.invite.send.js";
-import { conversationChatCommand } from "./commands/conversation.chat.js";
-import { imageCreateCommand } from "./commands/image.create.js";
-import { documentCreateCommand } from "./commands/document.create.js";
-import { automationListCommand } from "./commands/automation.list.js";
-import { automationEnableCommand } from "./commands/automation.enable.js";
-import { automationDisableCommand } from "./commands/automation.disable.js";
-import { imageListCommand } from "./commands/image.list.js";
-import { imageAnalyzeCommand } from "./commands/image.analyze.js";
-import { documentListCommand } from "./commands/document.list.js";
-import { documentReadCommand } from "./commands/document.read.js";
-import { formCreateCommand } from "./commands/form.create.js";
-import { formSubmitCommand } from "./commands/form.submit.js";
-import { automationCreateCommand } from "./commands/automation.create.js";
-import { automationUpdateCommand } from "./commands/automation.update.js";
-import { automationTriggerCommand } from "./commands/automation.trigger.js";
-import { skillWorkspaceListCommand } from "./commands/skill.workspace.list.js";
-import { skillWorkspaceInstallCommand } from "./commands/skill.workspace.install.js";
-import { skillVersionListCommand } from "./commands/skill.version.list.js";
-import { skillVersionGetCommand } from "./commands/skill.version.get.js";
-import { skillVersionUploadCommand } from "./commands/skill.version.upload.js";
-import { skillVersionActivateCommand } from "./commands/skill.version.activate.js";
-import { skillEditCommand } from "./commands/skill.edit.js";
-import { skillExportCommand } from "./commands/skill.export.js";
-import { skillMetricsReadCommand } from "./commands/skill.metrics.read.js";
-import { agentMemoryRecallCommand } from "./commands/agent.memory.recall.js";
-import { agentMemoryWriteCommand } from "./commands/agent.memory.write.js";
-import { videoGenerateCommand } from "./commands/video.generate.js";
-import { svgGenerateCommand } from "./commands/svg.generate.js";
-import { workspaceModelSettingsReadCommand } from "./commands/workspace.model.settings.read.js";
-import { workspaceModelSettingsWriteCommand } from "./commands/workspace.model.settings.write.js";
-import { orgMemberInviteAcceptCommand } from "./commands/org.member.invite.accept.js";
-import { pluginRegistryListCommand } from "./commands/plugin.registry.list.js";
-import { pluginCatalogBrowseCommand } from "./commands/plugin.catalog.browse.js";
-import { pluginCredentialReauthCommand } from "./commands/plugin.credential.reauth.js";
-import { imageGenerateCommand } from "./commands/image.generate.js";
-import { documentsGenerateCommand } from "./commands/documents.generate.js";
-import { pluginRegistryAddCommand } from "./commands/plugin.registry.add.js";
-import { agentMcpRegisterCommand } from "./commands/agent.mcp.register.js";
-import { agentMcpSetEnabledCommand } from "./commands/agent.mcp.set_enabled.js";
-import { agentMcpDeleteCommand } from "./commands/agent.mcp.delete.js";
-import { agentMcpConsentResolveCommand } from "./commands/agent.mcp.consent.resolve.js";
-import { agentMcpConsentListCommand } from "./commands/agent.mcp.consent.list.js";
-import { agentPlanApproveCommand } from "./commands/agent.plan.approve.js";
-import { agentPlanCreateCommand } from "./commands/agent.plan.create.js";
-import { agentTaskBackgroundReadCommand } from "./commands/agent.task.background.read.js";
-import { agentTaskBackgroundStartCommand } from "./commands/agent.task.background.start.js";
-import { agentTaskBackgroundCancelCommand } from "./commands/agent.task.background.cancel.js";
-import { assetUploadCommand } from "./commands/asset.upload.js";
-import { billingSubscriptionUpgradeStartCommand } from "./commands/billing.subscription.upgrade.start.js";
-import { brandkitApplyCommand } from "./commands/brandkit.apply.js";
-import { conversationPurgeCommand } from "./commands/conversation.purge.js";
-import { conversationFilesListCommand } from "./commands/conversation.files.list.js";
-import { documentsPdfCreateCommand } from "./commands/documents.pdf.create.js";
-import { markdownGenerateCommand } from "./commands/markdown.generate.js";
-import { mermaidGenerateCommand } from "./commands/mermaid.generate.js";
-import { formFillCommand } from "./commands/form.fill.js";
-import { orgMemberInviteDeclineCommand } from "./commands/org.member.invite.decline.js";
-import { organizationCreateCommand } from "./commands/organization.create.js";
-import { pluginCredentialSetSecretCommand } from "./commands/plugin.credential.set_secret.js";
-import { pluginOrgInstallBulkCommand } from "./commands/plugin.org.install_bulk.js";
-import { pluginOrgListCommand } from "./commands/plugin.org.list.js";
-import { pluginOrgSetEnabledCommand } from "./commands/plugin.org.set_enabled.js";
-import { pluginRegistryRemoveCommand } from "./commands/plugin.registry.remove.js";
-import { pluginSettingsSetAuthAlertsCommand } from "./commands/plugin.settings.set_auth_alerts.js";
-import { pluginWorkspaceSetEnabledCommand } from "./commands/plugin.workspace.set_enabled.js";
-import { systemInstallInstructionsCommand } from "./commands/system.install.instructions.js";
-import { workflowCancelCommand } from "./commands/workflow.cancel.js";
-import { workflowStatusCommand } from "./commands/workflow.status.js";
-import { userPreferencesReadCommand } from "./commands/user.preferences.read.js";
-import { userPreferencesWriteCommand } from "./commands/user.preferences.write.js";
-import { privacyExportCommand } from "./commands/privacy.export.js";
-import { privacyEraseCommand } from "./commands/privacy.erase.js";
-import { graphNodeUpsertCommand } from "./commands/graph.node.upsert.js";
-import { graphNodeGetCommand } from "./commands/graph.node.get.js";
-import { graphNodeDeleteCommand } from "./commands/graph.node.delete.js";
-import { graphNodeSearchCommand } from "./commands/graph.node.search.js";
-import { graphEdgeUpsertCommand } from "./commands/graph.edge.upsert.js";
-import { graphEdgeDeleteCommand } from "./commands/graph.edge.delete.js";
-import { graphCypherCommand } from "./commands/graph.cypher.js";
-import { ontologyQueryCommand } from "./commands/ontology.query.js";
-import { ontologyNeighborsCommand } from "./commands/ontology.neighbors.js";
-import { auditLogQueryCommand } from "./commands/audit.log.query.js";
-import { webSearchCommand } from "./commands/web.search.js";
-import { webFetchCommand } from "./commands/web.fetch.js";
-import { researchSwarmStartCommand } from "./commands/research.swarm.start.js";
-import { researchSwarmStatusCommand } from "./commands/research.swarm.status.js";
+import pkg from "../package.json" with { type: "json" };
+import { parseModeArg } from "./agent/permissions.js";
+// The Oxagen context engine pulls in DuckDB, a native CommonJS dependency that
+// references a bare `require`. Under pure-ESM execution that global is absent, so
+// loading the store throws "require is not defined". Provide the shim before any
+// code path dynamically imports the context engine.
+{
+    const g = globalThis;
+    if (typeof g.require === "undefined")
+        g.require = createRequire(import.meta.url);
+}
+const { version } = pkg;
 const program = new Command();
 program
     .name("oxagen")
-    .description("Oxagen developer CLI")
-    .version(version);
+    .description("Agentic coding assistant — powered by the Oxagen context engine")
+    .version(version)
+    .argument("[prompt...]", "One-shot prompt (runs and exits)")
+    .option("-m, --model <slug>", "Gateway model slug (overrides config/default)")
+    .option("--agent <name>", "Run the one-shot prompt as a named agent definition")
+    .option("--readonly", "Read-only mode: read/search/explain only — no file edits or commands", false)
+    .option("--mode <mode>", "Permission mode: ask | accept-edits | bypass | readonly (REPL default: ask; one-shot ungated unless set)")
+    .option("--no-pipeline", "Skip prompt evaluation, context injection, and completeness judging")
+    .option("--verbose", "Capture + emit full per-turn telemetry (per-phase timing, model+token+cost, tool results)", false)
+    .action(async (promptWords, opts) => {
+    const prompt = promptWords.join(" ").trim();
+    let mode;
+    if (opts.mode) {
+        mode = parseModeArg(opts.mode);
+        if (!mode) {
+            process.stderr.write(`Error: invalid --mode "${opts.mode}". Use ask, accept-edits, bypass, or readonly.\n`);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    const runOpts = {
+        model: opts.model,
+        readOnly: opts.readonly,
+        mode,
+        bare: opts.pipeline === false,
+        verbose: opts.verbose,
+    };
+    // --agent: run the prompt as a named agent (its prompt, tools, model).
+    if (opts.agent) {
+        if (!prompt) {
+            process.stderr.write("Error: --agent requires a prompt, e.g. `oxagen --agent reviewer \"…\"`.\n");
+            process.exitCode = 1;
+            return;
+        }
+        const { runAgentOneShot } = await import("./repl/one-shot.js");
+        await runAgentOneShot(prompt, opts.agent, runOpts);
+        return;
+    }
+    if (prompt) {
+        // One-shot mode: run prompt, stream response, exit
+        const { runOneShot } = await import("./repl/one-shot.js");
+        await runOneShot(prompt, runOpts);
+    }
+    else if (process.stdout.isTTY) {
+        // Interactive REPL mode
+        const { launchRepl } = await import("./repl/interactive.js");
+        await launchRepl(runOpts);
+    }
+    else {
+        // Piped input — read from stdin
+        const { runFromStdin } = await import("./repl/one-shot.js");
+        await runFromStdin(runOpts);
+    }
+});
+// ── view: agent dashboard ─────────────────────────────────────────────────────
+program
+    .command("view")
+    .description("Launch the agent dashboard (memory, compile, sessions)")
+    .action(async () => {
+    const { launchAgentView } = await import("./tui/agent-view/index.js");
+    launchAgentView();
+});
+// ── agents: the agents screen (fleet) ─────────────────────────────────────────
+program
+    .command("agents")
+    .description("Launch the agents screen — plan a goal, dispatch a fleet, watch it work")
+    .argument("[goal...]", "Goal to plan into tasks and run immediately")
+    .option("--concurrency <n>", "Max agents running at once", (v) => parseInt(v, 10), 4)
+    .option("--readonly", "Read-only agents: read/search/explain only — no file edits or commands", false)
+    .option("--isolate", "Run each agent in its own git worktree; commit + merge work back (no clobbering)", false)
+    .action(async (goal, opts) => {
+    const { launchFleetView } = await import("./tui/fleet-view/index.js");
+    await launchFleetView({
+        cwd: process.cwd(),
+        goal: goal.join(" ").trim() || undefined,
+        concurrency: opts.concurrency,
+        readOnly: opts.readonly,
+        isolate: opts.isolate,
+    });
+});
+// ── daemon: context daemon lifecycle ──────────────────────────────────────────
+const daemon = program
+    .command("daemon")
+    .description("Manage the persistent context daemon");
+daemon
+    .command("start")
+    .description("Start the context daemon (warm indexes, code graph)")
+    .option("--foreground", "Run in foreground (don't daemonize)", false)
+    .action(async (opts) => {
+    const { startDaemon } = await import("./daemon/lifecycle.js");
+    await startDaemon({ foreground: opts.foreground });
+});
+daemon
+    .command("stop")
+    .description("Stop the running context daemon")
+    .action(async () => {
+    const { stopDaemon } = await import("./daemon/lifecycle.js");
+    await stopDaemon();
+});
+daemon
+    .command("status")
+    .description("Show daemon health and uptime")
+    .action(async () => {
+    const { daemonStatus } = await import("./daemon/lifecycle.js");
+    await daemonStatus();
+});
+// ── replay: inspect how a past turn was handled ───────────────────────────────
+program
+    .command("replay")
+    .description("Show how a past turn was handled (prompt, scores, context, model, judge)")
+    .argument("[turn]", "Turn index (1 = most recent) or id; omit for the latest")
+    .option("--list", "List recent turns instead of replaying one", false)
+    .action(async (turn, opts) => {
+    const { handleReplay } = await import("./commands/replay.js");
+    await handleReplay(turn, opts);
+});
+// ── cost: project + report model cost from the baked-in rate card ─────────────
 program
-    .command("dev")
-    .description("Show the current dev stack status")
-    .action(() => {
-    render(_jsx(DevStatus, {}));
-});
-// auth
-const auth = program.command("auth").description("Authentication commands");
-auth.addCommand(authLoginCommand);
-auth.addCommand(authLogoutCommand);
-auth.addCommand(authWhoamiCommand);
-// org
-const org = program.command("org").description("Organization commands");
-org.addCommand(orgListCommand);
-org.addCommand(orgCreateCommand);
-const orgMember = org.command("member").description("Org member management");
-orgMember.addCommand(orgMemberAddCommand);
-orgMember.addCommand(orgMemberRemoveCommand);
-orgMember.addCommand(orgMemberRoleChangeCommand);
-const orgMemberInvite = orgMember.command("invite").description("Org member invitations");
-orgMemberInvite.addCommand(orgMemberInviteAcceptCommand);
-orgMemberInvite.addCommand(orgMemberInviteDeclineCommand);
-org.addCommand(organizationCreateCommand);
-// workspace
-const workspace = program.command("workspace").description("Workspace commands");
-workspace.addCommand(workspaceListCommand);
-workspace.addCommand(workspaceCreateCommand);
-// chat
-const chat = program.command("chat").description("Chat and messaging commands");
-chat.addCommand(chatSendCommand);
-// conversation
-const conversation = program.command("conversation").description("Conversation management");
-conversation.addCommand(conversationListCommand);
-conversation.addCommand(conversationDeleteCommand);
-conversation.addCommand(conversationArchiveCommand);
-conversation.addCommand(conversationRenameCommand);
-// api-key
-const apiKey = program.command("api-key").description("API key management");
-apiKey.addCommand(apiKeyCreateCommand);
-apiKey.addCommand(apiKeyRevokeCommand);
-// notifications
-const notifications = program.command("notifications").description("Notification management");
-notifications.addCommand(notificationsListCommand);
-notifications.addCommand(notificationsMarkCommand);
-// plugin
-const plugin = program.command("plugin").description("Plugin marketplace commands");
-plugin.addCommand(pluginListCommand);
-plugin.addCommand(pluginInstallCommand);
-plugin.addCommand(pluginUninstallCommand);
-const pluginOrg = plugin.command("org").description("Plugin organization management");
-pluginOrg.addCommand(pluginOrgInstallCommand);
-pluginOrg.addCommand(pluginOrgUninstallCommand);
-const pluginCatalog = plugin.command("catalog").description("Plugin catalog");
-pluginCatalog.addCommand(pluginCatalogGetCommand);
-pluginCatalog.addCommand(pluginCatalogBrowseCommand);
-const pluginRegistry = plugin.command("registry").description("Plugin registry management");
-pluginRegistry.addCommand(pluginRegistryListCommand);
-pluginRegistry.addCommand(pluginRegistryAddCommand);
-pluginRegistry.addCommand(pluginRegistryRemoveCommand);
-const pluginCredential = plugin.command("credential").description("Plugin credential management");
-pluginCredential.addCommand(pluginCredentialReauthCommand);
-pluginCredential.addCommand(pluginCredentialSetSecretCommand);
-pluginOrg.addCommand(pluginOrgInstallBulkCommand);
-pluginOrg.addCommand(pluginOrgListCommand);
-pluginOrg.addCommand(pluginOrgSetEnabledCommand);
-const pluginSettings = plugin.command("settings").description("Plugin settings");
-pluginSettings.addCommand(pluginSettingsSetAuthAlertsCommand);
-pluginOrg.addCommand(pluginWorkspaceSetEnabledCommand);
-// billing
-const billing = program.command("billing").description("Billing and subscription commands");
-billing.addCommand(billingStatusCommand);
-billing.addCommand(billingCreditsPurchaseCommand);
-billing.addCommand(billingSubscriptionReadCommand);
-const billingSubscription = billing.command("subscription").description("Subscription management");
-billingSubscription.addCommand(billingSubscriptionUpgradeStartCommand);
-// agent
-const agent = program.command("agent").description("Agent commands");
-const agentMcp = agent.command("mcp").description("MCP server management");
-agentMcp.addCommand(agentMcpListCommand);
-const agentSkill = agent.command("skill").description("Agent skill management");
-agentSkill.addCommand(agentSkillListCommand);
-const agentTool = agent.command("tool").description("Agent tool management");
-agentTool.addCommand(agentToolListCommand);
-const agentApproval = agent.command("approval").description("Agent approval management");
-agentApproval.addCommand(agentApprovalResolveCommand);
-const agentMemory = agent.command("memory").description("Agent memory management");
-agentMemory.addCommand(agentMemoryRecallCommand);
-agentMemory.addCommand(agentMemoryWriteCommand);
-agentMcp.addCommand(agentMcpRegisterCommand);
-agentMcp.addCommand(agentMcpSetEnabledCommand);
-agentMcp.addCommand(agentMcpDeleteCommand);
-const agentMcpConsent = agentMcp.command("consent").description("External MCP tool consent grants");
-agentMcpConsent.addCommand(agentMcpConsentResolveCommand);
-agentMcpConsent.addCommand(agentMcpConsentListCommand);
-const agentPlan = agent.command("plan").description("Agent plan management");
-agentPlan.addCommand(agentPlanApproveCommand);
-agentPlan.addCommand(agentPlanCreateCommand);
-const agentTask = agent.command("task").description("Agent task management");
-const agentTaskBackground = agentTask.command("background").description("Background task management");
-agentTaskBackground.addCommand(agentTaskBackgroundReadCommand);
-agentTaskBackground.addCommand(agentTaskBackgroundStartCommand);
-agentTaskBackground.addCommand(agentTaskBackgroundCancelCommand);
-// archive
-const archive = program.command("archive").description("Archive management");
-archive.addCommand(archiveCreateCommand);
-// asset
-const asset = program.command("asset").description("Asset management");
-asset.addCommand(assetUploadCommand);
-// brandkit
-const brandkit = program.command("brandkit").description("Brand kit commands");
-brandkit.addCommand(brandkitApplyCommand);
-// workflow
-const workflow = program.command("workflow").description("Workflow automation");
-workflow.addCommand(workflowRunCommand);
-workflow.addCommand(workflowCancelCommand);
-workflow.addCommand(workflowStatusCommand);
-// system
-const system = program.command("system").description("System commands");
-system.addCommand(systemInstallInstructionsCommand);
-// user
-const user = program.command("user").description("User account commands");
-const userPreferences = user.command("preferences").description("User preference management");
-userPreferences.addCommand(userPreferencesGetCommand);
-userPreferences.addCommand(userPreferencesUpdateCommand);
-userPreferences.addCommand(userPreferencesReadCommand);
-userPreferences.addCommand(userPreferencesWriteCommand);
-// workspace member + invite
-const workspaceMember = workspace.command("member").description("Workspace member management");
-workspaceMember.addCommand(workspaceMemberListCommand);
-const workspaceInvite = workspace.command("invite").description("Workspace invitation management");
-workspaceInvite.addCommand(workspaceInviteSendCommand);
-const workspaceModel = workspace.command("model").description("Workspace model settings");
-const workspaceModelSettings = workspaceModel.command("settings").description("Model settings management");
-workspaceModelSettings.addCommand(workspaceModelSettingsReadCommand);
-workspaceModelSettings.addCommand(workspaceModelSettingsWriteCommand);
-// conversation chat + purge
-conversation.addCommand(conversationChatCommand);
-conversation.addCommand(conversationPurgeCommand);
-conversation.addCommand(conversationFilesListCommand);
-// image
-const image = program.command("image").description("Image generation commands");
-image.addCommand(imageCreateCommand);
-image.addCommand(imageListCommand);
-image.addCommand(imageAnalyzeCommand);
-image.addCommand(imageGenerateCommand);
-// document
-const document = program.command("document").description("Document management commands");
-document.addCommand(documentCreateCommand);
-document.addCommand(documentListCommand);
-document.addCommand(documentReadCommand);
-const documents = program.command("documents").description("Document generation commands");
-documents.addCommand(documentsGenerateCommand);
-documents.addCommand(documentsPdfCreateCommand);
-documents.addCommand(markdownGenerateCommand);
-// mermaid (diagram generation — top-level group like svg/video)
-const mermaid = program.command("mermaid").description("Mermaid diagram generation commands");
-mermaid.addCommand(mermaidGenerateCommand);
-// automation
-const automation = program.command("automation").description("Automation management commands");
-automation.addCommand(automationListCommand);
-automation.addCommand(automationCreateCommand);
-automation.addCommand(automationUpdateCommand);
-automation.addCommand(automationEnableCommand);
-automation.addCommand(automationDisableCommand);
-automation.addCommand(automationTriggerCommand);
-// form
-const form = program.command("form").description("Form management commands");
-form.addCommand(formCreateCommand);
-form.addCommand(formSubmitCommand);
-form.addCommand(formFillCommand);
-// skill
-const skill = program.command("skill").description("Skill management commands");
-const skillWorkspace = skill.command("workspace").description("Workspace skill management");
-skillWorkspace.addCommand(skillWorkspaceListCommand);
-skillWorkspace.addCommand(skillWorkspaceInstallCommand);
-const skillVersion = skill.command("version").description("Skill version management");
-skillVersion.addCommand(skillVersionListCommand);
-skillVersion.addCommand(skillVersionGetCommand);
-skillVersion.addCommand(skillVersionUploadCommand);
-skillVersion.addCommand(skillVersionActivateCommand);
-skill.addCommand(skillEditCommand);
-skill.addCommand(skillExportCommand);
-skill.addCommand(skillMetricsReadCommand);
-// video
-const video = program.command("video").description("Video generation commands");
-video.addCommand(videoGenerateCommand);
-// svg
-const svg = program.command("svg").description("SVG generation commands");
-svg.addCommand(svgGenerateCommand);
-// privacy (GDPR Art.17 erasure + Art.20 portability)
-const privacy = program.command("privacy").description("GDPR privacy rights — data export and erasure");
-privacy.addCommand(privacyExportCommand);
-privacy.addCommand(privacyEraseCommand);
-// graph
-const graph = program.command("graph").description("Knowledge graph commands");
-const graphNode = graph.command("node").description("Graph node management");
-graphNode.addCommand(graphNodeUpsertCommand);
-graphNode.addCommand(graphNodeGetCommand);
-graphNode.addCommand(graphNodeDeleteCommand);
-graphNode.addCommand(graphNodeSearchCommand);
-const graphEdge = graph.command("edge").description("Graph edge management");
-graphEdge.addCommand(graphEdgeUpsertCommand);
-graphEdge.addCommand(graphEdgeDeleteCommand);
-graph.addCommand(graphCypherCommand);
-// ontology
-const ontology = program
-    .command("ontology")
-    .description("Typed knowledge-graph traversal commands");
-ontology.addCommand(ontologyQueryCommand);
-ontology.addCommand(ontologyNeighborsCommand);
-// audit
-const audit = program.command("audit").description("Audit-log commands");
-const auditLog = audit.command("log").description("Query the security & automation audit spines");
-auditLog.addCommand(auditLogQueryCommand);
-// web
-const web = program.command("web").description("Web intelligence commands");
-web.addCommand(webSearchCommand);
-web.addCommand(webFetchCommand);
-// research
-const research = program.command("research").description("Research swarm commands");
-const researchSwarm = research.command("swarm").description("Research swarm management");
-researchSwarm.addCommand(researchSwarmStartCommand);
-researchSwarm.addCommand(researchSwarmStatusCommand);
-program.parse(process.argv);
-if (program.args.length === 0) {
-    program.outputHelp();
+    .command("cost")
+    // The root's global `-m, --model` is reused (commander binds it to the parent),
+    // so the action reads merged opts via optsWithGlobals() to see --model here.
+    .description("Project model cost from the baked-in rate card, or roll up this project's spend")
+    .option("--in <tokens>", "Input token count to price", (v) => parseInt(v, 10))
+    .option("--out <tokens>", "Output token count to price", (v) => parseInt(v, 10))
+    .option("--rates", "Print the baked-in rate card", false)
+    .option("--session", "Roll up what this project's recorded turns actually cost, by model", false)
+    .option("--json", "Output JSON", false)
+    .action(async (_opts, command) => {
+    const merged = command.optsWithGlobals();
+    const { handleCost } = await import("./commands/cost.js");
+    await handleCost(merged);
+});
+// ── graph: knowledge-graph search + pull + status ─────────────────────────────
+const graph = program.command("graph").description("Query the knowledge graph");
+graph
+    .command("search")
+    .description("Unified semantic (vector) search across the entire knowledge graph")
+    .requiredOption("-q, --query <text>", "Natural-language query to search by vector similarity")
+    .option("-k, --kinds <kinds>", "Comma-separated node kinds (entity,file,symbol,chunk,memory,execution,document,message)")
+    .option("-l, --labels <labels>", "Comma-separated domain labels (e.g. Person,SourceFile)")
+    .option("-n, --limit <n>", "Maximum number of results (1–50)", "10")
+    .option("--system", "Only return product-owned (system) nodes")
+    .option("--no-system", "Only return customer nodes (exclude system nodes)")
+    .action(async (opts) => {
+    const { handleGraphSearch } = await import("./commands/graph.search.js");
+    await handleGraphSearch(opts);
+});
+graph
+    .command("pull")
+    .description("Download an incremental snapshot of the workspace graph into a local DuckDB replica")
+    .option("--full", "Ignore the saved cursor and re-pull the entire graph", false)
+    .option("-l, --labels <csv>", "Comma-separated domain labels to filter (e.g. Person,SourceFile)")
+    .option("--no-system", "Exclude product-owned (system) nodes")
+    .option("--json", "Output summary as JSON")
+    .action(async (opts) => {
+    const { handleGraphPull } = await import("./commands/graph.pull.js");
+    await handleGraphPull({
+        full: opts.full,
+        labels: opts.labels,
+        noSystem: opts.system === false,
+        json: opts.json,
+    });
+});
+graph
+    .command("status")
+    .description("Show the state of the local workspace-graph replica")
+    .option("--json", "Output as JSON")
+    .action(async (opts) => {
+    const { handleGraphStatus } = await import("./commands/graph.status.js");
+    await handleGraphStatus(opts);
+});
+// ── config: local configuration ───────────────────────────────────────────────
+program
+    .command("config")
+    .description("View or set configuration (api key, model, etc.)")
+    .argument("[key]", "Config key to get/set")
+    .argument("[value]", "Value to set (omit to read)")
+    .action(async (key, value) => {
+    const { handleConfig } = await import("./commands/config.js");
+    await handleConfig(key, value);
+});
+// ── settings: the unified settings.json driver ────────────────────────────────
+const settings = program
+    .command("settings")
+    .description("Inspect and edit the unified settings.json (model, env, permissions, hooks, MCP)")
+    .action(async () => {
+    const { settingsShow } = await import("./commands/settings.js");
+    settingsShow();
+});
+settings
+    .command("show")
+    .description("Show the merged settings and which scope each file lives in")
+    .action(async () => {
+    const { settingsShow } = await import("./commands/settings.js");
+    settingsShow();
+});
+settings
+    .command("path")
+    .description("List the three scope files (user / project / local) and their status")
+    .action(async () => {
+    const { settingsPath } = await import("./commands/settings.js");
+    settingsPath();
+});
+settings
+    .command("get")
+    .description("Print a value by dotted key (e.g. permissions.defaultMode)")
+    .argument("<key>", "Dotted settings key")
+    .action(async (key) => {
+    const { settingsGet } = await import("./commands/settings.js");
+    settingsGet(key);
+});
+settings
+    .command("set")
+    .description("Set a value (model | apiUrl | env.NAME) in a scope")
+    .argument("<key>", "model, apiUrl, or env.NAME")
+    .argument("<value>", "Value to write")
+    .option("--scope <scope>", "user | project | local (default: project)")
+    .action(async (key, value, opts) => {
+    const { settingsSet } = await import("./commands/settings.js");
+    settingsSet(key, value, opts.scope);
+});
+settings
+    .command("validate")
+    .description("Validate every scope file against the settings schema")
+    .action(async () => {
+    const { settingsValidate } = await import("./commands/settings.js");
+    settingsValidate();
+});
+settings
+    .command("init")
+    .description("Write a documented starter settings.json (default: project scope)")
+    .option("--scope <scope>", "user | project | local (default: project)")
+    .action(async (opts) => {
+    const { settingsInit } = await import("./commands/settings.js");
+    settingsInit(opts.scope);
+});
+// ── agent: named agent definitions ────────────────────────────────────────────
+const agent = program
+    .command("agent")
+    .description("Manage named agent definitions (run one with `oxagen --agent <name> \"…\"`)");
+agent
+    .command("list")
+    .description("List available agents")
+    .action(async () => {
+    const { agentList } = await import("./commands/agent.js");
+    agentList();
+});
+agent
+    .command("show")
+    .description("Show an agent's definition and system prompt")
+    .argument("<name>", "Agent name")
+    .action(async (name) => {
+    const { agentShow } = await import("./commands/agent.js");
+    agentShow(name);
+});
+agent
+    .command("new")
+    .description("Scaffold a new agent at .oxagen/agents/<name>.md")
+    .argument("<name>", "Agent name")
+    .action(async (name) => {
+    const { agentNew } = await import("./commands/agent.js");
+    agentNew(name);
+});
+// ── command: user-defined slash commands ──────────────────────────────────────
+const command = program
+    .command("command")
+    .description("Manage user-defined slash commands (invoke as `/name` in the REPL)");
+command
+    .command("list")
+    .description("List available slash commands")
+    .action(async () => {
+    const { commandList } = await import("./commands/command.js");
+    commandList();
+});
+command
+    .command("show")
+    .description("Show a slash command's template")
+    .argument("<name>", "Command name")
+    .action(async (name) => {
+    const { commandShow } = await import("./commands/command.js");
+    commandShow(name);
+});
+command
+    .command("new")
+    .description("Scaffold a new slash command at .oxagen/commands/<name>.md")
+    .argument("<name>", "Command name")
+    .action(async (name) => {
+    const { commandNew } = await import("./commands/command.js");
+    commandNew(name);
+});
+command
+    .command("run")
+    .description("Expand a slash command's template with args and run it as a turn")
+    .argument("<name>", "Command name")
+    .argument("[args...]", "Arguments substituted into the template")
+    .action(async (name, args) => {
+    const { commandRun } = await import("./commands/command.js");
+    await commandRun(name, args ?? []);
+});
+// ── rules: workspace rules the agent must follow ──────────────────────────────
+const rules = program
+    .command("rules")
+    .description("Manage workspace rules the agent is told about and hard-blocked from violating");
+rules
+    .command("list")
+    .description("List rules (and which are hard-enforced)")
+    .action(async () => {
+    const { rulesList } = await import("./commands/rules.js");
+    rulesList();
+});
+rules
+    .command("show")
+    .description("Show a rule's text and guard")
+    .argument("<name>", "Rule name")
+    .action(async (name) => {
+    const { rulesShow } = await import("./commands/rules.js");
+    rulesShow(name);
+});
+rules
+    .command("new")
+    .description("Scaffold a new rule at .oxagen/rules/<name>.md")
+    .argument("<name>", "Rule name")
+    .action(async (name) => {
+    const { rulesNew } = await import("./commands/rules.js");
+    rulesNew(name);
+});
+rules
+    .command("check")
+    .description("Dry-run a proposed tool call against the guards (bash|edit|write|read)")
+    .argument("<tool>", "bash | edit | write | read")
+    .argument("<subject>", "The command (bash) or path (edit/write/read) to test")
+    .action(async (tool, subject) => {
+    const { rulesCheck } = await import("./commands/rules.js");
+    rulesCheck(tool, subject);
+});
+// ── mcp: external MCP servers ─────────────────────────────────────────────────
+const collect = (val, prev) => prev.concat([val]);
+const mcp = program
+    .command("mcp")
+    .description("Manage external MCP servers the agent loop connects to");
+mcp
+    .command("add")
+    .description("Add an MCP server (stdio via --command, or http/sse/websocket via --url)")
+    .argument("<name>", "Server name (used in tool names: mcp__<name>__<tool>)")
+    .option("--command <command>", "stdio: the command to spawn (e.g. npx)")
+    .option("--arg <arg>", "stdio: a command argument (repeatable)", collect, [])
+    .option("--url <url>", "http/sse/websocket: the server URL")
+    .option("--transport <transport>", "streamable-http | sse | websocket (default streamable-http)")
+    .option("--auth <auth>", "none | bearer | header (default none)")
+    .option("--env-token <VAR>", "Env var holding the bearer token")
+    .option("--header <KEY=VALUE>", "Static header for header auth (repeatable)", collect, [])
+    .option("--scope <scope>", "user | project | local (default project)")
+    .action(async (name, opts) => {
+    const { mcpAdd } = await import("./commands/mcp.js");
+    mcpAdd(name, {
+        command: opts["command"],
+        arg: opts["arg"],
+        url: opts["url"],
+        transport: opts["transport"],
+        auth: opts["auth"],
+        envToken: opts["envToken"],
+        header: opts["header"],
+        scope: opts["scope"],
+    });
+});
+mcp
+    .command("list")
+    .description("List configured MCP servers")
+    .action(async () => {
+    const { mcpList } = await import("./commands/mcp.js");
+    mcpList();
+});
+mcp
+    .command("remove")
+    .description("Remove an MCP server")
+    .argument("<name>", "Server name")
+    .option("--scope <scope>", "Limit to a scope (default: auto-detect)")
+    .action(async (name, opts) => {
+    const { mcpRemove } = await import("./commands/mcp.js");
+    mcpRemove(name, opts.scope);
+});
+mcp
+    .command("enable")
+    .description("Enable a disabled MCP server")
+    .argument("<name>", "Server name")
+    .option("--scope <scope>", "Limit to a scope (default: auto-detect)")
+    .action(async (name, opts) => {
+    const { mcpSetEnabled } = await import("./commands/mcp.js");
+    mcpSetEnabled(name, true, opts.scope);
+});
+mcp
+    .command("disable")
+    .description("Disable an MCP server without removing it")
+    .argument("<name>", "Server name")
+    .option("--scope <scope>", "Limit to a scope (default: auto-detect)")
+    .action(async (name, opts) => {
+    const { mcpSetEnabled } = await import("./commands/mcp.js");
+    mcpSetEnabled(name, false, opts.scope);
+});
+mcp
+    .command("check")
+    .description("Connect to a server (or all enabled) and preview the tools it exposes")
+    .argument("[name]", "Server name (omit to check all enabled)")
+    .action(async (name) => {
+    const { mcpCheck } = await import("./commands/mcp.js");
+    await mcpCheck(name);
+});
+// ── env: workspace environments ───────────────────────────────────────────────
+const env = program.command("env").description("Manage workspace environments");
+env
+    .command("list")
+    .description("List environments in the active workspace")
+    .option("--json", "Output JSON")
+    .action(async (opts) => {
+    const { handleEnvList } = await import("./commands/env.js");
+    await handleEnvList(opts);
+});
+env
+    .command("get")
+    .description("Show one environment")
+    .argument("<idOrSlug>", "Environment public id or slug")
+    .action(async (idOrSlug) => {
+    const { handleEnvGet } = await import("./commands/env.js");
+    await handleEnvGet(idOrSlug, {});
+});
+env
+    .command("create")
+    .description("Create an environment")
+    .argument("<name>", "Display name")
+    .option("--slug <slug>", "Slug (defaults to a slugified name)")
+    .option("--description <text>", "Description")
+    .action(async (name, opts) => {
+    const { handleEnvCreate } = await import("./commands/env.js");
+    await handleEnvCreate(name, opts);
+});
+env
+    .command("update")
+    .description("Update an environment")
+    .argument("<idOrSlug>", "Environment public id or slug")
+    .option("--name <name>", "New display name")
+    .option("--slug <slug>", "New slug")
+    .option("--description <text>", "New description")
+    .option("--active", "Activate")
+    .option("--inactive", "Deactivate (not allowed on the default)")
+    .action(async (idOrSlug, opts) => {
+    const { handleEnvUpdate } = await import("./commands/env.js");
+    const active = opts.active ? true : opts.inactive ? false : undefined;
+    await handleEnvUpdate(idOrSlug, {
+        name: opts.name,
+        slug: opts.slug,
+        description: opts.description,
+        active,
+    });
+});
+env
+    .command("rm")
+    .description("Delete an environment (not the default)")
+    .argument("<idOrSlug>", "Environment public id or slug")
+    .action(async (idOrSlug) => {
+    const { handleEnvRemove } = await import("./commands/env.js");
+    await handleEnvRemove(idOrSlug);
+});
+env
+    .command("set-default")
+    .description("Promote an environment to the workspace default")
+    .argument("<idOrSlug>", "Environment public id or slug")
+    .action(async (idOrSlug) => {
+    const { handleEnvSetDefault } = await import("./commands/env.js");
+    await handleEnvSetDefault(idOrSlug);
+});
+// ── secret: credential vault ──────────────────────────────────────────────────
+const secret = program.command("secret").description("Manage the workspace credential vault");
+secret
+    .command("list")
+    .description("List vault keys (masked metadata)")
+    .option("--json", "Output JSON")
+    .action(async (opts) => {
+    const { handleSecretList } = await import("./commands/secret.js");
+    await handleSecretList(opts);
+});
+secret
+    .command("set")
+    .description("Set a secret's default value, or an override with --env")
+    .argument("<key>", "Secret key name")
+    .argument("<value>", "Value")
+    .option("--env <slug>", "Target environment (override); omit for the default value")
+    .option("--no-sensitive", "Store as plaintext config (default: sensitive/encrypted)")
+    .action(async (key, value, opts) => {
+    const { handleSecretSet } = await import("./commands/secret.js");
+    await handleSecretSet(key, value, opts);
+});
+secret
+    .command("rm")
+    .description("Delete a key, or just an environment override with --env")
+    .argument("<key>", "Secret key name")
+    .option("--env <slug>", "Remove only this environment's override")
+    .action(async (key, opts) => {
+    const { handleSecretRemove } = await import("./commands/secret.js");
+    await handleSecretRemove(key, opts);
+});
+secret
+    .command("reveal")
+    .description("Reveal a secret's plaintext value (recorded to the access log)")
+    .argument("<key>", "Secret key name")
+    .option("--env <slug>", "Resolve for this environment")
+    .action(async (key, opts) => {
+    const { handleSecretReveal } = await import("./commands/secret.js");
+    await handleSecretReveal(key, opts);
+});
+secret
+    .command("import")
+    .description("Import .env text (preview unless --yes)")
+    .option("--env <slug>", "Target environment overrides; omit for default values")
+    .option("-f, --file <path>", "Read from a file (else stdin)")
+    .option("--yes", "Commit (otherwise preview only)")
+    .action(async (opts) => {
+    const { handleSecretImport } = await import("./commands/secret.js");
+    await handleSecretImport(opts);
+});
+secret
+    .command("export")
+    .description("Export resolved secrets as .env (recorded to the access log)")
+    .option("--env <slug>", "Resolve for this environment")
+    .option("-o, --out <path>", "Write to a file (else stdout)")
+    .action(async (opts) => {
+    const { handleSecretExport } = await import("./commands/secret.js");
+    await handleSecretExport(opts);
+});
+async function main() {
+    // Project settings.json (env, apiUrl, model) into the environment before any
+    // command runs — filling only unset vars, so the shell always wins.
+    const { applySettingsToEnv } = await import("./settings/runtime.js");
+    applySettingsToEnv();
+    await program.parseAsync(process.argv);
 }
+void main();
 //# sourceMappingURL=index.js.map