@amistio/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,698 @@
+#!/usr/bin/env node
+import { createHash, randomUUID } from "node:crypto";
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { Command } from "commander";
+import { AMISTIO_API_URL_ENV, isOfficialAmistioApiUrl, officialAmistioApiUrl, parseRepositoryCloneUrl } from "@amistio/shared";
+import { cloneOrValidateRepository } from "./bootstrap.js";
+import { credentialKey, LocalCredentialStore } from "./credential-store.js";
+import { initControlPlane, inspectControlPlane, readProjectLink, writeProjectLink } from "./control-plane.js";
+import { ApiClient } from "./api-client.js";
+import { createOrchestrationPrompt, writePromptFile } from "./orchestrator.js";
+import { createToolRunPreview, detectLocalTools, runLocalTool } from "./local-tool-runner.js";
+import { normalizeSessionPolicy, selectToolSession } from "./session-policy.js";
+import { collectDirtyDocumentsForPush, collectSyncStatus, materializeBrainDocuments } from "./sync.js";
+import { LocalToolSessionStore } from "./tool-session-store.js";
+import { createWorkExecutionPrompt, parseBrainGenerationArtifacts } from "./work-runner.js";
+const program = new Command();
+const defaultRoot = process.env.INIT_CWD ?? process.cwd();
+const apiUrlOptionDescription = `Amistio API URL override (or ${AMISTIO_API_URL_ENV})`;
+program.name("amistio").description("Amistio project brain CLI").version("0.1.0");
+const CLI_VERSION = "0.1.0";
+program
+    .command("init")
+    .description("Create Amistio control-plane folders for a new project")
+    .option("--root <path>", "Repository root", defaultRoot)
+    .action(async (options) => {
+    const created = await initControlPlane(options.root);
+    console.log(created.length ? `Created ${created.length} control-plane folders.` : "Control-plane folders already exist.");
+});
+program
+    .command("onboard")
+    .description("Inspect and prepare an existing repository for Amistio")
+    .option("--root <path>", "Repository root", defaultRoot)
+    .action(async (options) => {
+    const result = await inspectControlPlane(options.root);
+    console.log(`Present: ${result.present.length ? result.present.join(", ") : "none"}`);
+    console.log(`Missing: ${result.missing.length ? result.missing.join(", ") : "none"}`);
+    if (result.missing.length) {
+        console.log("Run `amistio init` to create missing control-plane folders without overwriting existing files.");
+    }
+});
+program
+    .command("bootstrap")
+    .description("Clone a linked repository locally, prepare the control plane, and pair it with Amistio")
+    .requiredOption("--repo-url <url>", "Linked repository clone URL")
+    .requiredOption("--target <path>", "Local checkout target path")
+    .requiredOption("--account <accountId>", "Amistio account ID")
+    .requiredOption("--project <projectId>", "Amistio project ID")
+    .requiredOption("--repository-link <repositoryLinkId>", "Existing repository link ID")
+    .option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl())
+    .requiredOption("--pairing-code <code>", "Short-lived pairing code from the Amistio app")
+    .option("--default-branch <branch>", "Default branch", "main")
+    .action(async (options) => {
+    const parsedRepoUrl = parseRepositoryCloneUrl(options.repoUrl);
+    const checkout = await cloneOrValidateRepository({ repoUrl: parsedRepoUrl.cloneUrl, targetDir: options.target });
+    await initControlPlane(checkout.targetDir);
+    const pairing = await new ApiClient({
+        apiUrl: options.apiUrl,
+        accountId: options.account
+    }).consumePairingSession({
+        projectId: options.project,
+        pairingCode: options.pairingCode,
+        repositoryLinkId: options.repositoryLink,
+        repoName: parsedRepoUrl.repoName,
+        repoFingerprint: createRepoFingerprint(options.account, options.project, options.repositoryLink),
+        defaultBranch: options.defaultBranch
+    });
+    const filePath = await writeProjectLink(checkout.targetDir, {
+        amistioAccountId: options.account,
+        amistioProjectId: options.project,
+        repositoryLinkId: pairing.repositoryLink.repositoryLinkId,
+        defaultBranch: options.defaultBranch,
+        lastSyncedRevision: 0
+    });
+    await new LocalCredentialStore().set(credentialKey(options.account, options.project, pairing.repositoryLink.repositoryLinkId), pairing.token);
+    console.log(checkout.status === "cloned" ? `Cloned repository to ${checkout.targetDir}.` : `Validated existing checkout at ${checkout.targetDir}.`);
+    console.log(`Pairing confirmed for ${pairing.repositoryLink.repoName}.`);
+    console.log(`Wrote non-secret project metadata to ${filePath}.`);
+    console.log(`Next: cd ${formatShellArg(checkout.targetDir)} && amistio run${formatApiUrlFlag(options.apiUrl)} --watch`);
+});
+program
+    .command("pair")
+    .description("Pair this repository with an Amistio web project")
+    .requiredOption("--account <accountId>", "Amistio account ID")
+    .requiredOption("--project <projectId>", "Amistio project ID")
+    .option("--repository-link <repositoryLinkId>", "Existing repository link ID")
+    .option("--default-branch <branch>", "Default branch", "main")
+    .option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl())
+    .option("--pairing-code <code>", "Short-lived pairing code from the Amistio app")
+    .option("--token <token>", "Runner/device credential to store outside the repository")
+    .option("--root <path>", "Repository root", defaultRoot)
+    .action(async (options, command) => {
+    let repositoryLinkId = options.repositoryLink ?? `repo_${randomUUID()}`;
+    let credential = options.token;
+    if (options.pairingCode) {
+        const pairing = await new ApiClient({
+            apiUrl: options.apiUrl,
+            accountId: options.account,
+            ...(credential ? { token: credential } : {})
+        }).consumePairingSession({
+            projectId: options.project,
+            pairingCode: options.pairingCode,
+            repositoryLinkId,
+            repoName: inferRepoName(options.root),
+            repoFingerprint: createRepoFingerprint(options.account, options.project, repositoryLinkId),
+            defaultBranch: options.defaultBranch
+        });
+        repositoryLinkId = pairing.repositoryLink.repositoryLinkId;
+        credential = credential ?? pairing.token;
+        console.log(`Pairing confirmed for ${pairing.repositoryLink.repoName}.`);
+    }
+    const filePath = await writeProjectLink(options.root, {
+        amistioAccountId: options.account,
+        amistioProjectId: options.project,
+        repositoryLinkId,
+        defaultBranch: options.defaultBranch,
+        lastSyncedRevision: 0
+    });
+    if (credential) {
+        await new LocalCredentialStore().set(credentialKey(options.account, options.project, repositoryLinkId), credential);
+    }
+    if (!options.pairingCode && apiUrlOverrideWasRequested(command)) {
+        const session = await new ApiClient({
+            apiUrl: options.apiUrl,
+            accountId: options.account,
+            ...(credential ? { token: credential } : {})
+        }).createPairingSession(options.project);
+        console.log(`Pairing code: ${session.pairingCode}`);
+        console.log(`Expires at: ${session.expiresAt}`);
+    }
+    console.log(`Wrote non-secret project metadata to ${filePath}.`);
+});
+const sync = program.command("sync").description("Inspect or move project brain changes between the repo and Amistio");
+sync
+    .command("status")
+    .description("Show local sync status")
+    .option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl())
+    .option("--root <path>", "Repository root", defaultRoot)
+    .action(async (options) => {
+    const metadata = await readProjectLink(options.root);
+    if (!metadata) {
+        console.log("Repository is not paired. Run `amistio pair` first.");
+        return;
+    }
+    const context = await loadPairedApiContext(options.root, options.apiUrl);
+    const webDocuments = context ? await context.client.listBrainDocuments(metadata.amistioProjectId).then((result) => result.documents).catch(() => []) : [];
+    const report = await collectSyncStatus(options.root, webDocuments);
+    console.log(`Paired project: ${metadata.amistioProjectId}`);
+    console.log(`Repository link: ${metadata.repositoryLinkId}`);
+    console.log(`Last synced revision: ${metadata.lastSyncedRevision}`);
+    console.log(`Sync status: ${report.status}`);
+    console.log(`Clean: ${report.counts.clean}; Pending: ${report.counts.pending}; Dirty: ${report.counts.dirty}; Conflicted: ${report.counts.conflicted}`);
+    for (const item of report.items.filter((entry) => entry.status !== "clean")) {
+        console.log(`${item.status}: ${item.repoPath} - ${item.reason}`);
+    }
+});
+sync
+    .command("pull")
+    .description("Pull approved web changes into the repository")
+    .option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl())
+    .option("--root <path>", "Repository root", defaultRoot)
+    .action(async (options) => {
+    const context = await loadPairedApiContext(options.root, options.apiUrl);
+    if (!context) {
+        console.log("Repository is not paired. Run `amistio pair` first.");
+        return;
+    }
+    const { documents } = await context.client.listBrainDocuments(context.metadata.amistioProjectId);
+    const approvedDocuments = documents.filter((document) => document.syncState === "approved" || document.syncState === "synced");
+    const result = await materializeBrainDocuments(options.root, approvedDocuments);
+    for (const conflict of result.conflicts) {
+        console.log(`conflicted: ${conflict}`);
+    }
+    if (result.conflicts.length) {
+        process.exitCode = 1;
+        return;
+    }
+    const latestRevision = Math.max(context.metadata.lastSyncedRevision, ...approvedDocuments.map((document) => document.revision));
+    if (latestRevision !== context.metadata.lastSyncedRevision) {
+        await writeProjectLink(options.root, { ...context.metadata, lastSyncedRevision: latestRevision });
+    }
+    console.log(result.written.length ? `Pulled ${result.written.length} approved document${result.written.length === 1 ? "" : "s"}.` : "No approved web changes were pulled.");
+});
+sync
+    .command("push")
+    .description("Push local brain changes to Amistio for review")
+    .option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl())
+    .option("--root <path>", "Repository root", defaultRoot)
+    .action(async (options) => {
+    const context = await loadPairedApiContext(options.root, options.apiUrl);
+    if (!context) {
+        console.log("Repository is not paired. Run `amistio pair` first.");
+        return;
+    }
+    const dirtyDocuments = await collectDirtyDocumentsForPush(options.root, context.metadata);
+    if (!dirtyDocuments.length) {
+        console.log("No local brain changes were pushed.");
+        return;
+    }
+    const { documents } = await context.client.pushBrainDocuments(context.metadata.amistioProjectId, dirtyDocuments);
+    const conflictedDocuments = documents.filter((document) => document.syncState === "conflicted" || document.status === "conflicted");
+    if (conflictedDocuments.length) {
+        for (const document of conflictedDocuments) {
+            console.log(`conflicted: ${document.repoPath} - web and repository revisions both changed`);
+        }
+        process.exitCode = 1;
+        return;
+    }
+    await materializeBrainDocuments(options.root, documents, { allowDirtyOverwrite: true });
+    console.log(`Pushed ${documents.length} local document${documents.length === 1 ? "" : "s"} for web review.`);
+});
+const work = program.command("work").description("Inspect approved work items");
+work
+    .command("list")
+    .description("List queued work without claiming it")
+    .option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl())
+    .option("--root <path>", "Repository root", defaultRoot)
+    .action(async (options) => {
+    const context = await loadPairedApiContext(options.root, options.apiUrl);
+    if (!context) {
+        console.log("Repository is not paired. Run `amistio pair` first.");
+        return;
+    }
+    const { workItems } = await context.client.listWorkItems(context.metadata.amistioProjectId);
+    if (!workItems.length) {
+        console.log("No work items are queued for this project.");
+        return;
+    }
+    for (const item of workItems) {
+        console.log(`${item.workItemId} [${item.status}] ${item.title}`);
+    }
+});
+work
+    .command("prompt")
+    .description("Print or write an approved work prompt without claiming a runner lease")
+    .argument("[workItemId]", "Work item ID. Defaults to the newest approved work item.")
+    .option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl())
+    .option("--root <path>", "Repository root", defaultRoot)
+    .option("--out <path>", "Write the prompt to a file instead of stdout")
+    .action(async (workItemId, options) => {
+    const context = await loadPairedApiContext(options.root, options.apiUrl);
+    if (!context) {
+        console.log("Repository is not paired. Run `amistio pair` first.");
+        return;
+    }
+    const { workItems } = await context.client.listWorkItems(context.metadata.amistioProjectId);
+    const workItem = selectPromptWorkItem(workItems, workItemId);
+    if (!workItem) {
+        console.log(workItemId ? `No work item found for ${workItemId}.` : "No approved work item is ready for prompt export.");
+        return;
+    }
+    const prompt = createWorkExecutionPrompt(workItem);
+    if (options.out) {
+        await writeFile(options.out, prompt, "utf8");
+        console.log(`Wrote work prompt to ${options.out}.`);
+    }
+    else {
+        console.log(prompt);
+    }
+});
+program
+    .command("tools")
+    .description("List local AI coding tools that the Amistio CLI can use")
+    .action(async () => {
+    const tools = await detectLocalTools();
+    for (const tool of tools) {
+        const mode = tool.execution === "sdk" ? "sdk" : tool.execution === "command" ? "cli" : "--";
+        console.log(`${tool.available ? "yes" : "no "} ${mode} ${tool.name} - ${tool.description}`);
+    }
+    console.log("custom - pass --tool-command to use any other local runner command.");
+});
+program
+    .command("orchestrate")
+    .description("Update the Amistio control plane through a user-installed local AI tool")
+    .argument("[goal...]", "Goal or next-step instruction for the orchestration pass")
+    .option("--root <path>", "Repository root", defaultRoot)
+    .option("--tool <name>", "Local tool to use: auto, none, opencode, claude, codex, copilot, gemini, aider, cursor-agent", "auto")
+    .option("--tool-command <command>", "Custom local command. Use {promptFile} and {root} placeholders when supported")
+    .option("--session <policy>", "Tool session policy: auto, new, continue:<toolSessionId>, or none", "auto")
+    .option("--prompt-out <path>", "Write the generated orchestration prompt to a file before running")
+    .option("--dry-run", "Print the generated orchestration prompt without running a tool")
+    .option("--no-stream", "Capture local tool output instead of streaming it")
+    .action(async (goalParts, options) => {
+    const goal = goalParts?.join(" ").trim() || "Review the current repository state and update the Amistio control plane with the next useful orchestration steps.";
+    const prompt = await createOrchestrationPrompt({ rootDir: options.root, goal });
+    if (options.promptOut) {
+        const promptPath = await writePromptFile(options.promptOut, prompt);
+        console.log(`Wrote orchestration prompt to ${promptPath}.`);
+    }
+    if (options.dryRun || options.tool === "none") {
+        console.log(prompt);
+        return;
+    }
+    const sessionPolicy = normalizeSessionPolicy(options.session);
+    const preview = await createToolRunPreview({ rootDir: options.root, prompt, tool: options.tool, ...(options.toolCommand ? { toolCommand: options.toolCommand } : {}) });
+    console.log(`Running ${preview.toolName}: ${preview.displayCommand}`);
+    const result = await runLocalTool({
+        rootDir: options.root,
+        prompt,
+        tool: options.tool,
+        ...(options.toolCommand ? { toolCommand: options.toolCommand } : {}),
+        streamOutput: options.stream,
+        ...(sessionPolicy === "none" ? {} : { session: { toolSessionId: `local_orchestration_${randomUUID()}`, policy: sessionPolicy, decision: localSessionDecision(sessionPolicy) } })
+    });
+    if (!options.stream && result.stdout.trim()) {
+        console.log(result.stdout.trim());
+    }
+    if (!options.stream && result.stderr.trim()) {
+        console.error(result.stderr.trim());
+    }
+    if (result.exitCode !== 0) {
+        process.exitCode = result.exitCode;
+    }
+});
+program
+    .command("run")
+    .description("Claim and run approved Amistio work locally")
+    .option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl())
+    .option("--runner-id <runnerId>", "Stable runner ID", `runner_${randomUUID()}`)
+    .option("--root <path>", "Repository root", defaultRoot)
+    .option("--tool <name>", "Local tool to use: auto, none, opencode, claude, codex, copilot, gemini, aider, cursor-agent", "auto")
+    .option("--tool-command <command>", "Custom local command. Use {promptFile} and {root} placeholders when supported")
+    .option("--session <policy>", "Tool session policy: auto, new, continue:<toolSessionId>, or none", "auto")
+    .option("--dry-run", "Claim work and print the generated execution prompt without running a tool")
+    .option("--watch", "Keep polling for approved work until stopped")
+    .option("--interval-seconds <seconds>", "Polling interval for --watch", parsePositiveInteger, 10)
+    .option("--max-iterations <count>", "Stop watch mode after this many polling attempts", parsePositiveInteger)
+    .option("--no-stream", "Capture local tool output instead of streaming it")
+    .action(async (options) => {
+    const context = await loadPairedApiContext(options.root, options.apiUrl);
+    if (!context) {
+        console.log("Repository is not paired. Run `amistio pair` first.");
+        return;
+    }
+    if (!context.token) {
+        console.log("No local runner credential found. Run `amistio pair --pairing-code <code>` to store this machine credential.");
+        process.exitCode = 1;
+        return;
+    }
+    if (options.watch) {
+        console.log(`Runner ${options.runnerId} is watching ${context.metadata.amistioProjectId} every ${options.intervalSeconds}s. Press Ctrl+C to stop.`);
+    }
+    let iterations = 0;
+    while (true) {
+        iterations += 1;
+        const result = await runNextWorkItem({
+            apiClient: context.client,
+            projectId: context.metadata.amistioProjectId,
+            repositoryLinkId: context.metadata.repositoryLinkId,
+            runnerId: options.runnerId,
+            root: options.root,
+            sessionPolicy: normalizeSessionPolicy(options.session),
+            tool: options.tool,
+            ...(options.toolCommand ? { toolCommand: options.toolCommand } : {}),
+            dryRun: Boolean(options.dryRun),
+            stream: options.stream
+        });
+        if (!options.watch || options.dryRun) {
+            if (result.exitCode !== 0) {
+                process.exitCode = result.exitCode;
+            }
+            return;
+        }
+        if (options.maxIterations !== undefined && iterations >= options.maxIterations) {
+            console.log(`Runner stopped after ${iterations} polling attempt${iterations === 1 ? "" : "s"}.`);
+            return;
+        }
+        if (result.status === "idle") {
+            console.log(`No approved work item is available. Checking again in ${options.intervalSeconds}s.`);
+        }
+        await delay(options.intervalSeconds * 1000);
+    }
+});
+async function runNextWorkItem({ apiClient, dryRun, projectId, repositoryLinkId, root, runnerId, sessionPolicy, stream, tool, toolCommand }) {
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", CLI_VERSION);
+    const result = await apiClient.claimWork(projectId, runnerId, repositoryLinkId);
+    if (!result.workItem) {
+        console.log("No approved work item is available.");
+        return { status: "idle", exitCode: 0 };
+    }
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "running", CLI_VERSION);
+    const prompt = createWorkExecutionPrompt(result.workItem);
+    if (dryRun || tool === "none") {
+        console.log(prompt);
+        await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", CLI_VERSION);
+        return { status: "preview", exitCode: 0 };
+    }
+    const preview = await createToolRunPreview({ rootDir: root, prompt, tool, ...(toolCommand ? { toolCommand } : {}) });
+    const sessionContext = await prepareToolSession({
+        apiClient,
+        projectId,
+        repositoryLinkId,
+        runnerId,
+        sessionPolicy: result.workItem.sessionPolicy ?? sessionPolicy,
+        toolName: preview.toolName,
+        supportsSessionReuse: preview.supportsSessionReuse,
+        resumabilityScope: preview.resumabilityScope,
+        workItem: result.workItem
+    });
+    console.log(`Claimed ${result.workItem.workItemId}. Running ${preview.toolName}: ${preview.displayCommand}`);
+    const startedAt = Date.now();
+    const providerSessionStore = new LocalToolSessionStore();
+    const providerSessionId = sessionContext.toolSession
+        ? await providerSessionStore.getProviderSessionId(sessionContext.toolSession.toolSessionId, preview.toolName)
+        : undefined;
+    const toolResult = await runLocalTool({
+        rootDir: root,
+        prompt,
+        tool,
+        ...(toolCommand ? { toolCommand } : {}),
+        streamOutput: stream,
+        ...(sessionContext.toolSession
+            ? {
+                session: {
+                    toolSessionId: sessionContext.toolSession.toolSessionId,
+                    policy: sessionContext.policy,
+                    decision: sessionContext.decision,
+                    ...(providerSessionId ? { providerSessionId } : {})
+                }
+            }
+            : {})
+    }).catch(async (error) => {
+        await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "blocked", CLI_VERSION);
+        await markToolSessionBlocked(apiClient, projectId, sessionContext.toolSession, errorMessage(error));
+        throw error;
+    });
+    if (sessionContext.toolSession && toolResult.providerSessionId) {
+        await providerSessionStore.setProviderSessionId(sessionContext.toolSession.toolSessionId, preview.toolName, toolResult.providerSessionId);
+    }
+    if (!stream && toolResult.stdout.trim()) {
+        console.log(toolResult.stdout.trim());
+    }
+    if (!stream && toolResult.stderr.trim()) {
+        console.error(toolResult.stderr.trim());
+    }
+    if (result.workItem.workKind === "brainGeneration") {
+        return finalizeBrainGenerationWork({
+            apiClient,
+            durationMs: Date.now() - startedAt,
+            projectId,
+            repositoryLinkId,
+            runnerId,
+            sessionContext,
+            toolName: preview.toolName,
+            toolResult,
+            workItem: result.workItem
+        });
+    }
+    const finalStatus = toolResult.exitCode === 0 ? "completed" : "failed";
+    const durationMs = Date.now() - startedAt;
+    const failureExcerpt = toolResult.exitCode === 0 ? undefined : truncateLogExcerpt(toolResult.stderr || toolResult.stdout);
+    const updatedToolSession = await finalizeToolSession({
+        apiClient,
+        projectId,
+        status: finalStatus,
+        runnerId,
+        workItemId: result.workItem.workItemId,
+        stdout: toolResult.stdout,
+        ...(sessionContext.toolSession ? { session: sessionContext.toolSession } : {}),
+        ...(toolResult.messageCount !== undefined ? { messageCount: toolResult.messageCount } : {}),
+        ...(toolResult.tokensIn !== undefined ? { tokensIn: toolResult.tokensIn } : {}),
+        ...(toolResult.tokensOut !== undefined ? { tokensOut: toolResult.tokensOut } : {}),
+        ...(toolResult.costUsd !== undefined ? { costUsd: toolResult.costUsd } : {})
+    });
+    const statusResult = await apiClient.updateWorkStatus(projectId, result.workItem.workItemId, finalStatus, `run_${result.workItem.workItemId}_${randomUUID()}`, runnerId, {
+        tool: preview.toolName,
+        durationMs,
+        message: `${preview.toolName} exited with code ${toolResult.exitCode}.`,
+        sessionPolicy: sessionContext.policy,
+        sessionDecision: sessionContext.decision,
+        sessionDecisionReason: sessionContext.reason,
+        ...(updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {}),
+        ...(updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {}),
+        ...(toolResult.tokensIn !== undefined ? { tokensIn: toolResult.tokensIn } : {}),
+        ...(toolResult.tokensOut !== undefined ? { tokensOut: toolResult.tokensOut } : {}),
+        ...(toolResult.costUsd !== undefined ? { costUsd: toolResult.costUsd } : {}),
+        ...(failureExcerpt ? { error: failureExcerpt } : {})
+    });
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", CLI_VERSION);
+    const durationSeconds = Math.round(durationMs / 1000);
+    console.log(`Marked ${statusResult.workItem.workItemId} ${statusResult.workItem.status} after ${durationSeconds}s.`);
+    return { status: finalStatus, exitCode: toolResult.exitCode };
+}
+async function finalizeBrainGenerationWork({ apiClient, durationMs, projectId, repositoryLinkId, runnerId, sessionContext, toolName, toolResult, workItem }) {
+    let artifacts;
+    let generationError;
+    if (toolResult.exitCode === 0) {
+        try {
+            artifacts = parseBrainGenerationArtifacts(`${toolResult.stdout}\n${toolResult.stderr}`);
+        }
+        catch (error) {
+            generationError = errorMessage(error);
+        }
+    }
+    else {
+        generationError = truncateLogExcerpt(toolResult.stderr || toolResult.stdout) || `${toolName} exited with code ${toolResult.exitCode}.`;
+    }
+    const finalStatus = artifacts ? "completed" : "failed";
+    const updatedToolSession = await finalizeToolSession({
+        apiClient,
+        projectId,
+        status: finalStatus,
+        runnerId,
+        workItemId: workItem.workItemId,
+        stdout: toolResult.stdout,
+        ...(sessionContext.toolSession ? { session: sessionContext.toolSession } : {}),
+        ...(toolResult.messageCount !== undefined ? { messageCount: toolResult.messageCount } : {}),
+        ...(toolResult.tokensIn !== undefined ? { tokensIn: toolResult.tokensIn } : {}),
+        ...(toolResult.tokensOut !== undefined ? { tokensOut: toolResult.tokensOut } : {}),
+        ...(toolResult.costUsd !== undefined ? { costUsd: toolResult.costUsd } : {})
+    });
+    const sessionTelemetry = {
+        sessionPolicy: sessionContext.policy,
+        sessionDecision: sessionContext.decision,
+        sessionDecisionReason: sessionContext.reason,
+        ...(updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {}),
+        ...(updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {})
+    };
+    if (artifacts) {
+        const result = await apiClient.submitBrainGenerationResult(projectId, workItem.workItemId, {
+            status: "completed",
+            runnerId,
+            idempotencyKey: `generation_${workItem.workItemId}_${randomUUID()}`,
+            artifacts,
+            tool: toolName,
+            durationMs,
+            ...sessionTelemetry,
+            message: `${toolName} generated ${artifacts.length} brain artifact${artifacts.length === 1 ? "" : "s"}.`
+        });
+        await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", CLI_VERSION);
+        console.log(`Generated ${result.documents.length} brain artifact${result.documents.length === 1 ? "" : "s"} for review.`);
+        return { status: "completed", exitCode: 0 };
+    }
+    await apiClient.submitBrainGenerationResult(projectId, workItem.workItemId, {
+        status: "failed",
+        runnerId,
+        idempotencyKey: `generation_${workItem.workItemId}_${randomUUID()}`,
+        tool: toolName,
+        durationMs,
+        ...sessionTelemetry,
+        message: `${toolName} did not produce valid brain artifacts.`,
+        ...(generationError ? { error: generationError } : {})
+    });
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", CLI_VERSION);
+    console.error(generationError ?? "Local runner generation failed.");
+    return { status: "failed", exitCode: toolResult.exitCode || 1 };
+}
+async function loadPairedApiContext(root, apiUrl) {
+    const metadata = await readProjectLink(root);
+    if (!metadata) {
+        return undefined;
+    }
+    const token = await new LocalCredentialStore().get(credentialKey(metadata.amistioAccountId, metadata.amistioProjectId, metadata.repositoryLinkId));
+    return {
+        metadata,
+        ...(token ? { token } : {}),
+        client: new ApiClient({
+            apiUrl,
+            accountId: metadata.amistioAccountId,
+            ...(token ? { token } : {})
+        })
+    };
+}
+function selectPromptWorkItem(workItems, workItemId) {
+    if (workItemId) {
+        return workItems.find((item) => item.workItemId === workItemId || item.id === workItemId);
+    }
+    return workItems.find((item) => isPromptReadyStatus(item.status));
+}
+function isPromptReadyStatus(status) {
+    return status === "approved" || status === "running" || status === "blocked" || status === "changesRequested";
+}
+async function prepareToolSession({ apiClient, projectId, repositoryLinkId, runnerId, sessionPolicy, supportsSessionReuse, resumabilityScope, toolName, workItem }) {
+    const { toolSessions } = await apiClient.listToolSessions(projectId);
+    const selection = selectToolSession({
+        policy: sessionPolicy,
+        workItem,
+        sessions: toolSessions,
+        toolName,
+        runnerId,
+        repositoryLinkId,
+        supportsSessionReuse
+    });
+    if (selection.decision === "skipped") {
+        return selection;
+    }
+    if (selection.toolSession) {
+        const { toolSession } = await apiClient.updateToolSession(projectId, selection.toolSession.toolSessionId, {
+            status: "active",
+            runnerId,
+            lastWorkItemId: workItem.workItemId,
+            reusePolicy: sessionPolicy
+        });
+        return { ...selection, toolSession };
+    }
+    const toolSessionId = `tool_session_${randomUUID()}`;
+    const { toolSession } = await apiClient.createToolSession(projectId, {
+        toolSessionId,
+        repositoryLinkId,
+        tool: toolName,
+        provider: toolName,
+        resumabilityScope: supportsSessionReuse ? resumabilityScope : "none",
+        title: workItem.title,
+        summary: selection.reason,
+        status: "active",
+        runnerId,
+        lastWorkItemId: workItem.workItemId,
+        messageCount: 0,
+        reusePolicy: sessionPolicy,
+        ...(workItem.sessionGroupKey ? { sessionGroupKey: workItem.sessionGroupKey } : {})
+    });
+    return { ...selection, toolSession };
+}
+async function finalizeToolSession({ apiClient, costUsd, messageCount, projectId, runnerId, session, status, stdout, tokensIn, tokensOut, workItemId }) {
+    if (!session) {
+        return undefined;
+    }
+    const summary = summarizeToolOutput(stdout) ?? session.summary;
+    const { toolSession } = await apiClient.updateToolSession(projectId, session.toolSessionId, {
+        status: status === "completed" ? "open" : "blocked",
+        runnerId,
+        lastWorkItemId: workItemId,
+        messageCount: (session.messageCount ?? 0) + (messageCount ?? 1),
+        ...(summary ? { summary } : {}),
+        ...(tokensIn !== undefined ? { estimatedInputTokens: (session.estimatedInputTokens ?? 0) + tokensIn } : {}),
+        ...(tokensOut !== undefined ? { estimatedOutputTokens: (session.estimatedOutputTokens ?? 0) + tokensOut } : {}),
+        ...(costUsd !== undefined ? { costUsd: (session.costUsd ?? 0) + costUsd } : {}),
+        ...(status === "failed" ? { closedReason: "Last run failed or returned a non-zero exit code." } : {})
+    });
+    return toolSession;
+}
+async function markToolSessionBlocked(apiClient, projectId, session, reason) {
+    if (!session) {
+        return;
+    }
+    await apiClient.updateToolSession(projectId, session.toolSessionId, {
+        status: "blocked",
+        summary: reason,
+        closedReason: reason
+    });
+}
+function localSessionDecision(policy) {
+    if (policy === "new") {
+        return "forcedNew";
+    }
+    if (typeof policy === "string" && policy.startsWith("continue:")) {
+        return "forcedContinue";
+    }
+    return "created";
+}
+function summarizeToolOutput(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.length > 300 ? `${trimmed.slice(0, 300)}...` : trimmed;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function truncateLogExcerpt(value) {
+    const trimmed = value.trim();
+    return trimmed.length > 1200 ? `${trimmed.slice(0, 1200)}...` : trimmed;
+}
+function parsePositiveInteger(value) {
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`Expected a positive integer, received ${value}.`);
+    }
+    return parsed;
+}
+function inferRepoName(root) {
+    return path.basename(path.resolve(root)) || "repository";
+}
+function createRepoFingerprint(accountId, projectId, repositoryLinkId) {
+    return createHash("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");
+}
+function defaultApiUrl() {
+    const envApiUrl = process.env[AMISTIO_API_URL_ENV]?.trim();
+    return envApiUrl || officialAmistioApiUrl;
+}
+function apiUrlOverrideWasRequested(command) {
+    return command.getOptionValueSource("apiUrl") === "cli" || Boolean(process.env[AMISTIO_API_URL_ENV]?.trim());
+}
+function formatApiUrlFlag(apiUrl) {
+    return isOfficialAmistioApiUrl(apiUrl) ? "" : ` --api-url ${formatShellArg(apiUrl)}`;
+}
+function formatShellArg(value) {
+    return /^[A-Za-z0-9_./:@-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
+}
+async function delay(milliseconds) {
+    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+program.parseAsync().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map