@otto-code/cli 0.8.19 → 0.9.2

package/bin/otto

@@ -1,3 +1,3 @@
 #!/usr/bin/env -S node --disable-warning=DEP0040
-import '../dist/index.js'
-
+import '../dist/index.js'
+

package/dist/cli.js

@@ -3,13 +3,18 @@ import { createAgentCommand } from "./commands/agent/index.js";
 import { createDaemonCommand } from "./commands/daemon/index.js";
 import { createPermitCommand } from "./commands/permit/index.js";
 import { createProviderCommand } from "./commands/provider/index.js";
+import { createPluginCommand } from "./commands/plugin/index.js";
+import { createProjectCommand } from "./commands/project/index.js";
 import { createScheduleCommand } from "./commands/schedule/index.js";
 import { createSpeechCommand } from "./commands/speech/index.js";
 import { createScriptCommand } from "./commands/script/index.js";
 import { createTerminalCommand } from "./commands/terminal/index.js";
 import { createWorktreeCommand } from "./commands/worktree/index.js";
 import { createWorkspaceCommand } from "./commands/workspace/index.js";
+import { createWorkflowCommand } from "./commands/workflow/index.js";
 import { createHeartbeatCommand } from "./commands/heartbeat/index.js";
+import { createArtifactCommand } from "./commands/artifact/index.js";
+import { createArchitecturalViewCommand } from "./commands/architectural-view/index.js";
 // DISABLED(hub): specifier redirected away from "./commands/hub/index.js".
 import { createHubCommand } from "./commands/hub-disabled.js";
 import { createHooksCommand } from "./commands/hooks.js";
@@ -17,6 +22,7 @@ import { createBrainCommand } from "@otto-code/brain";
 import { startCommand as daemonStartCommand } from "./commands/daemon/start.js";
 import { runStatusCommand as runDaemonStatusCommand } from "./commands/daemon/status.js";
 import { runRestartCommand as runDaemonRestartCommand } from "./commands/daemon/restart.js";
+import { runDaemonReloadCommand } from "./commands/daemon/reload.js";
 import { addLsOptions, runLsCommand } from "./commands/agent/ls.js";
 import { addRunOptions, runRunCommand } from "./commands/agent/run.js";
 import { addLogsOptions, runLogsCommand } from "./commands/agent/logs.js";
@@ -81,6 +87,7 @@ export function createCli() {
         .description('Show local daemon status (alias for "otto daemon status")'))
         .option("--home <path>", "Otto home directory (default: ~/.otto)")
         .action(withOutput(runDaemonStatusCommand));
+    addJsonAndDaemonHostOptions(program.command("reload").description('Reload daemon config (alias for "otto daemon reload")')).action(withOutput(runDaemonReloadCommand));
     addJsonOption(program
         .command("restart")
         .description('Restart local daemon (alias for "otto daemon restart")'))
@@ -114,14 +121,20 @@ export function createCli() {
     // Schedule commands
     program.addCommand(createScheduleCommand());
     program.addCommand(createHeartbeatCommand());
+    program.addCommand(createArtifactCommand());
+    program.addCommand(createArchitecturalViewCommand());
     // Permission commands
     program.addCommand(createPermitCommand());
     // Provider commands
     program.addCommand(createProviderCommand());
+    program.addCommand(createPluginCommand());
     // Speech model commands
     program.addCommand(createSpeechCommand());
     // Workspace commands
+    program.addCommand(createProjectCommand());
     program.addCommand(createWorkspaceCommand());
+    // Workflow commands
+    program.addCommand(createWorkflowCommand());
     // COMPAT(worktreeCli): legacy command alias added before workspace was the product unit.
     // Added in v0.2.0; remove after 2027-01-17.
     program.addCommand(createWorktreeCommand(), { hidden: true });

package/dist/commands/architectural-view/deliver.d.ts

@@ -0,0 +1,18 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ArchitecturalViewCommandOptions } from "./shared.js";
+interface DeliverArchitecturalViewOptions extends ArchitecturalViewCommandOptions {
+    workspace?: string;
+    source?: string;
+    title?: string;
+    link?: string[];
+    quality?: "standard" | "showcase";
+}
+interface DeliveredArchitecturalViewResult {
+    id: string;
+    location: "repository" | "host" | null;
+    htmlPath: string | null;
+}
+export declare function runDeliverArchitecturalViewCommand(viewId: string, options: DeliverArchitecturalViewOptions, _command: Command): Promise<SingleResult<DeliveredArchitecturalViewResult>>;
+export {};
+//# sourceMappingURL=deliver.d.ts.map

