@smithers-orchestrator/cli 0.16.8 → 0.17.0

package/src/index.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env bun
+import { setJsonMode } from "./util/logger.ts";
 import { resolve, dirname, basename } from "node:path";
 import { pathToFileURL } from "node:url";
-import { readFileSync, existsSync, openSync } from "node:fs";
+import { readFileSync, existsSync, openSync, statSync, mkdirSync, writeFileSync } from "node:fs";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { Effect, Fiber } from "effect";
 import { Cli, Mcp as IncurMcp, z } from "incur";
 import { isRunHeartbeatFresh, runWorkflow, renderFrame, resolveSchema } from "@smithers-orchestrator/engine";
-import { mdxPlugin } from "smithers-orchestrator/mdx-plugin";
+import { mdxPlugin } from "./mdx-plugin.js";
 import { approveNode, denyNode } from "@smithers-orchestrator/engine/approvals";
 import { signalRun } from "@smithers-orchestrator/engine/signals";
 import { loadInput, loadOutputs } from "@smithers-orchestrator/db/snapshot";
@@ -34,6 +35,9 @@ import { EVENT_CATEGORY_VALUES, eventTypesForCategory, normalizeEventCategory, }
 import { aggregateNodeDetailEffect, renderNodeDetailHuman, } from "./node-detail.js";
 import { diagnoseRunEffect, diagnosisCtaCommands, renderWhyDiagnosisHuman, } from "./why-diagnosis.js";
 import { detectAvailableAgents } from "./agent-detection.js";
+import { listAccounts, removeAccount } from "@smithers-orchestrator/accounts";
+import { runAgentAdd, pingAccount } from "./agent-commands/runAgentAdd.js";
+import { agentAddWizard } from "./agent-commands/agentAddWizard.js";
 import { initWorkflowPack, getWorkflowFollowUpCtas } from "./workflow-pack.js";
 import { discoverWorkflows, resolveWorkflow, createWorkflowFile } from "./workflows.js";
 import { ask } from "./ask.js";
@@ -45,6 +49,7 @@ import { WATCH_MIN_INTERVAL_MS, runWatchLoop, watchIntervalSecondsToMs, } from "
 import { createSemanticMcpServer } from "./mcp/semantic-server.js";
 import pc from "picocolors";
 import crypto from "node:crypto";
