@otto-code/cli 0.5.0

package/dist/commands/agent/import.js

@@ -0,0 +1,122 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { collectMultiple } from "../../utils/command-options.js";
+import { agentRunSchema } from "./run.js";
+export function addImportOptions(cmd) {
+    return cmd
+        .description("Import an existing provider session as a Otto agent")
+        .argument("<id>", "Provider session/thread ID to import")
+        .requiredOption("--provider <provider>", "Agent provider id")
+        .option("--cwd <path>", "Working directory for providers that require it")
+        .option("--label <key=value>", "Add label(s) to the agent (can be used multiple times)", collectMultiple, []);
+}
+function toImportResult(agent) {
+    return {
+        agentId: agent.id,
+        status: agent.status === "running" ? "running" : "created",
+        provider: agent.provider,
+        cwd: agent.cwd,
+        title: agent.title,
+    };
+}
+function parseImportProvider(provider) {
+    const normalizedProvider = provider?.trim();
+    if (!normalizedProvider) {
+        throw {
+            code: "MISSING_PROVIDER",
+            message: "Provider is required",
+            details: "Usage: otto import --provider <provider> <id>",
+        };
+    }
+    return normalizedProvider;
+}
+function parseImportLabels(labelFlags) {
+    const labels = {};
+    if (!labelFlags) {
+        return labels;
+    }
+    for (const labelFlag of labelFlags) {
+        const eqIndex = labelFlag.indexOf("=");
+        if (eqIndex === -1) {
+            throw {
+                code: "INVALID_LABEL",
+                message: `Invalid label format: ${labelFlag}`,
+                details: "Labels must be in key=value format",
+            };
+        }
+        const key = labelFlag.slice(0, eqIndex).trim();
+        if (!key) {
+            throw {
+                code: "INVALID_LABEL",
+                message: `Invalid label format: ${labelFlag}`,
+                details: "Labels must include a non-empty key in key=value format",
+            };
+        }
+        labels[key] = labelFlag.slice(eqIndex + 1);
+    }
+    return labels;
+}
+export function resolveImportCwd(explicitCwd, defaultCwd) {
+    const cwd = explicitCwd?.trim() ?? defaultCwd;
+    if (!cwd.trim()) {
+        throw {
+            code: "INVALID_CWD",
+            message: "--cwd cannot be empty",
+            details: "Provide a working directory path or omit --cwd",
+        };
+    }
+    return cwd;
+}
+async function connectToDaemonOrThrow(hostOption, host) {
+    try {
+        return await connectToDaemon({ host: hostOption });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+    }
+}
+export async function runImportCommand(sessionIdArg, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    const sessionId = sessionIdArg.trim();
+    if (!sessionId) {
+        throw {
+            code: "MISSING_SESSION_ID",
+            message: "Session ID is required",
+            details: "Usage: otto import --provider <provider> <id>",
+        };
+    }
+    const provider = parseImportProvider(options.provider);
+    const cwd = resolveImportCwd(options.cwd, process.cwd());
+    const labels = parseImportLabels(options.label);
+    const client = await connectToDaemonOrThrow(options.host, host);
+    try {
+        const agent = await client.importAgent({
+            provider,
+            sessionId,
+            cwd,
+            ...(Object.keys(labels).length > 0 ? { labels } : {}),
+        });
+        await client.close();
+        return {
+            type: "single",
+            data: toImportResult(agent),
+            schema: agentRunSchema,
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        throw {
+            code: "AGENT_IMPORT_FAILED",
+            message: `Failed to import agent: ${message}`,
+        };
+    }
+}
+//# sourceMappingURL=import.js.map

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

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

package/dist/commands/agent/index.js

@@ -0,0 +1,48 @@
+import { Command } from "commander";
+import { runModeCommand } from "./mode.js";
+import { addArchiveOptions, runArchiveCommand } from "./archive.js";
+import { addDeleteOptions, runDeleteCommand } from "./delete.js";
+import { addLsOptions, runLsCommand } from "./ls.js";
+import { addRunOptions, runRunCommand } from "./run.js";
+import { addLogsOptions, runLogsCommand } from "./logs.js";
+import { addStopOptions, runStopCommand } from "./stop.js";
+import { addSendOptions, runSendCommand } from "./send.js";
+import { addInspectOptions, runInspectCommand } from "./inspect.js";
+import { addWaitOptions, runWaitCommand } from "./wait.js";
+import { addAttachOptions, runAttachCommand } from "./attach.js";
+import { addReloadOptions, runReloadCommand } from "./reload.js";
+import { addImportOptions, runImportCommand } from "./import.js";
+import { runUpdateCommand } from "./update.js";
+import { withOutput } from "../../output/index.js";
+import { addDaemonHostOption, addJsonAndDaemonHostOptions, collectMultiple, } from "../../utils/command-options.js";
+export function createAgentCommand() {
+    const agent = new Command("agent").description("Manage agents (advanced operations)");
+    // Primary agent commands (same as top-level)
+    addJsonAndDaemonHostOptions(addLsOptions(agent.command("ls"))).action(withOutput(runLsCommand));
+    addJsonAndDaemonHostOptions(addRunOptions(agent.command("run"))).action(withOutput(runRunCommand));
+    addJsonAndDaemonHostOptions(addImportOptions(agent.command("import"))).action(withOutput(runImportCommand));
+    addDaemonHostOption(addAttachOptions(agent.command("attach"))).action(runAttachCommand);
+    addDaemonHostOption(addLogsOptions(agent.command("logs"))).action(runLogsCommand);
+    addJsonAndDaemonHostOptions(addStopOptions(agent.command("stop"))).action(withOutput(runStopCommand));
+    addJsonAndDaemonHostOptions(addDeleteOptions(agent.command("delete"))).action(withOutput(runDeleteCommand));
+    addJsonAndDaemonHostOptions(addSendOptions(agent.command("send"))).action(withOutput(runSendCommand));
+    addJsonAndDaemonHostOptions(addInspectOptions(agent.command("inspect"))).action(withOutput(runInspectCommand));
+    addJsonAndDaemonHostOptions(addWaitOptions(agent.command("wait"))).action(withOutput(runWaitCommand));
+    // Advanced agent commands (less common operations)
+    addJsonAndDaemonHostOptions(agent
+        .command("mode")
+        .description("Change an agent's operational mode")
+        .argument("<id>", "Agent ID (or prefix)")
+        .argument("[mode]", "Mode to set (required unless --list)")
+        .option("--list", "List available modes for this agent")).action(withOutput(runModeCommand));
+    addJsonAndDaemonHostOptions(addArchiveOptions(agent.command("archive"))).action(withOutput(runArchiveCommand));
+    addJsonAndDaemonHostOptions(addReloadOptions(agent.command("reload"))).action(withOutput(runReloadCommand));
+    addJsonAndDaemonHostOptions(agent
+        .command("update")
+        .description("Update an agent's metadata")
+        .argument("<id>", "Agent ID (or prefix)")
+        .option("--name <name>", "Update the agent's display name")
+        .option("--label <label>", "Add/set label(s) on the agent (can be used multiple times or comma-separated)", collectMultiple, [])).action(withOutput(runUpdateCommand));
+    return agent;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/agent/inspect.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from "commander";
+import type { CommandOptions, ListResult } from "../../output/index.js";
+export declare function addInspectOptions(cmd: Command): Command;
+/** Key-value row for table display */
+interface InspectRow {
+    key: string;
+    value: string;
+}
+export type AgentInspectResult = ListResult<InspectRow>;
+export interface AgentInspectOptions extends CommandOptions {
+    host?: string;
+}
+export declare function runInspectCommand(agentIdArg: string, options: AgentInspectOptions, _command: Command): Promise<AgentInspectResult>;
+export {};
+//# sourceMappingURL=inspect.d.ts.map

package/dist/commands/agent/inspect.js

@@ -0,0 +1,209 @@
+import { PARENT_AGENT_ID_LABEL } from "@otto-code/protocol/agent-labels";
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+export function addInspectOptions(cmd) {
+    return cmd
+        .description("Show detailed information about an agent")
+        .argument("<id>", "Agent ID (or prefix)");
+}
+/** Schema for key-value display with custom serialization for JSON/YAML */
+function createInspectSchema(agent) {
+    return {
+        idField: "key",
+        columns: [
+            { header: "KEY", field: "key" },
+            {
+                header: "VALUE",
+                field: "value",
+                color: (_, item) => {
+                    if (item.key === "Status") {
+                        if (item.value === "running")
+                            return "green";
+                        if (item.value === "idle")
+                            return "yellow";
+                        if (item.value === "error")
+                            return "red";
+                    }
+                    return undefined;
+                },
+            },
+        ],
+        // For JSON/YAML, return the structured agent object
+        serialize: (_item) => agent,
+    };
+}
+/** Shorten home directory in path */
+function shortenPath(path) {
+    const home = process.env.HOME;
+    if (home && path.startsWith(home)) {
+        return "~" + path.slice(home.length);
+    }
+    return path;
+}
+/** Format cost in USD */
+function formatCost(costUsd) {
+    if (costUsd === 0)
+        return "$0.00";
+    if (costUsd < 0.01)
+        return `$${costUsd.toFixed(4)}`;
+    return `$${costUsd.toFixed(2)}`;
+}
+function normalizeModelId(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim();
+    if (!normalized || normalized.toLowerCase() === "default")
+        return null;
+    return normalized;
+}
+function resolveModel(snapshot) {
+    return normalizeModelId(snapshot.runtimeInfo?.model) ?? normalizeModelId(snapshot.model);
+}
+function buildLastUsage(snapshot) {
+    if (!snapshot.lastUsage)
+        return null;
+    return {
+        InputTokens: snapshot.lastUsage.inputTokens ?? 0,
+        OutputTokens: snapshot.lastUsage.outputTokens ?? 0,
+        CachedTokens: snapshot.lastUsage.cachedInputTokens ?? 0,
+        CostUsd: snapshot.lastUsage.totalCostUsd ?? 0,
+    };
+}
+function buildCapabilities(snapshot) {
+    if (!snapshot.capabilities)
+        return null;
+    return {
+        Streaming: snapshot.capabilities.supportsStreaming ?? false,
+        Persistence: snapshot.capabilities.supportsSessionPersistence ?? false,
+        DynamicModes: snapshot.capabilities.supportsDynamicModes ?? false,
+        McpServers: snapshot.capabilities.supportsMcpServers ?? false,
+    };
+}
+/** Convert agent snapshot to inspection data */
+function toInspectData(snapshot) {
+    return {
+        Id: snapshot.id,
+        Name: snapshot.title ?? "-",
+        Provider: snapshot.provider,
+        Model: resolveModel(snapshot) ?? "-",
+        Thinking: snapshot.effectiveThinkingOptionId ?? "auto",
+        Status: snapshot.status,
+        Archived: snapshot.archivedAt != null,
+        ArchivedAt: snapshot.archivedAt ?? null,
+        Mode: snapshot.currentModeId ?? "default",
+        Cwd: snapshot.cwd,
+        CreatedAt: snapshot.createdAt,
+        UpdatedAt: snapshot.updatedAt,
+        LastUsage: buildLastUsage(snapshot),
+        Capabilities: buildCapabilities(snapshot),
+        AvailableModes: snapshot.availableModes
+            ? snapshot.availableModes.map((m) => ({ id: m.id, label: m.label }))
+            : null,
+        PendingPermissions: (snapshot.pendingPermissions ?? []).map((p) => ({
+            id: p.id,
+            tool: p.name ?? "unknown",
+        })),
+        Worktree: snapshot.labels?.["otto.worktree"] ?? null,
+        ParentAgentId: snapshot.labels?.[PARENT_AGENT_ID_LABEL] ?? null,
+    };
+}
+/** Convert agent to key-value rows for table display */
+function toInspectRows(agent) {
+    const rows = [
+        { key: "Id", value: agent.Id },
+        { key: "Name", value: agent.Name },
+        { key: "Provider", value: agent.Provider },
+        { key: "Model", value: agent.Model },
+        { key: "Thinking", value: agent.Thinking },
+        { key: "Status", value: agent.Status },
+        { key: "Archived", value: String(agent.Archived) },
+        { key: "ArchivedAt", value: agent.ArchivedAt ?? "null" },
+        { key: "Mode", value: agent.Mode },
+        { key: "Cwd", value: shortenPath(agent.Cwd) },
+        { key: "CreatedAt", value: agent.CreatedAt },
+        { key: "UpdatedAt", value: agent.UpdatedAt },
+    ];
+    if (agent.LastUsage) {
+        rows.push({
+            key: "LastUsage",
+            value: `InputTokens: ${agent.LastUsage.InputTokens}, OutputTokens: ${agent.LastUsage.OutputTokens}, CachedTokens: ${agent.LastUsage.CachedTokens}, CostUsd: ${formatCost(agent.LastUsage.CostUsd)}`,
+        });
+    }
+    if (agent.Capabilities) {
+        rows.push({
+            key: "Capabilities",
+            value: `Streaming: ${agent.Capabilities.Streaming}, Persistence: ${agent.Capabilities.Persistence}, DynamicModes: ${agent.Capabilities.DynamicModes}, McpServers: ${agent.Capabilities.McpServers}`,
+        });
+    }
+    if (agent.AvailableModes && agent.AvailableModes.length > 0) {
+        rows.push({
+            key: "AvailableModes",
+            value: agent.AvailableModes.map((m) => `${m.id} (${m.label})`).join(", "),
+        });
+    }
+    rows.push({
+        key: "PendingPermissions",
+        value: agent.PendingPermissions.length > 0
+            ? agent.PendingPermissions.map((p) => `${p.id} (${p.tool})`).join(", ")
+            : "[]",
+    });
+    rows.push({ key: "Worktree", value: agent.Worktree ?? "null" });
+    rows.push({ key: "ParentAgentId", value: agent.ParentAgentId ?? "null" });
+    return rows;
+}
+export async function runInspectCommand(agentIdArg, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    // Validate arguments
+    if (!agentIdArg || agentIdArg.trim().length === 0) {
+        const error = {
+            code: "MISSING_AGENT_ID",
+            message: "Agent ID is required",
+            details: "Usage: otto agent inspect <id>",
+        };
+        throw error;
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "DAEMON_NOT_RUNNING",
+            message: `Cannot connect to daemon at ${host}: ${message}`,
+            details: "Start the daemon with: otto daemon start",
+        };
+        throw error;
+    }
+    try {
+        const fetchResult = await client.fetchAgent({ agentId: agentIdArg });
+        if (!fetchResult) {
+            const error = {
+                code: "AGENT_NOT_FOUND",
+                message: `Agent not found: ${agentIdArg}`,
+                details: 'Use "otto ls" to list available agents',
+            };
+            throw error;
+        }
+        await client.close();
+        const inspectData = toInspectData(fetchResult.agent);
+        return {
+            type: "list",
+            data: toInspectRows(inspectData),
+            schema: createInspectSchema(inspectData),
+        };
+    }
+    catch (err) {
+        await client.close().catch(() => { });
+        // Re-throw CommandError as-is
+        if (err && typeof err === "object" && "code" in err) {
+            throw err;
+        }
+        const message = err instanceof Error ? err.message : String(err);
+        const error = {
+            code: "INSPECT_FAILED",
+            message: `Failed to inspect agent: ${message}`,
+        };
+        throw error;
+    }
+}
+//# sourceMappingURL=inspect.js.map

package/dist/commands/agent/logs.d.ts

@@ -0,0 +1,19 @@
+import { Command } from "commander";
+import type { CommandOptions } from "../../output/index.js";
+import type { DaemonClient } from "@otto-code/client/internal/daemon-client";
+import type { AgentTimelineItem } from "@otto-code/protocol/agent-types";
+export declare function addLogsOptions(cmd: Command): Command;
+export interface AgentLogsOptions extends CommandOptions {
+    follow?: boolean;
+    tail?: string;
+    filter?: string;
+    since?: string;
+}
+export type AgentLogsResult = void;
+export declare const NO_ACTIVITY_MESSAGE = "No activity to display.";
+export declare function fetchAgentTimelineItems(client: DaemonClient, agentId: string, options?: {
+    timeoutMs?: number;
+}): Promise<AgentTimelineItem[]>;
+export declare function formatAgentActivityTranscript(timelineItems: AgentTimelineItem[], tailCount?: number): string;
+export declare function runLogsCommand(id: string, options: AgentLogsOptions, _command: Command): Promise<AgentLogsResult>;
+//# sourceMappingURL=logs.d.ts.map

package/dist/commands/agent/logs.js

@@ -0,0 +1,180 @@
+import { connectToDaemon, getDaemonHost } from "../../utils/client.js";
+import { fetchProjectedTimelineItems, LIVE_HISTORY_FETCH_TIMEOUT_MS, } from "../../utils/timeline.js";
+import { curateAgentActivity } from "@otto-code/server";
+export function addLogsOptions(cmd) {
+    return cmd
+        .description("View agent activity/timeline")
+        .argument("<id>", "Agent ID (or prefix)")
+        .option("-f, --follow", "Follow log output (streaming)")
+        .option("--tail <n>", "Show last n entries")
+        .option("--filter <type>", "Filter by event type (tools, text, errors, permissions)")
+        .option("--since <time>", "Show logs since timestamp");
+}
+export const NO_ACTIVITY_MESSAGE = "No activity to display.";
+export async function fetchAgentTimelineItems(client, agentId, options) {
+    return fetchProjectedTimelineItems({ client, agentId, timeoutMs: options?.timeoutMs });
+}
+export function formatAgentActivityTranscript(timelineItems, tailCount) {
+    if (tailCount === 0) {
+        return "";
+    }
+    return curateAgentActivity(timelineItems, tailCount !== undefined ? { maxItems: tailCount } : undefined);
+}
+function parseTailCount(raw) {
+    if (raw === undefined)
+        return undefined;
+    const parsed = Number.parseInt(raw, 10);
+    if (Number.isNaN(parsed) || parsed < 0) {
+        return undefined;
+    }
+    return parsed;
+}
+/**
+ * Check if a timeline item matches the filter type
+ */
+function matchesFilter(item, filter) {
+    if (!filter)
+        return true;
+    const filterLower = filter.toLowerCase();
+    const type = item.type.toLowerCase();
+    switch (filterLower) {
+        case "tools":
+            return type === "tool_call";
+        case "text":
+            return type === "user_message" || type === "assistant_message" || type === "reasoning";
+        case "errors":
+            return type === "error";
+        case "permissions":
+            // Permissions might be in tool_call status or a separate event type
+            return type.includes("permission");
+        default:
+            // If filter doesn't match predefined types, match against the actual type
+            return type.includes(filterLower);
+    }
+}
+export async function runLogsCommand(id, options, _command) {
+    const host = getDaemonHost({ host: options.host });
+    if (!id) {
+        console.error("Error: Agent ID required");
+        console.error("Usage: otto agent logs <id>");
+        process.exit(1);
+    }
+    let client;
+    try {
+        client = await connectToDaemon({ host: options.host });
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Error: Cannot connect to daemon at ${host}: ${message}`);
+        console.error("Start the daemon with: otto daemon start");
+        process.exit(1);
+    }
+    try {
+        const fetchResult = await client.fetchAgent({ agentId: id });
+        if (!fetchResult) {
+            console.error(`Error: No agent found matching: ${id}`);
+            console.error("Use `otto ls` to list available agents");
+            await client.close();
+            process.exit(1);
+        }
+        const resolvedId = fetchResult.agent.id;
+        // For follow mode, we stream events continuously
+        if (options.follow) {
+            if (options.tail !== undefined && parseTailCount(options.tail) === undefined) {
+                console.error(`Error: Invalid --tail value: ${options.tail}`);
+                console.error("Usage: --tail <n> (where n is >= 0)");
+                await client.close().catch(() => { });
+                process.exit(1);
+            }
+            await runFollowMode(client, resolvedId, options);
+            return;
+        }
+        // Fetch timeline directly via cursor RPC.
+        let timelineItems = await fetchAgentTimelineItems(client, resolvedId);
+        // Apply filter
+        if (options.filter) {
+            timelineItems = timelineItems.filter((item) => matchesFilter(item, options.filter));
+        }
+        const tailCount = parseTailCount(options.tail);
+        if (options.tail !== undefined && tailCount === undefined) {
+            console.error(`Error: Invalid --tail value: ${options.tail}`);
+            console.error("Usage: --tail <n> (where n is >= 0)");
+            await client.close().catch(() => { });
+            process.exit(1);
+        }
+        await client.close();
+        // Use curateAgentActivity to format the transcript
+        if (tailCount === 0) {
+            return;
+        }
+        const transcript = formatAgentActivityTranscript(timelineItems, tailCount);
+        console.log(transcript);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(`Error: Failed to get logs: ${message}`);
+        await client.close().catch(() => { });
+        process.exit(1);
+    }
+}
+/**
+ * Follow mode: stream logs in real-time until interrupted
+ */
+async function runFollowMode(client, agentId, options) {
+    const DEFAULT_FOLLOW_TAIL = 10;
+    const tailCount = parseTailCount(options.tail) ?? DEFAULT_FOLLOW_TAIL;
+    // First, get existing timeline.
+    let existingItems = [];
+    try {
+        existingItems = await fetchAgentTimelineItems(client, agentId, {
+            timeoutMs: LIVE_HISTORY_FETCH_TIMEOUT_MS,
+        });
+    }
+    catch (error) {
+        console.warn("Warning: failed to fetch existing timeline", error);
+    }
+    // Apply filter to existing items
+    if (options.filter) {
+        existingItems = existingItems.filter((item) => matchesFilter(item, options.filter));
+    }
+    // Print existing transcript (tail-like behavior)
+    if (tailCount > 0) {
+        const existingTranscript = formatAgentActivityTranscript(existingItems, tailCount);
+        if (existingTranscript !== NO_ACTIVITY_MESSAGE) {
+            console.log(existingTranscript);
+        }
+    }
+    // Subscribe to new events
+    const tailLabel = tailCount === 0 ? "no history" : `last ${tailCount} entr${tailCount === 1 ? "y" : "ies"}`;
+    console.log(`\n--- Following logs (${tailLabel}; Ctrl+C to stop) ---\n`);
+    const unsubscribe = client.on("agent_stream", (msg) => {
+        const message = msg;
+        if (message.type !== "agent_stream")
+            return;
+        if (message.payload.agentId !== agentId)
+            return;
+        if (message.payload.event.type === "timeline") {
+            const item = message.payload.event.item;
+            // Apply filter
+            if (options.filter && !matchesFilter(item, options.filter)) {
+                return;
+            }
+            // Print each timeline item as it arrives using the curator format
+            const transcript = formatAgentActivityTranscript([item]);
+            if (transcript !== NO_ACTIVITY_MESSAGE) {
+                console.log(transcript);
+            }
+        }
+    });
+    // Wait for interrupt
+    await new Promise((resolve) => {
+        const cleanup = () => {
+            unsubscribe();
+            resolve();
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+    });
+    await client.close();
+}
+//# sourceMappingURL=logs.js.map

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

@@ -0,0 +1,44 @@
+import type { Command } from "commander";
+import { connectToDaemon } from "../../utils/client.js";
+import type { CommandOptions, ListResult, OutputSchema } from "../../output/index.js";
+type FetchAgentsOptions = NonNullable<Parameters<Awaited<ReturnType<typeof connectToDaemon>>["fetchAgents"]>[0]>;
+export declare function addLsOptions(cmd: Command): Command;
+/** Agent list item for display */
+export interface AgentListItem {
+    id: string;
+    shortId: string;
+    name: string;
+    provider: string;
+    thinking: string;
+    status: string;
+    cwd: string;
+    created: string;
+}
+/** Schema for agent ls output */
+export declare const agentLsSchema: OutputSchema<AgentListItem>;
+export type AgentLsResult = ListResult<AgentListItem>;
+export interface AgentLsOptions extends CommandOptions {
+    /** -a: Include archived agents */
+    all?: boolean;
+    /** -g: List agents across all directories */
+    global?: boolean;
+    /** Filter by specific status */
+    status?: string;
+    /** Filter by specific cwd */
+    cwd?: string;
+    /** Filter by labels (key=value format) */
+    label?: string[];
+    /** Filter by thinking option ID */
+    thinking?: string;
+}
+export declare function buildAgentLsFetchOptions(options: Pick<AgentLsOptions, "all" | "global" | "label" | "thinking">): FetchAgentsOptions;
+/**
+ * Agent ls command semantics:
+ * - `otto agent ls`    → active non-archived agents
+ * - `otto agent ls -g` → global non-archived agents
+ * - `otto agent ls -a` → active agents, including archived
+ * - `otto agent ls -ag` → global agents, including archived
+ */
+export declare function runLsCommand(options: AgentLsOptions, _command: Command): Promise<AgentLsResult>;
+export {};
+//# sourceMappingURL=ls.d.ts.map