package/dist/commands/architectural-view/deliver.js

@@ -0,0 +1,60 @@
+import { connectArchitecturalViewsClient } from "./shared.js";
+const deliveredArchitecturalViewSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 24 },
+        { header: "STORED", field: "location", width: 14 },
+        { header: "HTML", field: "htmlPath", width: 48 },
+    ],
+};
+function requiredOption(value, option) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        throw { code: "MISSING_ARCHITECTURAL_VIEW_OPTION", message: `${option} is required.` };
+    return trimmed;
+}
+function parseKnowledgeReferences(values) {
+    const references = values ?? [];
+    if (references.length === 0) {
+        throw {
+            code: "MISSING_ARCHITECTURAL_VIEW_LINK",
+            message: "At least one --link root:<id> or record:<id> is required.",
+        };
+    }
+    return references.map((value) => {
+        const separator = value.indexOf(":");
+        const kind = value.slice(0, separator);
+        const id = value.slice(separator + 1).trim();
+        if ((kind !== "root" && kind !== "record") || !id) {
+            throw {
+                code: "INVALID_ARCHITECTURAL_VIEW_LINK",
+                message: `Invalid Knowledge link "${value}". Use root:<id> or record:<id>.`,
+            };
+        }
+        return { kind, id };
+    });
+}
+export async function runDeliverArchitecturalViewCommand(viewId, options, _command) {
+    const client = await connectArchitecturalViewsClient(options.host);
+    try {
+        const payload = await client.deliverArchitecturalView({
+            workspaceId: requiredOption(options.workspace, "--workspace"),
+            viewId: requiredOption(viewId, "Architectural View ID"),
+            title: requiredOption(options.title, "--title"),
+            sourcePath: requiredOption(options.source, "--source"),
+            knowledgeReferences: parseKnowledgeReferences(options.link),
+            ...(options.quality ? { quality: options.quality } : {}),
+        });
+        if (!payload.success)
+            throw new Error(payload.error ?? "Architectural View delivery failed.");
+        return {
+            type: "single",
+            data: { id: payload.viewId, location: payload.storeLocation, htmlPath: payload.htmlPath },
+            schema: deliveredArchitecturalViewSchema,
+        };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=deliver.js.map

package/dist/commands/architectural-view/draft.d.ts

@@ -0,0 +1,33 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ArchitecturalViewCommandOptions } from "./shared.js";
+interface DraftCreateOptions extends ArchitecturalViewCommandOptions {
+    workspace?: string;
+    title?: string;
+    link?: string[];
+    source?: string;
+    quality?: "standard" | "showcase";
+}
+interface DraftOperationOptions extends ArchitecturalViewCommandOptions {
+    workspace?: string;
+}
+interface DraftResult {
+    id: string;
+    viewId: string;
+    updatedAt: string;
+}
+interface PublishResult {
+    id: string;
+    htmlPath: string;
+    renderedAt: string;
+}
+interface DiscardResult {
+    id: string;
+    discarded: boolean;
+}
+export declare function runDraftCreate(viewId: string, draftId: string, options: DraftCreateOptions, _command: Command): Promise<SingleResult<DraftResult>>;
+export declare function runDraftPublish(viewId: string, draftId: string, options: DraftOperationOptions, _command: Command): Promise<SingleResult<PublishResult>>;
+export declare function runDraftUpdate(viewId: string, draftId: string, options: DraftCreateOptions, _command: Command): Promise<SingleResult<DraftResult>>;
+export declare function runDraftDiscard(viewId: string, draftId: string, options: DraftOperationOptions, _command: Command): Promise<SingleResult<DiscardResult>>;
+export {};
+//# sourceMappingURL=draft.d.ts.map

package/dist/commands/architectural-view/draft.js

@@ -0,0 +1,128 @@
+import { connectArchitecturalViewsClient } from "./shared.js";
+const draftSchema = {
+    idField: "id",
+    columns: [
+        { header: "DRAFT", field: "id", width: 24 },
+        { header: "VIEW", field: "viewId", width: 24 },
+        { header: "UPDATED", field: "updatedAt", width: 24 },
+    ],
+};
+const publishSchema = {
+    idField: "id",
+    columns: [
+        { header: "VIEW", field: "id", width: 24 },
+        { header: "HTML", field: "htmlPath", width: 48 },
+        { header: "PUBLISHED", field: "renderedAt", width: 24 },
+    ],
+};
+const discardSchema = {
+    idField: "id",
+    columns: [
+        { header: "DRAFT", field: "id", width: 24 },
+        { header: "DISCARDED", field: "discarded", width: 12 },
+    ],
+};
+function required(value, option) {
+    if (!value?.trim())
+        throw new Error(`${option} is required.`);
+    return value.trim();
+}
+function links(values) {
+    const result = values ?? [];
+    if (!result.length)
+        throw new Error("At least one --link root:<id> or record:<id> is required.");
+    return result.map((value) => {
+        const [kind, ...parts] = value.split(":");
+        const id = parts.join(":").trim();
+        if ((kind !== "root" && kind !== "record") || !id)
+            throw new Error(`Invalid Knowledge link "${value}".`);
+        return { kind, id };
+    });
+}
+export async function runDraftCreate(viewId, draftId, options, _command) {
+    const client = await connectArchitecturalViewsClient(options.host);
+    try {
+        const result = await client.createArchitecturalViewDraft({
+            workspaceId: required(options.workspace, "--workspace"),
+            viewId,
+            draftId,
+            title: required(options.title, "--title"),
+            knowledgeReferences: links(options.link),
+            ...(options.source ? { sourcePath: options.source } : {}),
+            ...(options.quality ? { quality: options.quality } : {}),
+        });
+        if (!result.success || !result.draft)
+            throw new Error(result.error ?? "Could not create Architectural View draft.");
+        return {
+            type: "single",
+            data: { id: result.draft.id, viewId: result.draft.viewId, updatedAt: result.draft.updatedAt },
+            schema: draftSchema,
+        };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+export async function runDraftPublish(viewId, draftId, options, _command) {
+    const client = await connectArchitecturalViewsClient(options.host);
+    try {
+        const result = await client.publishArchitecturalViewDraft({
+            workspaceId: required(options.workspace, "--workspace"),
+            viewId,
+            draftId,
+        });
+        if (!result.success || !result.view)
+            throw new Error(result.error ?? "Could not publish Architectural View draft.");
+        return {
+            type: "single",
+            data: {
+                id: result.view.id,
+                htmlPath: result.view.htmlPath,
+                renderedAt: result.view.renderedAt,
+            },
+            schema: publishSchema,
+        };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+export async function runDraftUpdate(viewId, draftId, options, _command) {
+    const client = await connectArchitecturalViewsClient(options.host);
+    try {
+        const result = await client.updateArchitecturalViewDraft({
+            workspaceId: required(options.workspace, "--workspace"),
+            viewId,
+            draftId,
+            sourcePath: required(options.source, "--source"),
+            ...(options.quality ? { quality: options.quality } : {}),
+        });
+        if (!result.success || !result.draft)
+            throw new Error(result.error ?? "Could not update Architectural View draft.");
+        return {
+            type: "single",
+            data: { id: result.draft.id, viewId: result.draft.viewId, updatedAt: result.draft.updatedAt },
+            schema: draftSchema,
+        };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+export async function runDraftDiscard(viewId, draftId, options, _command) {
+    const client = await connectArchitecturalViewsClient(options.host);
+    try {
+        const result = await client.discardArchitecturalViewDraft({
+            workspaceId: required(options.workspace, "--workspace"),
+            viewId,
+            draftId,
+        });
+        if (!result.success)
+            throw new Error(result.error ?? "Could not discard Architectural View draft.");
+        return { type: "single", data: { id: draftId, discarded: true }, schema: discardSchema };
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=draft.js.map

package/dist/commands/architectural-view/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createArchitecturalViewCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/architectural-view/index.js

@@ -0,0 +1,48 @@
+import { Command, Option } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { runDeliverArchitecturalViewCommand } from "./deliver.js";
+import { runDraftCreate, runDraftDiscard, runDraftPublish, runDraftUpdate } from "./draft.js";
+export function createArchitecturalViewCommand() {
+    const architecturalView = new Command("architectural-view").description("Create and inspect Knowledge-packaged Architectural Views");
+    addJsonAndDaemonHostOptions(architecturalView
+        .command("deliver")
+        .description("Validate and deliver a Knowledge-packaged Architectural View through the daemon")
+        .argument("<id>", "Stable Architectural View ID")
+        .requiredOption("--workspace <id>", "Workspace that owns the project Knowledge")
+        .requiredOption("--source <path>", "Workspace-relative Architecture JSON source")
+        .requiredOption("--title <text>", "Architectural View title")
+        .option("--link <kind:id>", "Knowledge link: root:<id> or record:<id>", (value, values) => values.concat(value), [])
+        .addOption(new Option("--quality <profile>").choices(["standard", "showcase"]))).action(withOutput(runDeliverArchitecturalViewCommand));
+    const draft = architecturalView
+        .command("draft")
+        .description("Manage staged Architectural View drafts");
+    addJsonAndDaemonHostOptions(draft
+        .command("create")
+        .argument("<view-id>")
+        .argument("<draft-id>")
+        .requiredOption("--workspace <id>")
+        .requiredOption("--title <text>")
+        .option("--source <path>")
+        .option("--link <kind:id>", "Knowledge link", (value, values) => values.concat(value), [])
+        .addOption(new Option("--quality <profile>").choices(["standard", "showcase"]))).action(withOutput(runDraftCreate));
+    addJsonAndDaemonHostOptions(draft
+        .command("update")
+        .argument("<view-id>")
+        .argument("<draft-id>")
+        .requiredOption("--workspace <id>")
+        .requiredOption("--source <path>")
+        .addOption(new Option("--quality <profile>").choices(["standard", "showcase"]))).action(withOutput(runDraftUpdate));
+    addJsonAndDaemonHostOptions(draft
+        .command("publish")
+        .argument("<view-id>")
+        .argument("<draft-id>")
+        .requiredOption("--workspace <id>")).action(withOutput(runDraftPublish));
+    addJsonAndDaemonHostOptions(draft
+        .command("discard")
+        .argument("<view-id>")
+        .argument("<draft-id>")
+        .requiredOption("--workspace <id>")).action(withOutput(runDraftDiscard));
+    return architecturalView;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/architectural-view/shared.d.ts

@@ -0,0 +1,7 @@
+import type { DaemonClient } from "@otto-code/client/internal/daemon-client";
+import type { CommandOptions } from "../../output/index.js";
+export interface ArchitecturalViewCommandOptions extends CommandOptions {
+    host?: string;
+}
+export declare function connectArchitecturalViewsClient(host?: string): Promise<DaemonClient>;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/architectural-view/shared.js

@@ -0,0 +1,27 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export async function connectArchitecturalViewsClient(host) {
+    const daemonHost = getDaemonHost({ host });
+    try {
+        const client = await connectToDaemon({ host });
+        // COMPAT(architecturalViews): added in v0.9.0, remove after 2027-02-28.
+        if (!client.getLastServerInfoMessage()?.features?.architecturalViews) {
+            await client.close().catch(() => { });
+            throw {
+                code: "DAEMON_UPDATE_REQUIRED",
+                message: "Update the host to use Architectural Views.",
+            };
+        }
+        return client;
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && "message" in error)
+            throw error;
+        const message = error instanceof Error ? error.message : String(error);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${daemonHost}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+    }
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/artifact/cancel.d.ts

@@ -0,0 +1,13 @@
+import type { ArtifactMetadata } from "@otto-code/protocol/artifacts/types";
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ArtifactCommandOptions } from "./shared.js";
+export interface CancelledArtifactResult {
+    id: string;
+    status: string;
+    updatedAt: string;
+    error: string | null;
+}
+export declare function toCancelledArtifactResult(artifact: ArtifactMetadata): CancelledArtifactResult;
+export declare function runCancelCommand(id: string, options: ArtifactCommandOptions, _command: Command): Promise<SingleResult<CancelledArtifactResult>>;
+//# sourceMappingURL=cancel.d.ts.map

package/dist/commands/artifact/cancel.js

@@ -0,0 +1,38 @@
+import { connectArtifactClient, toArtifactCommandError, } from "./shared.js";
+const cancelledArtifactSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 16 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "UPDATED", field: "updatedAt", width: 24 },
+        { header: "RECOVERY", field: "error", width: 36 },
+    ],
+};
+export function toCancelledArtifactResult(artifact) {
+    return {
+        id: artifact.id,
+        status: artifact.status,
+        updatedAt: artifact.updatedAt,
+        error: artifact.errorMessage,
+    };
+}
+export async function runCancelCommand(id, options, _command) {
+    const client = await connectArtifactClient(options.host, "artifacts");
+    try {
+        const payload = await client.artifactCancel({ artifactId: id });
+        if (!payload.success)
+            throw new Error(payload.error ?? "Artifact cancellation failed");
+        return {
+            type: "single",
+            data: toCancelledArtifactResult(payload.artifact),
+            schema: cancelledArtifactSchema,
+        };
+    }
+    catch (error) {
+        throw toArtifactCommandError("ARTIFACT_CANCEL_FAILED", "cancel artifact generation", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=cancel.js.map

package/dist/commands/artifact/create.d.ts

@@ -0,0 +1,21 @@
+import type { ArtifactMetadata } from "@otto-code/protocol/artifacts/types";
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ArtifactCommandOptions } from "./shared.js";
+interface CreateArtifactOptions extends ArtifactCommandOptions {
+    project?: string;
+    provider?: string;
+    description?: string;
+    model?: string;
+    thinking?: string;
+}
+interface CreatedArtifactResult {
+    id: string;
+    status: string;
+    storageLocation: "repository" | "host" | null;
+    updatedAt: string;
+}
+export declare function toCreatedArtifactResult(artifact: ArtifactMetadata): CreatedArtifactResult;
+export declare function runCreateCommand(name: string, options: CreateArtifactOptions, _command: Command): Promise<SingleResult<CreatedArtifactResult>>;
+export {};
+//# sourceMappingURL=create.d.ts.map

package/dist/commands/artifact/create.js

@@ -0,0 +1,56 @@
+import { connectArtifactClient, toArtifactCommandError, } from "./shared.js";
+const createdArtifactSchema = {
+    idField: "id",
+    columns: [
+        { header: "ID", field: "id", width: 16 },
+        { header: "STATUS", field: "status", width: 12 },
+        { header: "STORED", field: "storageLocation", width: 14 },
+        { header: "UPDATED", field: "updatedAt", width: 24 },
+    ],
+};
+function requiredOption(value, option) {
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        throw { code: "MISSING_ARTIFACT_CREATE_OPTION", message: `${option} is required.` };
+    }
+    return trimmed;
+}
+export function toCreatedArtifactResult(artifact) {
+    return {
+        id: artifact.id,
+        status: artifact.status,
+        storageLocation: artifact.storageLocation ?? null,
+        updatedAt: artifact.updatedAt,
+    };
+}
+export async function runCreateCommand(name, options, _command) {
+    const projectId = requiredOption(options.project, "--project");
+    const provider = requiredOption(options.provider, "--provider");
+    const description = requiredOption(options.description, "--description");
+    const artifactName = requiredOption(name, "Artifact name");
+    const client = await connectArtifactClient(options.host, "artifacts");
+    try {
+        const payload = await client.artifactCreate({
+            name: artifactName,
+            description,
+            projectId,
+            provider,
+            ...(options.model?.trim() ? { model: options.model.trim() } : {}),
+            ...(options.thinking?.trim() ? { thinkingOptionId: options.thinking.trim() } : {}),
+        });
+        if (!payload.success)
+            throw new Error(payload.error ?? "Artifact creation failed");
+        return {
+            type: "single",
+            data: toCreatedArtifactResult(payload.artifact),
+            schema: createdArtifactSchema,
+        };
+    }
+    catch (error) {
+        throw toArtifactCommandError("ARTIFACT_CREATE_FAILED", "create artifact", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=create.js.map

package/dist/commands/artifact/get-data.d.ts

@@ -0,0 +1,5 @@
+import type { Command } from "commander";
+import type { SingleResult } from "../../output/index.js";
+import { type ArtifactCommandOptions } from "./shared.js";
+export declare function runGetDataCommand(id: string, options: ArtifactCommandOptions, _command: Command): Promise<SingleResult<unknown>>;
+//# sourceMappingURL=get-data.d.ts.map

package/dist/commands/artifact/get-data.js

@@ -0,0 +1,24 @@
+import { connectArtifactClient, toArtifactCommandError, } from "./shared.js";
+const artifactDataSchema = {
+    idField: () => "",
+    columns: [{ header: "DATA", field: (data) => JSON.stringify(data) }],
+};
+export async function runGetDataCommand(id, options, _command) {
+    const client = await connectArtifactClient(options.host, "data");
+    try {
+        const payload = await client.artifactGetData({ artifactId: id });
+        if (!payload.success)
+            throw new Error(payload.error ?? "Artifact data is unavailable");
+        if (payload.data === null) {
+            throw new Error("Artifact has no explicit data contract; regenerate it to add one");
+        }
+        return { type: "single", data: payload.data, schema: artifactDataSchema };
+    }
+    catch (error) {
+        throw toArtifactCommandError("ARTIFACT_DATA_GET_FAILED", "read artifact data", error);
+    }
+    finally {
+        await client.close().catch(() => { });
+    }
+}
+//# sourceMappingURL=get-data.js.map

package/dist/commands/artifact/index.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function createArtifactCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/artifact/index.js

@@ -0,0 +1,55 @@
+import { Command } from "commander";
+import { withOutput } from "../../output/index.js";
+import { addJsonAndDaemonHostOptions } from "../../utils/command-options.js";
+import { runCancelCommand } from "./cancel.js";
+import { runCreateCommand } from "./create.js";
+import { runGetDataCommand } from "./get-data.js";
+import { runArtifactListCommand } from "./ls.js";
+import { runMoveCommand } from "./move.js";
+import { runRepairCommand } from "./repair.js";
+import { runRegenerateCommand } from "./regenerate.js";
+import { runUpdateDataCommand } from "./update-data.js";
+export function createArtifactCommand() {
+    const artifact = new Command("artifact").description("Inspect and update durable artifacts");
+    addJsonAndDaemonHostOptions(artifact
+        .command("create")
+        .description("Create a durable artifact through the selected daemon host")
+        .argument("<name>")
+        .requiredOption("--project <root>", "Project root that owns the artifact")
+        .requiredOption("--provider <provider>", "Provider used for generation")
+        .requiredOption("--description <text>", "Self-contained deliverable description")
+        .option("--model <model>", "Optional provider model")
+        .option("--thinking <id>", "Optional provider thinking option")).action(withOutput(runCreateCommand));
+    addJsonAndDaemonHostOptions(artifact
+        .command("ls")
+        .description("List durable artifacts on the selected daemon host")
+        .option("--project <root>", "Limit to one project root (absolute path)")).action(withOutput(runArtifactListCommand));
+    addJsonAndDaemonHostOptions(artifact
+        .command("data")
+        .description("Read an artifact's explicit JSON data contract")
+        .argument("<id>")).action(withOutput(runGetDataCommand));
+    addJsonAndDaemonHostOptions(artifact
+        .command("update-data")
+        .description("Replace only an artifact's explicit JSON data contract without regenerating")
+        .argument("<id>")
+        .requiredOption("--data <json>", "Complete JSON replacement data")).action(withOutput(runUpdateDataCommand));
+    addJsonAndDaemonHostOptions(artifact
+        .command("cancel")
+        .description("Cancel a generating artifact and preserve any last known good output")
+        .argument("<id>")).action(withOutput(runCancelCommand));
+    addJsonAndDaemonHostOptions(artifact
+        .command("regenerate")
+        .description("Explicitly regenerate an artifact's visual output from its stored definition")
+        .argument("<id>")).action(withOutput(runRegenerateCommand));
+    addJsonAndDaemonHostOptions(artifact
+        .command("move")
+        .description("Move a settled artifact between repository and host storage")
+        .argument("<id>")
+        .requiredOption("--to <location>", "Destination: repository or host")).action(withOutput(runMoveCommand));
+    addJsonAndDaemonHostOptions(artifact
+        .command("repair")
+        .description("Restore an artifact's last known good output")
+        .argument("<id>")).action(withOutput(runRepairCommand));
+    return artifact;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/artifact/ls.d.ts

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import type { ArtifactMetadata } from "@otto-code/protocol/artifacts/types";
+import type { ListResult } from "../../output/index.js";
+import { type ArtifactCommandOptions } from "./shared.js";
+interface ArtifactListOptions extends ArtifactCommandOptions {
+    project?: string;
+}
+export interface ArtifactRow {
+    id: string;
+    name: string;
+    project: string;
+    stored: string;
+    source: string;
+    status: string;
+    updatedAt: string;
+}
+export declare function toArtifactRow(artifact: ArtifactMetadata): ArtifactRow;
+export declare function runArtifactListCommand(options: ArtifactListOptions, _command: Command): Promise<ListResult<ArtifactRow>>;
+export {};
+//# sourceMappingURL=ls.d.ts.map