+import React from "react";
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -91,7 +96,7 @@ async function loadWorkflowDb(workflowPath) {
  */
 function readPackageVersion() {
     try {
-        const pkgUrl = new URL("../../package.json", import.meta.url);
+        const pkgUrl = new URL("../package.json", import.meta.url);
         const raw = readFileSync(pkgUrl, "utf8");
         const parsed = JSON.parse(raw);
         return typeof parsed.version === "string" ? parsed.version : "unknown";
@@ -100,6 +105,39 @@ function readPackageVersion() {
         return "unknown";
     }
 }
+function smithersTokenStorePath() {
+    return process.env.SMITHERS_TOKEN_STORE ?? resolve(process.env.HOME ?? process.cwd(), ".smithers", "tokens.json");
+}
+function readSmithersTokenStore() {
+    const path = smithersTokenStorePath();
+    if (!existsSync(path)) {
+        return { tokens: {} };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+            return { tokens: {} };
+        }
+        const tokens = parsed.tokens && typeof parsed.tokens === "object" && !Array.isArray(parsed.tokens)
+            ? parsed.tokens
+            : {};
+        return { tokens };
+    }
+    catch {
+        return { tokens: {} };
+    }
+}
+function writeSmithersTokenStore(store) {
+    const path = smithersTokenStorePath();
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(store, null, 2)}\n`, { mode: 0o600 });
+}
+function parseTokenScopes(raw) {
+    return raw
+        .split(/[,\s]+/)
+        .map((scope) => scope.trim())
+        .filter(Boolean);
+}
 const CLI_ARGUMENT_MAX_LENGTH = 4096;
 const CLI_IDENTIFIER_MAX_LENGTH = 256;
 const CLI_TEXT_ARGUMENT_MAX_LENGTH = 64 * 1024;
@@ -1242,6 +1280,10 @@ const chatOptions = z.object({
     tail: z.number().int().min(1).optional().describe("Show only the last N chat blocks"),
     stderr: z.boolean().default(true).describe("Include agent stderr output"),
 });
+const chatCreateOptions = z.object({
+    agent: z.enum(["claude-code", "codex", "gemini"]).describe("CLI agent engine to launch"),
+    cwd: z.string().optional().describe("Working directory for the chat session (default: current directory)"),
+});
 const inspectArgs = z.object({
     runId: z.string().describe("Run ID to inspect"),
 });
@@ -1320,7 +1362,9 @@ const revertOptions = z.object({
 });
 const initOptions = z.object({
     force: z.boolean().default(false).describe("Overwrite existing scaffold files"),
+    agentsOnly: z.boolean().default(false).describe("Only create .smithers/agents/ and leave the rest of the workflow pack untouched"),
     install: z.boolean().default(true).describe("Run `bun install` inside .smithers/ after scaffolding (--no-install to skip)"),
+    addAgents: z.boolean().default(false).describe("After scaffolding, launch the interactive `agents add` wizard to register one or more accounts."),
 });
 const workflowPathArgs = z.object({
     name: z.string().describe("Workflow ID"),
@@ -1894,7 +1938,7 @@ const cronCli = Cli.create({
 });
 const agentsCli = Cli.create({
     name: "agents",
-    description: "Inspect built-in CLI agent capability registries.",
+    description: "Inspect and register subscriptions and api keys.",
 })
     .command("capabilities", {
     description: "Print a JSON report of the built-in CLI agent capability registries.",
@@ -1911,7 +1955,7 @@ const agentsCli = Cli.create({
     run(c) {
         const report = getCliAgentCapabilityDoctorReport();
         commandExitOverride = report.ok ? 0 : 1;
-        if (c.options.json) {
+        if (c.options.json || c.format === "json") {
             process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
         }
         else {
@@ -1919,6 +1963,128 @@ const agentsCli = Cli.create({
         }
         return c.ok(undefined);
     },
+})
+    .command("add", {
+    description: "Register a Smithers agent account (interactive wizard, or non-interactive via flags).",
+    options: z.object({
+        provider: z.enum([
+            "claude-code", "codex", "gemini", "kimi",
+            "anthropic-api", "openai-api", "gemini-api",
+        ]).optional().describe("Provider id; omit to launch the interactive wizard"),
+        label: z.string().optional().describe("Unique label, e.g. 'claude-work'"),
+        configDir: z.string().optional().describe("Path to the per-account CLI config dir (subscription providers)"),
+        apiKey: z.string().optional().describe("API key (api-key providers only)"),
+        model: z.string().optional().describe("Default model for this account"),
+        skipLogin: z.boolean().default(false).describe("Skip the 'is the dir populated?' check (advanced)"),
+        force: z.boolean().default(false).describe("Register even if no credentials are present"),
+        replace: z.boolean().default(false).describe("Overwrite an existing account with the same label"),
+        loop: z.boolean().default(false).describe("Wizard mode only: keep adding accounts until you say done"),
+    }),
+    async run(c) {
+        // Flag-driven mode: provider+label given → just register.
+        if (c.options.provider && c.options.label) {
+            try {
+                const result = runAgentAdd({
+                    provider: c.options.provider,
+                    label: c.options.label,
+                    configDir: c.options.configDir,
+                    apiKey: c.options.apiKey,
+                    model: c.options.model,
+                    skipLogin: c.options.skipLogin,
+                    force: c.options.force,
+                    replace: c.options.replace,
+                });
+                if (!result.ok) {
+                    const code = result.reason === "login-required" ? 2 : 1;
+                    commandExitOverride = code;
+                    return c.error({
+                        code: result.reason === "login-required"
+                            ? "AGENT_LOGIN_REQUIRED"
+                            : "AGENT_ADD_FAILED",
+                        message: result.detail ?? result.reason,
+                        exitCode: code,
+                    });
+                }
+                return c.ok({
+                    account: result.account,
+                    regen: result.regen,
+                });
+            }
+            catch (err) {
+                commandExitOverride = 1;
+                return c.error({
+                    code: err?.code ?? "AGENT_ADD_FAILED",
+                    message: err?.message ?? String(err),
+                    exitCode: 1,
+                });
+            }
+        }
+        // Interactive wizard mode.
+        const labels = await agentAddWizard({ loop: c.options.loop });
+        return c.ok({ added: labels });
+    },
+})
+    .command("list", {
+    description: "List all registered Smithers agent accounts. Use --format json for machine output.",
+    run(c) {
+        const accounts = listAccounts();
+        if (accounts.length === 0) {
+            process.stderr.write("No accounts registered. Add one with `smithers agents add`.\n");
+            return c.ok({ accounts });
+        }
+        const rows = accounts.map((a) => {
+            const where = a.configDir ?? (a.apiKey ? "(api key set)" : "");
+            return `  ${a.label.padEnd(24)}  ${a.provider.padEnd(14)}  ${where}`;
+        });
+        process.stderr.write(`Registered accounts (${accounts.length}):\n${rows.join("\n")}\n`);
+        return c.ok({ accounts });
+    },
+})
+    .command("remove", {
+    description: "Remove a Smithers agent account by label.",
+    args: z.object({ label: z.string().describe("Account label to remove") }),
+    options: z.object({
+        silent: z.boolean().default(false).describe("Do not error if the label is not registered"),
+    }),
+    async run(c) {
+        try {
+            const removed = removeAccount(c.args.label, { silent: c.options.silent });
+            if (removed) {
+                const { regenerateAgentsTsIfPresent } = await import("./agent-commands/regenerateAgentsTsIfPresent.js");
+                const regen = regenerateAgentsTsIfPresent();
+                process.stdout.write(`Removed ${c.args.label}.\n`);
+                return c.ok({ removed: true, label: c.args.label, regen });
+            }
+            return c.ok({ removed: false, label: c.args.label });
+        }
+        catch (err) {
+            commandExitOverride = 1;
+            return c.error({
+                code: err?.code ?? "AGENT_REMOVE_FAILED",
+                message: err?.message ?? String(err),
+                exitCode: 1,
+            });
+        }
+    },
+})
+    .command("test", {
+    description: "Spawn the account's underlying CLI with --version to verify it is reachable.",
+    args: z.object({ label: z.string().describe("Account label to ping") }),
+    run(c) {
+        const account = listAccounts().find((a) => a.label === c.args.label);
+        if (!account) {
+            commandExitOverride = 1;
+            return c.error({
+                code: "ACCOUNT_NOT_FOUND",
+                message: `No account with label "${c.args.label}" is registered.`,
+                exitCode: 1,
+            });
+        }
+        const ping = pingAccount(account);
+        process.stdout.write(`Ran: ${ping.cmd}\nExit: ${ping.exitCode ?? "<n/a>"}\n`);
+        if (ping.ran && ping.exitCode !== 0) commandExitOverride = 1;
+        return c.ok({ account, ping });
+    },
 });
 // ---------------------------------------------------------------------------
 // OpenAPI subcommand
@@ -1953,6 +2119,79 @@ const openapiCli = Cli.create({
         }
     },
 });
+const tokenCli = Cli.create({
+    name: "token",
+    description: "Issue and revoke short-lived Gateway bearer tokens.",
+})
+    .command("issue", {
+    description: "Issue a local short-lived Gateway bearer token grant.",
+    options: z.object({
+        scopes: z.string().default("run:read").describe("Comma or space separated Gateway scopes"),
+        role: z.string().default("operator").describe("Role recorded on the token grant"),
+        userId: z.string().optional().describe("User id recorded on the token grant"),
+        ttl: z.string().default("1h").describe("Token lifetime, such as 15m or 1h"),
+    }),
+    run(c) {
+        const fail = (opts) => {
+            commandExitOverride = opts.exitCode ?? 1;
+            return c.error(opts);
+        };
+        try {
+            const ttlMs = parseDurationMs(c.options.ttl, "ttl");
+            const now = Date.now();
+            const token = `smithers_${crypto.randomBytes(32).toString("base64url")}`;
+            const tokenId = crypto.createHash("sha256").update(token).digest("hex").slice(0, 16);
+            const grant = {
+                tokenId,
+                role: c.options.role,
+                scopes: parseTokenScopes(c.options.scopes),
+                ...(c.options.userId ? { userId: c.options.userId } : {}),
+                issuedAtMs: now,
+                expiresAtMs: now + ttlMs,
+            };
+            const store = readSmithersTokenStore();
+            store.tokens[token] = grant;
+            writeSmithersTokenStore(store);
+            return c.ok({
+                token,
+                grant,
+                storePath: smithersTokenStorePath(),
+            });
+        }
+        catch (err) {
+            return fail({
+                code: err instanceof SmithersError ? err.code : "TOKEN_ISSUE_FAILED",
+                message: err?.message ?? String(err),
+                exitCode: 1,
+            });
+        }
+    },
+})
+    .command("revoke", {
+    description: "Revoke a locally issued Gateway bearer token.",
+    args: z.object({
+        token: z.string().describe("Bearer token to revoke"),
+    }),
+    run(c) {
+        const store = readSmithersTokenStore();
+        const grant = store.tokens[c.args.token];
+        if (!grant) {
+            commandExitOverride = 1;
+            return c.error({
+                code: "TOKEN_NOT_FOUND",
+                message: "Token was not found in the local Smithers token store",
+                exitCode: 1,
+            });
+        }
+        grant.revokedAtMs = Date.now();
+        writeSmithersTokenStore(store);
+        return c.ok({
+            revoked: true,
+            tokenId: grant.tokenId ?? crypto.createHash("sha256").update(c.args.token).digest("hex").slice(0, 16),
+            storePath: smithersTokenStorePath(),
+        });
+    },
+});
 // ---------------------------------------------------------------------------
 // DevTools live-run commands (tree / diff / output / rewind)
 // ---------------------------------------------------------------------------
@@ -2243,7 +2482,7 @@ const cli = Cli.create({
     .command("init", {
     description: "Install the local Smithers workflow pack into .smithers/.",
     options: initOptions,
-    run(c) {
+    async run(c) {
         const fail = (opts) => {
             commandExitOverride = opts.exitCode ?? 1;
             return c.error(opts);
@@ -2251,22 +2490,36 @@ const cli = Cli.create({
         try {
             const result = initWorkflowPack({
                 force: c.options.force,
-                skipInstall: !c.options.install,
-            });
-            return c.ok(result, {
-                cta: {
-                    description: "Next steps:",
-                    commands: c.agent
-                        ? [
-                            { command: "workflow list", description: "View all available workflows" },
-                            { command: "bun install -g smithers", description: "Install smithers globally" },
-                        ]
-                        : [
-                            { command: "tui", description: "Open the interactive dashboard" },
-                            { command: "bun install -g smithers", description: "Install smithers globally" },
-                        ],
-                },
+                agentsOnly: c.options.agentsOnly,
+                skipInstall: c.options.agentsOnly || !c.options.install,
             });
+            if (c.options.addAgents) {
+                const added = await agentAddWizard({ loop: true });
+                result.addedAccounts = added;
+                // Regenerate agents.ts now that accounts are in place — the
+                // initial generateAgentsTs() call ran before any accounts
+                // existed, so it produced the detection-based file.
+                if (added.length > 0) {
+                    const { regenerateAgentsTsIfPresent } = await import("./agent-commands/regenerateAgentsTsIfPresent.js");
+                    result.regen = regenerateAgentsTsIfPresent();
+                }
+            }
+            return c.ok(result, c.options.agentsOnly
+                ? undefined
+                : {
+                    cta: {
+                        description: "Next steps:",
+                        commands: c.agent
+                            ? [
+                                { command: "workflow list", description: "View all available workflows" },
+                                { command: "workflow run implement", description: "Run the implementation workflow" },
+                            ]
+                            : [
+                                { command: "tui", description: "Open the interactive dashboard" },
+                                { command: "workflow list", description: "View all available workflows" },
+                            ],
+                    },
+                });
         }
         catch (err) {
             if (err instanceof SmithersError) {
@@ -2922,6 +3175,80 @@ const cli = Cli.create({
             cleanup?.();
         }
     },
+})
+    // =========================================================================
+    // smithers chat create
+    // =========================================================================
+    .command("chat-create", {
+    description: "Create and start a one-task auto-hijacked chat run.",
+    options: chatCreateOptions,
+    async run(c) {
+        const fail = (opts) => {
+            commandExitOverride = opts.exitCode ?? 1;
+            return c.error(opts);
+        };
+        const chatCwd = resolve(process.cwd(), c.options.cwd ?? ".");
+        if (!existsSync(chatCwd)) {
+            return fail({
+                code: "PATH_NOT_FOUND",
+                message: `Path does not exist: ${chatCwd}`,
+                exitCode: 4,
+            });
+        }
+        if (!statSync(chatCwd).isDirectory()) {
+            return fail({
+                code: "PATH_NOT_DIRECTORY",
+                message: `Path is not a directory: ${chatCwd}`,
+                exitCode: 4,
+            });
+        }
+        try {
+            const workflow = await buildInlineChatWorkflow(c.options.agent, chatCwd);
+            setupSqliteCleanup(workflow);
+            const result = await Effect.runPromise(runWorkflow(workflow, {
+                input: {},
+                rootDir: chatCwd,
+            }));
+            const adapter = new SmithersDb(workflow.db);
+            const candidate = result.runId
+                ? await resolveHijackCandidate(adapter, result.runId, c.options.agent)
+                : null;
+            if (!candidate) {
+                if (result.status === "failed") {
+                    return fail({
+                        code: result.error?.code ?? "CHAT_CREATE_FAILED",
+                        message: result.error?.message ?? `Chat run ${result.runId} failed.`,
+                        exitCode: result.error?.code === "TASK_HIJACK_UNSUPPORTED" ? 4 : 1,
+                    });
+                }
+                return fail({
+                    code: "CHAT_CREATE_UNAVAILABLE",
+                    message: `Chat run ${result.runId} did not produce a hijackable ${c.options.agent} session.`,
+                    exitCode: 1,
+                });
+            }
+            return c.ok({
+                runId: result.runId,
+                workflowName: "chat",
+                agent: c.options.agent,
+            }, {
+                cta: {
+                    description: "Next steps:",
+                    commands: [
+                        { command: `hijack ${result.runId}`, description: "Open the chat session" },
+                        { command: `inspect ${result.runId}`, description: "Inspect run state" },
+                    ],
+                },
+            });
+        }
+        catch (err) {
+            return fail({
+                code: err instanceof SmithersError ? err.code : "CHAT_CREATE_FAILED",
+                message: err?.message ?? String(err),
+                exitCode: err instanceof SmithersError ? 4 : 1,
+            });
+        }
+    },
 })
     // =========================================================================
     // smithers hijack <run_id>
@@ -4608,7 +4935,8 @@ const cli = Cli.create({
     .command(cronCli)
     .command(agentsCli)
     .command(memoryCli)
-    .command(openapiCli);
+    .command(openapiCli)
+    .command(tokenCli);
 const cliCommands = Cli.toCommands?.get(cli);
 if (!(cliCommands instanceof Map)) {
     throw new Error("Could not resolve Smithers CLI commands for input bounds.");
@@ -4619,8 +4947,8 @@ wrapCliCommandHandlersWithInputBounds(cliCommands);
 // ---------------------------------------------------------------------------
 const KNOWN_COMMANDS = new Set([
     "init", "up", "supervise", "down", "ps", "logs", "events", "chat", "inspect", "node", "why", "approve", "deny",
-    "cancel", "graph", "revert", "scores", "observability", "workflow", "ask", "cron",
-    "replay", "diff", "fork", "timeline", "memory", "openapi", "agents", "alerts",
+    "cancel", "graph", "revert", "scores", "observability", "workflow", "ask", "cron", "chat-create",
+    "replay", "diff", "fork", "timeline", "memory", "openapi", "token", "agents", "alerts",
     "tree", "output", "rewind", "gui",
 ]);
 /**
@@ -4760,6 +5088,67 @@ function hasHelpFlag(argv, startIndex = 0) {
     }
     return false;
 }
+/**
+ * @param {string[]} argv
+ */
+function hasJsonFormatFlag(argv) {
+    for (let index = 0; index < argv.length; index++) {
+        const arg = argv[index];
+        if (arg === "--format") {
+            const value = argv[index + 1];
+            if (value === "json" || value === "jsonl") {
+                return true;
+            }
+            index++;
+            continue;
+        }
+        if (arg === "--format=json" || arg === "--format=jsonl") {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @param {string[]} argv
+ * @param {number} startIndex
+ */
+function hasJsonFlag(argv, startIndex) {
+    for (let index = startIndex; index < argv.length; index++) {
+        const arg = argv[index];
+        if (arg === "--json" || arg === "-j") {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * @param {string[]} argv
+ */
+function argvRequestsJsonMode(argv) {
+    const commandIndex = findFirstPositionalIndex(argv);
+    if (commandIndex < 0) {
+        return hasJsonFormatFlag(argv);
+    }
+    const command = argv[commandIndex];
+    if (hasJsonFormatFlag(argv)) {
+        return true;
+    }
+    if (command === "why" ||
+        command === "events" ||
+        command === "inspect" ||
+        command === "node" ||
+        DEVTOOLS_COMMANDS.has(command)) {
+        return hasJsonFlag(argv, commandIndex + 1);
+    }
+    if (command === "agents") {
+        const subcommandIndex = findFirstPositionalIndex(argv, commandIndex + 1);
+        return subcommandIndex >= 0 && argv[subcommandIndex] === "doctor" && hasJsonFlag(argv, subcommandIndex + 1);
+    }
+    if (command === "doctor") {
+        return hasJsonFlag(argv, commandIndex + 1);
+    }
+    return false;
+}
 /**
  * @param {string[]} argv
  */
@@ -4840,14 +5229,128 @@ function normalizeResumeOption(value) {
     }
     return { resume: true, resumeRunId: normalized };
 }
+const CHAT_CREATE_PROMPT = [
+    "Start an interactive chat session with the user and help them directly.",
+    "Stay in this conversation until the user is done.",
+    'When you are completely finished and want to hand control back to Smithers, end your final response with an empty JSON object in a ```json fence: {}.',
+].join("\n\n");
+/**
+ * @param {"claude-code" | "codex" | "gemini"} agentId
+ * @param {string} cwd
+ */
+async function createChatAgent(agentId, cwd) {
+    switch (agentId) {
+        case "claude-code": {
+            const { ClaudeCodeAgent } = await import("@smithers-orchestrator/agents/ClaudeCodeAgent");
+            return new ClaudeCodeAgent({
+                cwd,
+                model: "claude-opus-4-6",
+            });
+        }
+        case "codex": {
+            const { CodexAgent } = await import("@smithers-orchestrator/agents/CodexAgent");
+            return new CodexAgent({
+                cwd,
+                model: "gpt-5.3-codex",
+                skipGitRepoCheck: true,
+            });
+        }
+        case "gemini": {
+            const { GeminiAgent } = await import("@smithers-orchestrator/agents/GeminiAgent");
+            return new GeminiAgent({
+                cwd,
+                model: "gemini-3.1-pro-preview",
+            });
+        }
+    }
+}
+/**
+ * @param {"claude-code" | "codex" | "gemini"} agentId
+ * @param {string} cwd
+ * @returns {Promise<import("@smithers-orchestrator/components/SmithersWorkflow").SmithersWorkflow<any>>}
+ */
+async function buildInlineChatWorkflow(agentId, cwd) {
+    const [
+        { Database },
+        { drizzle },
+        { sqliteTable, text },
+        { Workflow, Task },
+        { zodToTable },
+        { syncZodTableSchema },
+        { camelToSnake },
+        { z: zod },
+    ] = await Promise.all([
+        import("bun:sqlite"),
+        import("drizzle-orm/bun-sqlite"),
+        import("drizzle-orm/sqlite-core"),
+        import("@smithers-orchestrator/components"),
+        import("@smithers-orchestrator/db/zodToTable"),
+        import("@smithers-orchestrator/db/zodToCreateTableSQL"),
+        import("@smithers-orchestrator/db/utils/camelToSnake"),
+        import("zod"),
+    ]);
+    const agent = await createChatAgent(agentId, cwd);
+    const chatSchema = zod.object({});
+    const inputTable = sqliteTable("input", {
+        runId: text("run_id").primaryKey(),
+        payload: text("payload", { mode: "json" }).$type(),
+    });
+    const chatTableName = camelToSnake("chat");
+    const chatTable = zodToTable(chatTableName, chatSchema);
+    const sqlite = new Database(resolve(cwd, "smithers.db"));
+    sqlite.run("PRAGMA journal_mode = WAL");
+    sqlite.run("PRAGMA busy_timeout = 30000");
+    sqlite.run("PRAGMA synchronous = NORMAL");
+    sqlite.run("PRAGMA locking_mode = NORMAL");
+    sqlite.run("PRAGMA foreign_keys = ON");
+    sqlite.exec(`CREATE TABLE IF NOT EXISTS "input" (run_id TEXT PRIMARY KEY, payload TEXT)`);
+    syncZodTableSchema(sqlite, chatTableName, chatSchema);
+    const db = drizzle(sqlite, { schema: { input: inputTable, chat: chatTable } });
+    const schemaRegistry = new Map([["chat", { table: chatTable, zodSchema: chatSchema }]]);
+    const zodToKeyName = new Map([[chatSchema, "chat"]]);
+    return {
+        db,
+        build: () => React.createElement(Workflow, { name: "chat" }, React.createElement(Task, {
+            id: "chat",
+            output: chatSchema,
+            agent,
+            hijack: true,
+        }, CHAT_CREATE_PROMPT)),
+        opts: {},
+        schemaRegistry,
+        zodToKeyName,
+    };
+}
+/**
+ * @param {string[]} argv
+ */
+function rewriteChatCreateArgv(argv) {
+    const commandIndex = findFirstPositionalIndex(argv);
+    if (commandIndex < 0 || argv[commandIndex] !== "chat") {
+        return argv;
+    }
+    const subcommandIndex = findFirstPositionalIndex(argv, commandIndex + 1);
+    if (subcommandIndex < 0 || argv[subcommandIndex] !== "create") {
+        return argv;
+    }
+    return [
+        ...argv.slice(0, commandIndex),
+        "chat-create",
+        ...argv.slice(subcommandIndex + 1),
+    ];
+}
 async function main() {
     const rawArgv = process.argv.slice(2);
     let argv = rawArgv.map((arg) => (arg === "-v" ? "--version" : arg));
     argv = rewriteGuiShortcutArgv(argv);
+    argv = rewriteChatCreateArgv(argv);
     argv = rewriteWorkflowCommandArgv(argv);
     argv = rewriteEventsJsonFlagArgv(argv);
     // Finding #3: route `--json` to command-scoped `-j` for devtools commands.
     argv = rewriteDevtoolsJsonFlagArgv(argv);
+    if (argvRequestsJsonMode(argv)) {
+        setJsonMode(true);
+    }
     // Finding #1: pre-validate argv for devtools commands so missing-args
     // / invalid-flag errors go to stderr with exit 1 (not incur's
     // remap-to-4 VALIDATION_ERROR envelope on stdout).