@agent-native/core 0.15.12 → 0.16.0

package/dist/cli/code.js

@@ -0,0 +1,1306 @@
+import { createInterface } from "node:readline";
+import { CODE_AGENT_PERMISSION_MODES, appendCodeAgentTranscriptEvent, createCodeAgentRunRecord, getCodeAgentRunRecord, getLastCodeAgentRunRecord, isActiveCodeAgentRun, listCodeAgentRunRecords, listCodeAgentTranscriptEvents, normalizeCodeAgentPermissionMode, queueCodeAgentFollowUp, updateCodeAgentRunRecord, } from "./code-agent-runs.js";
+import { findProjectSlashCommand, listProjectSlashCommands, renderProjectSlashCommandPrompt, } from "./code-agent-commands.js";
+import { executeCodeAgentRun, executeExistingCodeAgentRun, executePendingCodeAgentApproval, } from "./code-agent-executor.js";
+import { runAuditAgentWeb } from "./audit-agent-web.js";
+import { runMigrate } from "./migrate.js";
+export const CODE_AGENT_CLI_GOALS = [
+    {
+        id: "task",
+        slashCommand: "/task",
+        aliases: ["task", "todo"],
+        summary: "Run a generic coding task as a resumable Agent-Native Code session.",
+        backingCommand: "task",
+    },
+    {
+        id: "migrate",
+        slashCommand: "/migrate",
+        aliases: ["migrate", "migration"],
+        summary: "Move a path, URL, or described product into agent-native with verification.",
+        backingCommand: "migrate",
+    },
+    {
+        id: "audit",
+        slashCommand: "/audit",
+        aliases: ["audit", "audit-agent-web", "agent-web"],
+        summary: "Audit a public URL for agent-readable surfaces such as llms.txt and markdown mirrors.",
+        backingCommand: "audit-agent-web",
+    },
+];
+const CODE_AGENT_CONTROL_SUBCOMMANDS = new Set([
+    "approve",
+    "attach",
+    "list",
+    "logs",
+    "ps",
+    "resume",
+    "status",
+    "stop",
+    "ui",
+]);
+const SHELL_PROMPT = "code> ";
+export function resolveCodeCommand(argv) {
+    const [rawFirst, ...rest] = argv;
+    if (!rawFirst) {
+        return { kind: "shell" };
+    }
+    if (rawFirst === "--help" || rawFirst === "-h") {
+        return { kind: "help" };
+    }
+    const first = normalizeGoalToken(rawFirst);
+    if (first === "goals") {
+        return { kind: "list-goals" };
+    }
+    if (first === "serve") {
+        return { kind: "serve", relayUrl: parseRelayUrlOption(rest) };
+    }
+    if (first === "exec" || first === "e") {
+        return {
+            kind: "run-goal",
+            goalId: "task",
+            forwardedArgs: rest,
+        };
+    }
+    if (first === "--print" || first === "-p") {
+        return {
+            kind: "run-goal",
+            goalId: "task",
+            forwardedArgs: rest,
+        };
+    }
+    if (first === "--continue" || first === "-c") {
+        const parsed = parseFollowUpArgs(rest);
+        return parsed.prompt
+            ? {
+                kind: "record-follow-up",
+                prompt: parsed.prompt,
+                ...(parsed.followUpMode === "queued"
+                    ? { followUpMode: parsed.followUpMode }
+                    : {}),
+                ...(parsed.permissionModeExplicit
+                    ? { permissionMode: parsed.permissionMode }
+                    : {}),
+            }
+            : {
+                kind: "control",
+                subcommand: "resume",
+                args: ["resume", "--last"],
+            };
+    }
+    if (first === "--resume" || first === "-r") {
+        return {
+            kind: "control",
+            subcommand: "resume",
+            args: ["resume", ...rest],
+        };
+    }
+    if ((first === "run" || first === "start") && rest[0]) {
+        return { kind: "execute-existing-run", runId: rest[0] };
+    }
+    const followUp = parseResumeFollowUpPrompt([rawFirst, ...rest]);
+    if (followUp) {
+        return {
+            kind: "record-follow-up",
+            prompt: followUp.prompt,
+            runId: followUp.runId,
+            ...(followUp.followUpMode ? { followUpMode: followUp.followUpMode } : {}),
+            ...(followUp.permissionMode
+                ? { permissionMode: followUp.permissionMode }
+                : {}),
+        };
+    }
+    const goal = findGoal(first);
+    if (goal) {
+        return {
+            kind: "run-goal",
+            goalId: goal.id,
+            forwardedArgs: rest,
+        };
+    }
+    if (rawFirst.startsWith("/")) {
+        const projectCommand = findProjectSlashCommand(first);
+        if (projectCommand) {
+            return {
+                kind: "run-project-command",
+                commandName: projectCommand.name,
+                forwardedArgs: rest,
+            };
+        }
+    }
+    if (isCodeAgentControlSubcommand(first)) {
+        return {
+            kind: "control",
+            subcommand: first,
+            args: [first, ...rest],
+        };
+    }
+    return {
+        kind: "run-goal",
+        goalId: "task",
+        forwardedArgs: argv,
+    };
+}
+export async function runCode(argv, options = {}) {
+    const command = resolveCodeCommand(argv);
+    const output = options.output ?? process.stdout;
+    const runGoal = options.runGoal ?? runCodeGoal;
+    if (command.kind === "shell") {
+        await runCodeShell({ ...options, output, runGoal });
+        return;
+    }
+    if (command.kind === "help") {
+        writeLine(output, codeUsage());
+        return;
+    }
+    if (command.kind === "list-goals") {
+        writeLine(output, renderGoalList());
+        return;
+    }
+    if (command.kind === "serve") {
+        const { runCodeAgentConnector } = await import("./code-agent-connector.js");
+        const exitCode = await runCodeAgentConnector({
+            relayUrl: command.relayUrl,
+            output,
+        });
+        if (exitCode !== 0)
+            process.exitCode = exitCode;
+        return;
+    }
+    if (command.kind === "execute-existing-run") {
+        await executeExistingCodeAgentRun(command.runId, { stdout: output });
+        return;
+    }
+    if (command.kind === "control") {
+        await runCodeAgentControl(command.subcommand, command.args, output);
+        return;
+    }
+    if (command.kind === "record-follow-up") {
+        await recordCodeAgentFollowUpPrompt(command.prompt, output, command.permissionMode, command.runId, command.followUpMode);
+        return;
+    }
+    if (command.kind === "run-project-command") {
+        await runProjectSlashCommand(command.commandName, command.forwardedArgs, output);
+        return;
+    }
+    await runGoal(command.goalId, command.forwardedArgs, output);
+}
+export async function runCodeShell(options = {}) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    const runGoal = options.runGoal ?? runCodeGoal;
+    const rl = createInterface({
+        input,
+        output,
+        terminal: isInteractiveTerminal(input, output),
+    });
+    writeLine(output, codeShellIntro());
+    writePrompt(output);
+    try {
+        for await (const line of rl) {
+            const result = await handleCodeShellLine(line, { output, runGoal });
+            if (result === "exit") {
+                break;
+            }
+            writePrompt(output);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+export async function handleCodeShellLine(line, options) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return "continue";
+    }
+    const parsed = parseCodeShellArgs(trimmed);
+    if ("error" in parsed) {
+        writeLine(options.output, parsed.error);
+        return "continue";
+    }
+    const [rawFirst, ...rest] = parsed.args;
+    if (!rawFirst) {
+        return "continue";
+    }
+    const followUp = parseResumeFollowUpPrompt(parsed.args);
+    if (followUp) {
+        await recordCodeAgentFollowUpPrompt(followUp.prompt, options.output, followUp.permissionMode, followUp.runId, followUp.followUpMode);
+        return "continue";
+    }
+    if (rawFirst.startsWith("/")) {
+        const first = normalizeGoalToken(rawFirst);
+        if (first === "help") {
+            writeLine(options.output, codeShellHelp());
+            return "continue";
+        }
+        if (first === "goals") {
+            writeLine(options.output, renderGoalList());
+            return "continue";
+        }
+        if (first === "exit" || first === "quit") {
+            writeLine(options.output, "Leaving Agent-Native Code.");
+            return "exit";
+        }
+        const goal = findGoal(first);
+        if (goal) {
+            await options.runGoal(goal.id, rest, options.output);
+            return "continue";
+        }
+        const projectCommand = findProjectSlashCommand(first);
+        if (projectCommand) {
+            await runProjectSlashCommand(projectCommand.name, rest, options.output);
+            return "continue";
+        }
+        writeLine(options.output, `Unknown slash command: ${rawFirst}\nTry /help to see available commands.`);
+        return "continue";
+    }
+    const first = normalizeGoalToken(rawFirst);
+    if (first === "exec" || first === "e") {
+        await options.runGoal("task", rest, options.output);
+        return "continue";
+    }
+    if (first === "--print" || first === "-p") {
+        await options.runGoal("task", rest, options.output);
+        return "continue";
+    }
+    if (first === "--continue" || first === "-c") {
+        const parsedTask = parseFollowUpArgs(rest);
+        if (parsedTask.prompt) {
+            await recordCodeAgentFollowUpPrompt(parsedTask.prompt, options.output, parsedTask.permissionModeExplicit
+                ? parsedTask.permissionMode
+                : undefined, undefined, parsedTask.followUpMode);
+        }
+        else {
+            await runCodeAgentControl("resume", ["resume", "--last"], options.output);
+        }
+        return "continue";
+    }
+    if (first === "--resume" || first === "-r") {
+        await runCodeAgentControl("resume", ["resume", ...rest], options.output);
+        return "continue";
+    }
+    if ((first === "run" || first === "start") && rest[0]) {
+        await executeExistingCodeAgentRun(rest[0], { stdout: options.output });
+        return "continue";
+    }
+    if (isCodeAgentControlSubcommand(first)) {
+        await runCodeAgentControl(first, parsed.args, options.output);
+        return "continue";
+    }
+    await options.runGoal("task", parsed.args, options.output);
+    return "continue";
+}
+export function codeUsage() {
+    return `agent-native code
+
+Open the Agent-Native Code shell or run a coding-agent goal directly.
+
+Usage:
+  agent-native code
+  agent-native code "fix the failing auth tests"
+  agent-native code exec "fix the failing auth tests"
+  agent-native code -p "fix the failing auth tests"
+  agent-native code --plan "explain this repo"
+  agent-native code --auto "fix the failing auth tests"
+  agent-native code /review-diff
+  agent-native code /audit --url https://example.com
+  agent-native code /migrate <source> [--out ../migrated-app]
+  agent-native code /migrate --describe "what to build or migrate"
+  agent-native code attach --last
+  agent-native code logs --last
+  agent-native code approve --last
+  agent-native code list
+  agent-native code resume --last "follow-up prompt"
+  agent-native code --continue "follow-up prompt"
+  agent-native code resume --last
+  agent-native code status --last
+  agent-native code serve --relay-url <url>
+  agent-native code ui --last
+  agent-native code run <runId>
+  agent-native code goals
+
+Interactive shell:
+  /help        Show shell commands
+  /goals       List available coding-agent goals
+  /migrate ... Run the migration goal
+  /audit ...   Run the web audit goal
+  /<project>   Run .agents/commands/<project>.md
+  /exit        Leave the shell
+
+Session commands:
+  list         List recent sessions
+  attach ...   Attach to a run transcript, following active work
+  logs ...     Print a run transcript once
+  approve ...  Run one pending approved command, then resume the session
+  resume ...   Continue the latest or selected run
+  status ...   Show run status
+  stop ...     Stop a tracked Desktop/CLI runner
+  serve ...    Run the remote relay connector
+
+Modes:
+  --plan, --auto
+  --permission-mode read-only|ask-before-edit|auto-edit|full-auto
+  --read-only, --ask-before-edit, --auto-edit, --full-auto
+
+Available goals:
+${renderGoalRows()}
+${renderProjectCommandRows()}
+
+The existing shortcut still works:
+  agent-native migrate <source> [options]`;
+}
+export function codeShellIntro() {
+    return `Agent-Native Code
+Type a coding task to start a session, /help for commands, /goals for goals, or /exit to leave.`;
+}
+export function codeShellHelp() {
+    return `Agent-Native Code shell commands:
+  /help        Show this help
+  /goals       List available coding-agent goals
+  /migrate ... Move a source into agent-native
+  /audit ...   Audit a public URL for agent-readable surfaces
+  /<project>   Run a project command from .agents/commands/*.md
+  /exit        Leave the shell
+  /quit        Leave the shell
+
+Compatibility shortcuts:
+  exec "prompt"
+  -p "prompt"
+  list
+  ps
+  attach --last
+  logs --last
+  approve --last
+  resume --last "follow-up prompt"
+  --continue "follow-up prompt"
+  resume --last
+  status --last
+  ui --last
+  stop --last`;
+}
+export function codeShellFreeTextMessage() {
+    return `Bare prompts run as generic Agent-Native Code sessions.
+Use /migrate and /audit for specialized goals.`;
+}
+export function parseCodeShellArgs(line) {
+    const args = [];
+    let current = "";
+    let quote;
+    let escaping = false;
+    let hasValue = false;
+    const pushCurrent = () => {
+        if (hasValue) {
+            args.push(current);
+            current = "";
+            hasValue = false;
+        }
+    };
+    for (const char of line) {
+        if (escaping) {
+            current += char;
+            hasValue = true;
+            escaping = false;
+            continue;
+        }
+        if (char === "\\" && quote !== "'") {
+            escaping = true;
+            hasValue = true;
+            continue;
+        }
+        if (quote) {
+            if (char === quote) {
+                quote = undefined;
+            }
+            else {
+                current += char;
+                hasValue = true;
+            }
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            hasValue = true;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            pushCurrent();
+            continue;
+        }
+        current += char;
+        hasValue = true;
+    }
+    if (escaping) {
+        current += "\\";
+    }
+    if (quote) {
+        return { ok: false, error: `Unclosed ${quote} quote.` };
+    }
+    pushCurrent();
+    return { ok: true, args };
+}
+function renderGoalList() {
+    return `Available Agent-Native Code goals:
+${renderGoalRows()}
+${renderProjectCommandRows()}`;
+}
+function renderGoalRows() {
+    return CODE_AGENT_CLI_GOALS.map((goal) => `  ${goal.slashCommand.padEnd(12)} ${goal.summary}`).join("\n");
+}
+function renderProjectCommandRows() {
+    const commands = listVisibleProjectSlashCommands();
+    if (commands.length === 0)
+        return "";
+    return [
+        "",
+        "Project commands:",
+        ...commands.map((command) => {
+            const args = command.argumentHint ? ` ${command.argumentHint}` : "";
+            const description = command.description ?? "Project slash command.";
+            return `  /${command.name}${args}`.padEnd(24) + description;
+        }),
+    ].join("\n");
+}
+function listVisibleProjectSlashCommands() {
+    return listProjectSlashCommands().filter((command) => !isReservedSlashName(command.name));
+}
+function isReservedSlashName(name) {
+    const normalized = normalizeGoalToken(name);
+    return (Boolean(findGoal(normalized)) ||
+        isCodeAgentControlSubcommand(normalized) ||
+        normalized === "help" ||
+        normalized === "exit" ||
+        normalized === "quit" ||
+        normalized === "goals");
+}
+function normalizeGoalToken(value) {
+    return value.replace(/^\//, "").toLowerCase();
+}
+function findGoal(value) {
+    const normalized = normalizeGoalToken(value);
+    return CODE_AGENT_CLI_GOALS.find((goal) => goal.id === normalized ||
+        normalizeGoalToken(goal.slashCommand) === normalized ||
+        goal.aliases.includes(normalized));
+}
+function isCodeAgentControlSubcommand(value) {
+    return CODE_AGENT_CONTROL_SUBCOMMANDS.has(value);
+}
+function parseResumeFollowUpPrompt(args) {
+    const [rawFirst, ...rest] = args;
+    if (normalizeGoalToken(rawFirst ?? "") !== "resume")
+        return null;
+    const selector = parseResumeSelectorAndPrompt(rest);
+    if (!selector)
+        return null;
+    if (!selector.hasSeparator &&
+        !selector.promptArgs.some((arg) => !arg.startsWith("-"))) {
+        return null;
+    }
+    const parsed = parseFollowUpArgs(selector.promptArgs);
+    return parsed.prompt
+        ? {
+            prompt: parsed.prompt,
+            runId: selector.runId,
+            ...(parsed.followUpMode === "queued"
+                ? { followUpMode: parsed.followUpMode }
+                : {}),
+            permissionMode: parsed.permissionModeExplicit
+                ? parsed.permissionMode
+                : undefined,
+        }
+        : null;
+}
+function parseResumeSelectorAndPrompt(args) {
+    const lastIndex = args.indexOf("--last");
+    if (lastIndex !== -1) {
+        const promptArgs = args.filter((_, index) => index !== lastIndex);
+        const separatorIndex = promptArgs.indexOf("--");
+        return {
+            promptArgs: separatorIndex === -1
+                ? promptArgs
+                : promptArgs.slice(separatorIndex + 1),
+            hasSeparator: separatorIndex !== -1,
+        };
+    }
+    const [maybeRunId, ...rest] = args;
+    if (!maybeRunId ||
+        maybeRunId.startsWith("-") ||
+        !looksLikeRunId(maybeRunId)) {
+        return null;
+    }
+    const separatorIndex = rest.indexOf("--");
+    return {
+        runId: maybeRunId,
+        promptArgs: separatorIndex === -1 ? rest : rest.slice(separatorIndex + 1),
+        hasSeparator: separatorIndex !== -1,
+    };
+}
+function looksLikeRunId(value) {
+    return /^[a-z][a-z0-9-]*-(?:\d{14}|\d{8}t\d{6}z)-[a-f0-9]{8}$/i.test(value);
+}
+function parseRelayUrlOption(args) {
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--relay-url" && args[i + 1])
+            return args[i + 1];
+        if (arg.startsWith("--relay-url=")) {
+            const value = arg.slice("--relay-url=".length).trim();
+            if (value)
+                return value;
+        }
+    }
+    return undefined;
+}
+async function runCodeAgentControl(subcommand, args, output, allowPicker = true) {
+    const runs = listCodeAgentRunRecords();
+    const effectiveArgs = await maybePickRunArgs(subcommand, runs, args, output, allowPicker);
+    if (!effectiveArgs) {
+        writeLine(output, "No Agent-Native Code session selected.");
+        return;
+    }
+    switch (subcommand) {
+        case "approve":
+            await approveCodeAgentRun(runs, effectiveArgs, output);
+            return;
+        case "attach":
+            await attachCodeAgentRun(runs, effectiveArgs, output);
+            return;
+        case "logs":
+            writeLine(output, renderCodeAgentLogs(runs, effectiveArgs));
+            return;
+        case "list":
+        case "ps":
+            writeLine(output, renderCodeAgentSessionList(runs));
+            return;
+        case "status":
+            writeLine(output, renderCodeAgentStatus(runs, effectiveArgs));
+            return;
+        case "resume":
+            writeLine(output, renderCodeAgentResume(runs, effectiveArgs));
+            return;
+        case "ui":
+            writeLine(output, renderCodeAgentUi(runs, effectiveArgs));
+            return;
+        case "stop":
+            writeLine(output, stopCodeAgentRun(runs, effectiveArgs));
+            return;
+    }
+}
+async function maybePickRunArgs(subcommand, runs, args, output, allowPicker) {
+    if (!allowPicker ||
+        !["approve", "attach", "logs", "resume"].includes(subcommand) ||
+        args.includes("--last") ||
+        hasExplicitRunId(args) ||
+        runs.length === 0 ||
+        !isInteractiveTerminal(process.stdin, output)) {
+        return args;
+    }
+    const selected = await promptForRunSelection(runs, output);
+    return selected ? [subcommand, selected.id] : null;
+}
+async function promptForRunSelection(runs, output) {
+    const choices = runs.slice(0, 10);
+    writeLine(output, "");
+    writeLine(output, "Select an Agent-Native Code session:");
+    choices.forEach((run, index) => {
+        writeLine(output, `  ${index + 1}. ${run.id}`);
+        writeLine(output, `     /${run.goalId} ${run.status}${run.phase ? ` (${run.phase})` : ""}  updated ${run.updatedAt}`);
+        writeLine(output, `     ${truncateForDisplay(run.title, 90)}`);
+    });
+    writeLine(output, "");
+    const rl = createInterface({
+        input: process.stdin,
+        output,
+        terminal: true,
+    });
+    const answer = await new Promise((resolve) => {
+        rl.question("Run number or id (blank cancels): ", resolve);
+    });
+    rl.close();
+    const trimmed = answer.trim();
+    if (!trimmed) {
+        writeLine(output, "No run selected.");
+        return null;
+    }
+    const index = Number(trimmed);
+    if (Number.isInteger(index) && index >= 1 && index <= choices.length) {
+        return choices[index - 1] ?? null;
+    }
+    const matchingRun = choices.find((run) => run.id === trimmed) ??
+        choices.find((run) => run.id.startsWith(trimmed));
+    if (matchingRun)
+        return matchingRun;
+    writeLine(output, "No matching run selected.");
+    return null;
+}
+function renderCodeAgentSessionList(runs) {
+    return [
+        "",
+        "Agent-Native Code sessions",
+        "",
+        runs.length === 0
+            ? "  No Agent-Native Code sessions found."
+            : `  ${runs.length} session${runs.length === 1 ? "" : "s"} found. Most recent first.`,
+        ...runs.slice(0, 10).map(renderCodeAgentRunListItem),
+        runs.length > 10 ? `  - ${runs.length - 10} more...` : "",
+        "",
+        runs.length > 0 ? "Inspect a session:" : "",
+        runs.length > 0 ? "  agent-native code status <runId>" : "",
+        runs.length > 0 ? "  agent-native code logs <runId>" : "",
+        runs.length > 0 ? "  agent-native code resume <runId>" : "",
+        runs.length > 0
+            ? '  agent-native code resume <runId> "follow-up prompt"'
+            : 'Start one with: agent-native code "what to change"',
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function renderCodeAgentStatus(runs, args) {
+    const selected = selectCodeAgentRun(runs, args, {
+        defaultToLast: args.includes("--last") || hasExplicitRunId(args),
+    });
+    if (selected) {
+        return renderCodeAgentRunDetail("Agent-Native Code status", selected);
+    }
+    return [
+        "",
+        "Agent-Native Code status",
+        "",
+        runs.length === 0
+            ? "  No Agent-Native Code sessions found."
+            : `  ${runs.length} session${runs.length === 1 ? "" : "s"} found.`,
+        ...runs.slice(0, 10).map(renderCodeAgentRunListItem),
+        runs.length > 10 ? `  - ${runs.length - 10} more...` : "",
+        "",
+        'Start one with: agent-native code "what to change"',
+        'Add a follow-up with: agent-native code resume --last "what next"',
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function renderCodeAgentResume(runs, args) {
+    const run = selectCodeAgentRun(runs, args, { defaultToLast: true });
+    if (!run) {
+        return [
+            "",
+            "Agent-Native Code resume",
+            "",
+            "  No Agent-Native Code sessions found.",
+            "",
+            'Start one with: agent-native code "what to change"',
+        ].join("\n");
+    }
+    const transcriptEvents = listCodeAgentTranscriptEvents(run.id);
+    const latestEvent = transcriptEvents.at(-1);
+    const followUpTarget = args.includes("--last") ? "--last" : run.id;
+    return [
+        "",
+        "Agent-Native Code resume",
+        "",
+        `  Run:     ${run.id}`,
+        `  Goal:    /${run.goalId}`,
+        `  Title:   ${run.title}`,
+        `  Status:  ${run.status}${run.phase ? ` (${run.phase})` : ""}`,
+        run.permissionMode
+            ? `  Mode:    ${formatCodeAgentRunMode(run.permissionMode)}`
+            : "",
+        `  Updated: ${run.updatedAt}`,
+        latestEvent
+            ? `  Last:    ${truncateForDisplay(latestEvent.message, 140)}`
+            : "",
+        "",
+        "Resume execution:",
+        `  agent-native code run ${run.id}`,
+        "",
+        "Attach to the live transcript:",
+        `  agent-native code attach ${run.id}`,
+        "",
+        "Append and run a follow-up:",
+        `  agent-native code resume ${followUpTarget} "next instruction"`,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function renderCodeAgentUi(runs, args) {
+    const run = selectCodeAgentRun(runs, args, { defaultToLast: true });
+    return [
+        "",
+        "Agent-Native Code UI",
+        "",
+        "Open Agent-Native Desktop and choose Agent-Native Code from the left sidebar.",
+        run ? `Run: ${run.id}` : "No run selected yet.",
+        run ? `Deep link: agentnative://open?app=code-agents&run=${run.id}` : "",
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function stopCodeAgentRun(runs, args) {
+    const run = selectCodeAgentRun(runs, args, { defaultToLast: true });
+    if (run &&
+        (run.status === "completed" ||
+            run.status === "errored" ||
+            run.phase === "complete" ||
+            run.phase === "error")) {
+        return [
+            "",
+            "Agent-Native Code stop",
+            "",
+            `  Run: ${run.id}`,
+            `  Status: ${run.status}${run.phase ? ` (${run.phase})` : ""}`,
+            "",
+            "  This run is already finished; no stop signal was sent.",
+        ].join("\n");
+    }
+    if (run) {
+        const pid = Number(run.metadata?.runnerPid);
+        let killed = false;
+        let killError = "";
+        if (Number.isFinite(pid) && pid > 0) {
+            try {
+                process.kill(pid, "SIGTERM");
+                killed = true;
+            }
+            catch (err) {
+                killError = err instanceof Error ? err.message : String(err);
+            }
+        }
+        appendCodeAgentTranscriptEvent({
+            runId: run.id,
+            kind: "status",
+            message: killed
+                ? "Stop requested for Agent-Native Code runner."
+                : "Stop requested; no active runner process was found from the CLI.",
+            metadata: {
+                source: "cli-stop",
+                pid: Number.isFinite(pid) ? pid : undefined,
+                killed,
+                killError: killError || undefined,
+            },
+        });
+        updateCodeAgentRunRecord(run.id, {
+            status: "paused",
+            phase: "stopped",
+            progress: {
+                label: "Stopped",
+                completed: 0,
+                total: 1,
+                percent: 0,
+            },
+            metadata: {
+                stoppedAt: new Date().toISOString(),
+                stoppedBy: "cli",
+                stopSignalSent: killed,
+                stopError: killError || undefined,
+            },
+        });
+    }
+    return [
+        "",
+        "Agent-Native Code stop",
+        "",
+        run ? `  Run: ${run.id}` : "  No Agent-Native Code session selected.",
+        "",
+        run
+            ? "  Stop requested. If a tracked runner process is active, it received SIGTERM."
+            : '  Start one with: agent-native code "what to change"',
+    ].join("\n");
+}
+async function approveCodeAgentRun(runs, args, output) {
+    const run = selectCodeAgentRun(runs, args, {
+        defaultToLast: args.includes("--last"),
+    });
+    if (!run) {
+        writeLine(output, [
+            "",
+            "Agent-Native Code approve",
+            "",
+            "  No Agent-Native Code session selected.",
+            "",
+            "Try: agent-native code approve --last",
+        ].join("\n"));
+        return;
+    }
+    writeLine(output, [
+        "",
+        "Agent-Native Code approve",
+        "",
+        `  Run: ${run.id}`,
+        "",
+        "Running the pending approved command.",
+    ].join("\n"));
+    await executePendingCodeAgentApproval(run.id, { stdout: output });
+    writeLine(output, [
+        "",
+        "Approval step finished.",
+        "",
+        "Resume the Agent-Native Code session:",
+        `  agent-native code run ${run.id}`,
+    ].join("\n"));
+}
+function renderCodeAgentLogs(runs, args) {
+    const run = selectCodeAgentRun(runs, args, { defaultToLast: true });
+    if (!run) {
+        return [
+            "",
+            "Agent-Native Code logs",
+            "",
+            "  No Agent-Native Code session selected.",
+            "",
+            "Try: agent-native code logs --last",
+        ].join("\n");
+    }
+    const events = listCodeAgentTranscriptEvents(run.id);
+    return [
+        "",
+        `Agent-Native Code logs: ${run.id}`,
+        `/${run.goalId} ${run.status}${run.phase ? ` (${run.phase})` : ""}`,
+        run.title,
+        `Updated: ${run.updatedAt}`,
+        `Events: ${events.length}`,
+        "",
+        events.length === 0
+            ? "  No transcript events recorded yet."
+            : events.map(renderTranscriptEventForCli).join("\n"),
+    ].join("\n");
+}
+async function attachCodeAgentRun(runs, args, output) {
+    const run = selectCodeAgentRun(runs, args, { defaultToLast: true });
+    if (!run) {
+        writeLine(output, [
+            "",
+            "Agent-Native Code attach",
+            "",
+            "  No Agent-Native Code session selected.",
+            "",
+            "Try: agent-native code attach --last",
+        ].join("\n"));
+        return;
+    }
+    const follow = !args.includes("--no-follow");
+    const printed = new Set();
+    writeLine(output, "");
+    writeLine(output, `Attaching to Agent-Native Code run ${run.id}`);
+    writeLine(output, "Press Ctrl+C to detach. The session keeps its transcript.");
+    writeLine(output, "");
+    const printNewEvents = () => {
+        const events = listCodeAgentTranscriptEvents(run.id);
+        for (const event of events) {
+            const key = `${event.id}:${event.createdAt}`;
+            if (printed.has(key))
+                continue;
+            printed.add(key);
+            writeLine(output, renderTranscriptEventForCli(event));
+        }
+    };
+    printNewEvents();
+    if (!follow)
+        return;
+    while (true) {
+        const latest = getCodeAgentRunRecord(run.id);
+        if (!latest || isTerminalRun(latest)) {
+            printNewEvents();
+            if (latest) {
+                writeLine(output, `\nRun ${latest.status}${latest.phase ? ` (${latest.phase})` : ""}.`);
+            }
+            return;
+        }
+        await delay(1_000);
+        printNewEvents();
+    }
+}
+function renderTranscriptEventForCli(event) {
+    const timestamp = event.createdAt.replace("T", " ").replace(/\.\d+Z$/, "Z");
+    const label = event.kind === "user"
+        ? "user"
+        : event.metadata?.role === "assistant"
+            ? "assistant"
+            : event.kind;
+    const tool = typeof event.metadata?.tool === "string" ? ` ${event.metadata.tool}` : "";
+    return `[${timestamp}] ${label}${tool}: ${event.message}`;
+}
+function isTerminalRun(run) {
+    return (run.status === "completed" ||
+        run.status === "errored" ||
+        run.status === "paused" ||
+        run.phase === "complete" ||
+        run.phase === "error" ||
+        run.phase === "paused" ||
+        run.phase === "missing-credentials" ||
+        run.phase === "stopped");
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function selectCodeAgentRun(runs, args, options) {
+    const explicitRunId = getExplicitRunId(args);
+    if (explicitRunId) {
+        return runs.find((run) => run.id === explicitRunId) ?? null;
+    }
+    return options.defaultToLast ? (runs[0] ?? null) : null;
+}
+function hasExplicitRunId(args) {
+    return Boolean(getExplicitRunId(args));
+}
+function getExplicitRunId(args) {
+    const subcommand = args[0];
+    for (const arg of args.slice(1)) {
+        if (arg === "--last" || arg === "--")
+            continue;
+        if (arg.startsWith("-"))
+            continue;
+        if (arg === subcommand)
+            continue;
+        return arg;
+    }
+    return null;
+}
+function renderCodeAgentRunDetail(heading, run) {
+    const transcriptEvents = listCodeAgentTranscriptEvents(run.id);
+    return [
+        "",
+        heading,
+        "",
+        `  Run:        ${run.id}`,
+        `  Goal:       /${run.goalId}`,
+        `  Title:      ${run.title}`,
+        run.subtitle ? `  Subtitle:   ${run.subtitle}` : "",
+        run.permissionMode
+            ? `  Mode:       ${formatCodeAgentRunMode(run.permissionMode)}`
+            : "",
+        `  Status:     ${run.status}${run.phase ? ` (${run.phase})` : ""}`,
+        run.progress
+            ? `  Progress:   ${run.progress.completed}/${run.progress.total} (${run.progress.percent}%)`
+            : "",
+        run.artifactRoot ? `  Artifacts:  ${run.artifactRoot}` : "",
+        `  Transcript: ${transcriptEvents.length} event${transcriptEvents.length === 1 ? "" : "s"}`,
+        `  Updated:    ${run.updatedAt}`,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function renderCodeAgentRunListItem(run) {
+    const progress = run.progress
+        ? `, ${run.progress.completed}/${run.progress.total}`
+        : "";
+    const permission = run.permissionMode
+        ? `, ${formatCodeAgentRunMode(run.permissionMode)}`
+        : "";
+    return [
+        `  - ${run.id}`,
+        `    /${run.goalId} ${run.status}${run.phase ? ` (${run.phase})` : ""}${progress}${permission}`,
+        `    ${truncateForDisplay(run.title, 100)}`,
+        `    updated ${run.updatedAt}`,
+    ].join("\n");
+}
+function isInteractiveTerminal(input, output) {
+    return Boolean(input.isTTY && output.isTTY);
+}
+function writeLine(output, text = "") {
+    output.write(`${text}\n`);
+}
+function writePrompt(output) {
+    output.write(SHELL_PROMPT);
+}
+async function runCodeGoal(goalId, forwardedArgs, output = process.stdout) {
+    const goal = CODE_AGENT_CLI_GOALS.find((candidate) => candidate.id === goalId);
+    if (!goal) {
+        throw new Error(`Unknown Agent-Native Code goal: ${goalId}`);
+    }
+    switch (goal.backingCommand) {
+        case "task":
+            await runTask(forwardedArgs, output);
+            return;
+        case "audit-agent-web":
+            await runAuditAgentWeb(forwardedArgs);
+            return;
+        case "migrate":
+            await runMigrate(forwardedArgs);
+            return;
+    }
+}
+async function runTask(forwardedArgs, output, options = {}) {
+    const parsed = parseTaskArgs(forwardedArgs, options.permissionMode);
+    if (parsed.error) {
+        writeLine(output, parsed.error);
+        writeLine(output, taskUsage());
+        return;
+    }
+    if (!parsed.prompt) {
+        writeLine(output, taskUsage());
+        return;
+    }
+    const prompt = parsed.prompt;
+    const run = createCodeAgentRunRecord({
+        goalId: "task",
+        title: titleFromPrompt(prompt),
+        subtitle: options.subtitle ?? "Generic coding task",
+        status: "running",
+        phase: "starting",
+        permissionMode: parsed.permissionMode,
+        progress: {
+            label: "Starting",
+            completed: 0,
+            total: 1,
+            percent: 5,
+        },
+        details: [
+            { label: "Prompt", value: truncateForDisplay(prompt, 160) },
+            { label: "Agent", value: "Running locally" },
+            { label: "Mode", value: formatCodeAgentRunMode(parsed.permissionMode) },
+        ],
+        cwd: process.cwd(),
+        metadata: {
+            prompt,
+            source: options.source ?? "agent-native code",
+            commandName: options.commandName,
+            commandPath: options.commandPath,
+            permissionMode: parsed.permissionMode,
+        },
+    });
+    appendCodeAgentTranscriptEvent({
+        runId: run.id,
+        kind: "user",
+        message: prompt,
+        metadata: { source: "initial-prompt" },
+    });
+    appendCodeAgentTranscriptEvent({
+        runId: run.id,
+        kind: "status",
+        message: "Starting local Agent-Native Code execution.",
+        metadata: {
+            status: "running",
+            phase: "starting",
+        },
+    });
+    writeLine(output, renderTaskStarted(run, prompt));
+    await executeCodeAgentRun({
+        runId: run.id,
+        prompt,
+        appendUserEvent: false,
+        stdout: output,
+    });
+}
+async function runProjectSlashCommand(commandName, forwardedArgs, output) {
+    const command = findProjectSlashCommand(commandName);
+    if (!command) {
+        writeLine(output, `Project slash command not found: /${normalizeGoalToken(commandName)}`);
+        return;
+    }
+    const parsed = parseTaskArgs(forwardedArgs);
+    if (parsed.error) {
+        writeLine(output, parsed.error);
+        return;
+    }
+    const prompt = renderProjectSlashCommandPrompt(command, parsed.promptArgs);
+    await runTask([prompt], output, {
+        subtitle: `Project command /${command.name}`,
+        source: "agent-native code project-command",
+        commandName: command.name,
+        commandPath: command.path,
+        permissionMode: parsed.permissionMode,
+    });
+}
+async function recordCodeAgentFollowUpPrompt(prompt, output, permissionMode, runId, followUpMode = "immediate") {
+    const run = runId
+        ? getCodeAgentRunRecord(runId)
+        : getLastCodeAgentRunRecord();
+    if (!run) {
+        writeLine(output, [
+            "",
+            runId
+                ? `Agent-Native Code run not found: ${runId}`
+                : "No Agent-Native Code runs found.",
+            "",
+            'Start one with: agent-native code "what to change"',
+        ].join("\n"));
+        return;
+    }
+    const activeRun = permissionMode
+        ? (updateCodeAgentRunRecord(run.id, { permissionMode }) ?? run)
+        : run;
+    const shouldQueue = isActiveCodeAgentRun(activeRun);
+    const event = appendCodeAgentTranscriptEvent({
+        runId: activeRun.id,
+        kind: "user",
+        message: prompt,
+        metadata: {
+            source: "resume-follow-up",
+            permissionMode,
+            followUpMode,
+            delivery: shouldQueue ? followUpMode : "run-now",
+        },
+    });
+    if (shouldQueue) {
+        queueCodeAgentFollowUp({
+            runId: activeRun.id,
+            prompt,
+            mode: followUpMode,
+            eventId: event.id,
+            permissionMode,
+            source: "resume-follow-up",
+            createdAt: event.createdAt,
+        });
+        writeLine(output, renderFollowUpRecorded(activeRun, event, followUpMode));
+        return;
+    }
+    writeLine(output, renderFollowUpRecorded(activeRun, event, "immediate"));
+    await executeCodeAgentRun({
+        runId: activeRun.id,
+        prompt,
+        appendUserEvent: false,
+        stdout: output,
+    });
+}
+function parseTaskArgs(forwardedArgs, defaultPermissionMode = "full-auto") {
+    const promptArgs = [];
+    let permissionMode = defaultPermissionMode;
+    let permissionModeExplicit = false;
+    for (let index = 0; index < forwardedArgs.length; index += 1) {
+        const arg = forwardedArgs[index];
+        if (arg === "--") {
+            promptArgs.push(...forwardedArgs.slice(index + 1));
+            break;
+        }
+        if (arg === "--permission-mode") {
+            const value = forwardedArgs[index + 1];
+            const normalized = normalizeCodeAgentPermissionMode(value);
+            if (!normalized) {
+                return {
+                    prompt: "",
+                    promptArgs,
+                    permissionMode,
+                    error: `Invalid run mode: ${value ?? "(missing)"}`,
+                };
+            }
+            permissionMode = normalized;
+            permissionModeExplicit = true;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith("--permission-mode=")) {
+            const normalized = normalizeCodeAgentPermissionMode(arg.slice("--permission-mode=".length));
+            if (!normalized) {
+                return {
+                    prompt: "",
+                    promptArgs,
+                    permissionMode,
+                    error: `Invalid run mode: ${arg.slice("--permission-mode=".length)}`,
+                };
+            }
+            permissionMode = normalized;
+            permissionModeExplicit = true;
+            continue;
+        }
+        const shorthand = parsePermissionModeFlag(arg);
+        if (shorthand) {
+            permissionMode = shorthand;
+            permissionModeExplicit = true;
+            continue;
+        }
+        promptArgs.push(arg);
+    }
+    return {
+        prompt: promptArgs.join(" ").trim(),
+        promptArgs,
+        permissionMode,
+        permissionModeExplicit,
+    };
+}
+function parseFollowUpArgs(forwardedArgs) {
+    const promptArgs = [];
+    let followUpMode = "immediate";
+    for (let index = 0; index < forwardedArgs.length; index += 1) {
+        const arg = forwardedArgs[index];
+        if (arg === "--") {
+            promptArgs.push(...forwardedArgs.slice(index));
+            break;
+        }
+        if (arg === "--queue" || arg === "--after-completion") {
+            followUpMode = "queued";
+            continue;
+        }
+        if (arg === "--immediate" || arg === "--steer") {
+            followUpMode = "immediate";
+            continue;
+        }
+        promptArgs.push(arg);
+    }
+    return {
+        ...parseTaskArgs(promptArgs),
+        followUpMode,
+    };
+}
+function parsePermissionModeFlag(arg) {
+    switch (arg) {
+        case "--plan":
+        case "--read-only":
+            return "read-only";
+        case "--auto":
+            return "full-auto";
+        case "--ask-before-edit":
+            return "ask-before-edit";
+        case "--auto-edit":
+            return "auto-edit";
+        case "--full-auto":
+            return "full-auto";
+        default:
+            return null;
+    }
+}
+function titleFromPrompt(prompt) {
+    return truncateForDisplay(prompt.replace(/\s+/g, " "), 80);
+}
+function truncateForDisplay(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function renderTaskStarted(run, prompt) {
+    return [
+        "",
+        "Agent-Native Code session started.",
+        "",
+        `  Run:    ${run.id}`,
+        `  Prompt: ${truncateForDisplay(prompt, 160)}`,
+        `  Mode:   ${formatCodeAgentRunMode(run.permissionMode)}`,
+        "",
+        "Streaming output below. The transcript is saved with this run.",
+    ].join("\n");
+}
+function renderFollowUpRecorded(run, event, mode) {
+    const active = isActiveCodeAgentRun(run);
+    const heading = active
+        ? mode === "queued"
+            ? "Queued follow-up prompt for Agent-Native Code run."
+            : "Recorded steering prompt for active Agent-Native Code run."
+        : "Running follow-up prompt for Agent-Native Code run.";
+    return [
+        "",
+        heading,
+        "",
+        `  Run:   ${run.id}`,
+        `  Goal:  /${run.goalId}`,
+        `  Event: ${event.id}`,
+        "",
+        active
+            ? mode === "queued"
+                ? "It will run after the current execution finishes."
+                : "It will be applied by the active runner as soon as it can steer."
+            : "Streaming output below. The transcript is saved with this run.",
+    ].join("\n");
+}
+function taskUsage() {
+    return [
+        "",
+        "Usage:",
+        '  agent-native code "what to change"',
+        '  agent-native code --plan "explain this repo"',
+        '  agent-native code --auto "fix this and verify it"',
+        `  agent-native code --permission-mode ${CODE_AGENT_PERMISSION_MODES.join("|")} "what to change"`,
+        "",
+        "The task goal starts a local Agent-Native Code session, saves transcript events, and can be resumed with follow-up prompts.",
+    ].join("\n");
+}
+function formatCodeAgentRunMode(permissionMode) {
+    return permissionMode === "read-only" ? "Plan mode" : "Auto mode";
+}
+//# sourceMappingURL=code.js.map