@amistio/cli 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,698 +1,3549 @@
 #!/usr/bin/env node
-import { createHash, randomUUID } from "node:crypto";
-import { writeFile } from "node:fs/promises";
-import path from "node:path";
+
+// src/index.ts
+import { spawn as spawn3 } from "node:child_process";
+import { createHash as createHash3, randomUUID } from "node:crypto";
+import { writeFile as writeFile8 } from "node:fs/promises";
+import os5 from "node:os";
+import path9 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
+
+// ../shared/src/schemas.ts
+import { z } from "zod";
+var isoDateTimeSchema = z.string().datetime({ offset: true });
+var itemTypeSchema = z.enum([
+  "account",
+  "accountUser",
+  "accountInvite",
+  "accountSettings",
+  "user",
+  "project",
+  "repositoryLink",
+  "brainDocument",
+  "generatedDraft",
+  "syncCursor",
+  "syncConflict",
+  "workItem",
+  "runnerHeartbeat",
+  "runnerExecutionLog",
+  "runnerCredential",
+  "runnerCommand",
+  "planReviewMessage",
+  "toolSession",
+  "activityEvent",
+  "pairingSession"
+]);
+var documentTypeSchema = z.enum([
+  "architecture",
+  "context",
+  "decision",
+  "feature",
+  "memory",
+  "plan",
+  "prompt",
+  "workflow"
+]);
+var syncStateSchema = z.enum([
+  "draft",
+  "approved",
+  "synced",
+  "dirtyInRepo",
+  "dirtyInWeb",
+  "conflicted",
+  "archived"
+]);
+var workStatusSchema = z.enum([
+  "drafted",
+  "approved",
+  "synced",
+  "running",
+  "blocked",
+  "completed",
+  "changesRequested",
+  "failed",
+  "conflicted"
+]);
+var sourceSchema = z.enum(["web", "repo", "generated", "runner"]);
+var executionModeSchema = z.enum(["localRunner", "cloudSandbox"]);
+var workKindSchema = z.enum(["brainGeneration", "implementation", "planRevision"]);
+var generatedDraftStatusSchema = z.enum(["queued", "generating", "reviewing", "approved", "rejected", "changesRequested", "failed"]);
+var generatedBrainArtifactSchema = z.object({
+  documentType: documentTypeSchema,
+  title: z.string().trim().min(1),
+  repoPath: z.string().trim().min(1),
+  content: z.string().min(1)
+});
+var brainGenerationResultSchema = z.object({
+  artifacts: z.array(generatedBrainArtifactSchema).min(1),
+  summary: z.string().optional()
+});
+var sessionPolicySchema = z.union([z.enum(["auto", "new", "none"]), z.string().regex(/^continue:[A-Za-z0-9_.:-]+$/)]);
+var sessionDecisionSchema = z.enum(["created", "continued", "forcedNew", "forcedContinue", "notSupported", "skipped"]);
+var toolSessionStatusSchema = z.enum(["open", "active", "closed", "archived", "blocked", "unavailable"]);
+var sessionResumabilityScopeSchema = z.enum(["none", "localMachine", "repository", "account", "providerCloud"]);
+var runnerToolNames = ["opencode", "claude", "codex", "copilot", "gemini", "aider", "cursor-agent"];
+var runnerToolNameSchema = z.enum(runnerToolNames);
+var runnerToolSelectionSchema = z.union([runnerToolNameSchema, z.literal("auto")]);
+var runnerPreferenceScopeSchema = z.enum(["account", "project"]);
+var runnerPreferenceSourceSchema = z.enum(["cli", "project", "account", "default"]);
+var runnerPreferenceStatusSchema = z.enum(["resolved", "unavailable", "modelUnsupported", "custom", "none"]);
+var runnerToolModelPreferenceSchema = z.object({
+  tool: runnerToolSelectionSchema.optional(),
+  model: z.string().trim().min(1).max(160).optional()
+});
+var runnerToolCapabilitySchema = z.object({
+  name: runnerToolNameSchema,
+  description: z.string().min(1),
+  available: z.boolean(),
+  sdkAvailable: z.boolean(),
+  commandAvailable: z.boolean(),
+  execution: z.enum(["sdk", "command", "unavailable"]),
+  supportsSessionReuse: z.boolean(),
+  resumabilityScope: sessionResumabilityScopeSchema,
+  supportsModelSelection: z.boolean()
+});
+var repositoryLinkSourceSchema = z.enum(["web", "cli"]);
+var repositoryCloneStatusSchema = z.enum(["notCloned", "cloned", "validated", "failed"]);
+var baseItemSchema = z.object({
+  id: z.string().min(1),
+  type: itemTypeSchema,
+  schemaVersion: z.number().int().positive().default(1),
+  accountId: z.string().min(1),
+  projectId: z.string().min(1).optional(),
+  createdAt: isoDateTimeSchema,
+  updatedAt: isoDateTimeSchema
+});
+var accountItemSchema = baseItemSchema.extend({
+  type: z.literal("account"),
+  name: z.string().min(1),
+  slug: z.string().min(1)
+});
+var userItemSchema = baseItemSchema.extend({
+  type: z.literal("user"),
+  userId: z.string().min(1),
+  email: z.string().email(),
+  firstName: z.string(),
+  lastName: z.string()
+});
+var projectItemSchema = baseItemSchema.extend({
+  type: z.literal("project"),
+  projectId: z.string().min(1),
+  name: z.string().min(1),
+  slug: z.string().min(1),
+  description: z.string().optional()
+});
+var repositoryLinkItemSchema = baseItemSchema.extend({
+  type: z.literal("repositoryLink"),
+  projectId: z.string().min(1),
+  repositoryLinkId: z.string().min(1),
+  repoName: z.string().min(1),
+  repoFingerprint: z.string().min(1).optional(),
+  defaultBranch: z.string().min(1),
+  cloneUrl: z.string().min(1).optional(),
+  provider: z.string().min(1).optional(),
+  repoOwner: z.string().min(1).optional(),
+  repoFullName: z.string().min(1).optional(),
+  linkedByUserId: z.string().min(1).optional(),
+  linkSource: repositoryLinkSourceSchema.optional(),
+  cloneStatus: repositoryCloneStatusSchema.optional(),
+  lastValidatedAt: isoDateTimeSchema.optional(),
+  status: z.enum(["active", "revoked"]).default("active")
+});
+var brainDocumentItemSchema = baseItemSchema.extend({
+  type: z.literal("brainDocument"),
+  projectId: z.string().min(1),
+  documentId: z.string().min(1),
+  documentType: documentTypeSchema,
+  title: z.string().min(1),
+  status: z.string().min(1),
+  repoPath: z.string().min(1),
+  content: z.string(),
+  contentHash: z.string().min(1),
+  frontmatter: z.record(z.string(), z.unknown()).default({}),
+  revision: z.number().int().nonnegative(),
+  approvedRevision: z.number().int().nonnegative().optional(),
+  source: sourceSchema,
+  syncState: syncStateSchema
+});
+var generatedDraftItemSchema = baseItemSchema.extend({
+  type: z.literal("generatedDraft"),
+  projectId: z.string().min(1),
+  wishId: z.string().min(1),
+  title: z.string().min(1),
+  status: generatedDraftStatusSchema,
+  documentIds: z.array(z.string()).default([]),
+  wish: z.string().min(1).optional(),
+  requestedByUserId: z.string().min(1).optional(),
+  workItemId: z.string().min(1).optional(),
+  runnerId: z.string().min(1).optional(),
+  generationAttempt: z.number().int().nonnegative().optional(),
+  lastGenerationError: z.string().optional()
+});
+var syncCursorItemSchema = baseItemSchema.extend({
+  type: z.literal("syncCursor"),
+  projectId: z.string().min(1),
+  repositoryLinkId: z.string().min(1),
+  lastSyncedRevision: z.number().int().nonnegative(),
+  lastSyncedAt: isoDateTimeSchema.optional()
+});
+var syncConflictItemSchema = baseItemSchema.extend({
+  type: z.literal("syncConflict"),
+  projectId: z.string().min(1),
+  conflictId: z.string().min(1),
+  documentId: z.string().min(1),
+  repoPath: z.string().min(1),
+  webRevision: z.number().int().nonnegative(),
+  repoContentHash: z.string().min(1),
+  status: z.enum(["open", "resolved", "ignored"])
+});
+var workItemSchema = baseItemSchema.extend({
+  type: z.literal("workItem"),
+  projectId: z.string().min(1),
+  workItemId: z.string().min(1),
+  workKind: workKindSchema.optional(),
+  status: workStatusSchema,
+  executionMode: executionModeSchema.optional(),
+  title: z.string().min(1),
+  requestedBy: z.string().min(1),
+  approvedBy: z.string().min(1).optional(),
+  sourceWish: z.string().min(1).optional(),
+  generatedDraftId: z.string().min(1).optional(),
+  reviewThreadId: z.string().min(1).optional(),
+  reviewDocumentId: z.string().min(1).optional(),
+  reviewDocumentRevision: z.number().int().nonnegative().optional(),
+  reviewMessageId: z.string().min(1).optional(),
+  claimedByRunnerId: z.string().optional(),
+  leaseExpiresAt: isoDateTimeSchema.optional(),
+  attempt: z.number().int().nonnegative().default(0),
+  idempotencyKey: z.string().min(1),
+  sessionPolicy: sessionPolicySchema.optional(),
+  sessionGroupKey: z.string().min(1).optional(),
+  toolSessionId: z.string().min(1).optional(),
+  sessionDecision: sessionDecisionSchema.optional(),
+  sessionDecisionReason: z.string().min(1).optional(),
+  lastStatusMessage: z.string().optional(),
+  lastStatusAt: isoDateTimeSchema
+});
+var runnerHeartbeatItemSchema = baseItemSchema.extend({
+  type: z.literal("runnerHeartbeat"),
+  projectId: z.string().min(1),
+  runnerId: z.string().min(1),
+  repositoryLinkId: z.string().min(1),
+  status: z.enum(["online", "offline", "running", "blocked"]),
+  version: z.string().optional(),
+  mode: z.enum(["foreground", "background"]).optional(),
+  hostname: z.string().min(1).optional(),
+  runnerName: z.string().min(1).optional(),
+  capabilities: z.array(runnerToolCapabilitySchema).optional(),
+  requestedTool: runnerToolSelectionSchema.optional(),
+  effectiveTool: z.union([runnerToolNameSchema, z.literal("custom")]).optional(),
+  effectiveModel: z.string().min(1).optional(),
+  preferenceSource: runnerPreferenceSourceSchema.optional(),
+  preferenceStatus: runnerPreferenceStatusSchema.optional(),
+  preferenceMessage: z.string().optional(),
+  lastSeenAt: isoDateTimeSchema
+});
+var runnerSettingsItemSchema = baseItemSchema.extend({
+  type: z.literal("accountSettings"),
+  projectId: z.string().min(1),
+  settingsType: z.literal("runnerPreferences"),
+  scope: runnerPreferenceScopeSchema,
+  preferences: runnerToolModelPreferenceSchema
+});
+var runnerExecutionLogItemSchema = baseItemSchema.extend({
+  type: z.literal("runnerExecutionLog"),
+  projectId: z.string().min(1),
+  runnerLogId: z.string().min(1),
+  runnerId: z.string().min(1),
+  workKind: workKindSchema.optional(),
+  workItemId: z.string().min(1).optional(),
+  workTitle: z.string().min(1).optional(),
+  initiatedBy: z.string().min(1).optional(),
+  approvedBy: z.string().min(1).optional(),
+  status: z.enum(["claimed", "running", "completed", "failed", "blocked", "idle"]),
+  executionMode: executionModeSchema.optional(),
+  tool: z.string().min(1).optional(),
+  model: z.string().min(1).optional(),
+  attempt: z.number().int().nonnegative().optional(),
+  startedAt: isoDateTimeSchema.optional(),
+  endedAt: isoDateTimeSchema.optional(),
+  durationMs: z.number().int().nonnegative().optional(),
+  costUsd: z.number().nonnegative().optional(),
+  tokensIn: z.number().int().nonnegative().optional(),
+  tokensOut: z.number().int().nonnegative().optional(),
+  sessionPolicy: sessionPolicySchema.optional(),
+  sessionGroupKey: z.string().min(1).optional(),
+  toolSessionId: z.string().min(1).optional(),
+  sessionDecision: sessionDecisionSchema.optional(),
+  sessionDecisionReason: z.string().min(1).optional(),
+  message: z.string().optional(),
+  error: z.string().optional()
+});
+var runnerCredentialItemSchema = baseItemSchema.extend({
+  type: z.literal("runnerCredential"),
+  projectId: z.string().min(1),
+  runnerCredentialId: z.string().min(1),
+  repositoryLinkId: z.string().min(1),
+  tokenHash: z.string().min(32),
+  issuedAt: isoDateTimeSchema,
+  lastUsedAt: isoDateTimeSchema.optional(),
+  status: z.enum(["active", "revoked"]).default("active")
+});
+var runnerCommandKindSchema = z.enum(["update", "restart", "remove"]);
+var runnerCommandStatusSchema = z.enum(["pending", "acknowledged", "running", "completed", "failed", "expired", "cancelled"]);
+var runnerCommandItemSchema = baseItemSchema.extend({
+  type: z.literal("runnerCommand"),
+  projectId: z.string().min(1),
+  commandId: z.string().min(1),
+  commandKind: runnerCommandKindSchema,
+  status: runnerCommandStatusSchema,
+  runnerId: z.string().min(1),
+  repositoryLinkId: z.string().min(1),
+  requestedByUserId: z.string().min(1),
+  idempotencyKey: z.string().min(1),
+  lastStatusIdempotencyKey: z.string().min(1).optional(),
+  expiresAt: isoDateTimeSchema,
+  acknowledgedAt: isoDateTimeSchema.optional(),
+  startedAt: isoDateTimeSchema.optional(),
+  completedAt: isoDateTimeSchema.optional(),
+  cancelledAt: isoDateTimeSchema.optional(),
+  message: z.string().optional(),
+  error: z.string().optional()
+});
+var planReviewMessageRoleSchema = z.enum(["user", "assistant", "system"]);
+var planReviewMessageIntentSchema = z.enum(["ask", "revisionRequest", "revisionResult"]);
+var planReviewMessageStatusSchema = z.enum(["posted", "queued", "running", "completed", "failed"]);
+var planReviewMessageItemSchema = baseItemSchema.extend({
+  type: z.literal("planReviewMessage"),
+  projectId: z.string().min(1),
+  messageId: z.string().min(1),
+  threadId: z.string().min(1),
+  generatedDraftId: z.string().min(1),
+  documentId: z.string().min(1),
+  documentRevision: z.number().int().nonnegative(),
+  role: planReviewMessageRoleSchema,
+  intent: planReviewMessageIntentSchema,
+  status: planReviewMessageStatusSchema,
+  content: z.string().min(1),
+  workItemId: z.string().min(1).optional(),
+  responseToMessageId: z.string().min(1).optional(),
+  createdByUserId: z.string().min(1).optional(),
+  runnerId: z.string().min(1).optional()
+});
+var toolSessionItemSchema = baseItemSchema.extend({
+  type: z.literal("toolSession"),
+  projectId: z.string().min(1),
+  toolSessionId: z.string().min(1),
+  repositoryLinkId: z.string().min(1).optional(),
+  tool: z.string().min(1),
+  provider: z.string().min(1).optional(),
+  model: z.string().min(1).optional(),
+  resumabilityScope: sessionResumabilityScopeSchema,
+  title: z.string().min(1),
+  summary: z.string().optional(),
+  tags: z.array(z.string().min(1)).default([]),
+  relatedDocumentIds: z.array(z.string().min(1)).default([]),
+  status: toolSessionStatusSchema,
+  createdByUserId: z.string().min(1).optional(),
+  runnerId: z.string().min(1).optional(),
+  lastWorkItemId: z.string().min(1).optional(),
+  lastActivityAt: isoDateTimeSchema,
+  messageCount: z.number().int().nonnegative().optional(),
+  estimatedInputTokens: z.number().int().nonnegative().optional(),
+  estimatedOutputTokens: z.number().int().nonnegative().optional(),
+  costUsd: z.number().nonnegative().optional(),
+  sessionGroupKey: z.string().min(1).optional(),
+  reusePolicy: sessionPolicySchema.optional(),
+  closedReason: z.string().optional()
+});
+var pairingSessionItemSchema = baseItemSchema.extend({
+  type: z.literal("pairingSession"),
+  pairingCodeHash: z.string().min(1),
+  projectId: z.string().min(1),
+  createdByUserId: z.string().min(1),
+  expiresAt: isoDateTimeSchema,
+  status: z.enum(["pending", "confirmed", "expired", "revoked"])
+});
+var projectItemUnionSchema = z.discriminatedUnion("type", [
+  projectItemSchema,
+  repositoryLinkItemSchema,
+  brainDocumentItemSchema,
+  generatedDraftItemSchema,
+  syncCursorItemSchema,
+  syncConflictItemSchema,
+  workItemSchema,
+  runnerHeartbeatItemSchema,
+  runnerSettingsItemSchema,
+  runnerExecutionLogItemSchema,
+  runnerCredentialItemSchema,
+  runnerCommandItemSchema,
+  planReviewMessageItemSchema,
+  toolSessionItemSchema
+]);
+
+// ../shared/src/api-url.ts
+var AMISTIO_API_URL_ENV = "AMISTIO_API_URL";
+var OFFICIAL_AMISTIO_WEB_ORIGIN = "https://www.amistio.com";
+var API_PATH = "/api";
+var officialAmistioApiUrl = normalizeAmistioApiUrl(new URL(API_PATH, OFFICIAL_AMISTIO_WEB_ORIGIN).toString());
+function normalizeAmistioApiUrl(value) {
+  const parsed = new URL(value);
+  parsed.hash = "";
+  parsed.search = "";
+  if (parsed.pathname.length > 1 && parsed.pathname.endsWith("/")) {
+    parsed.pathname = parsed.pathname.slice(0, -1);
+  }
+  return parsed.toString().replace(/\/$/, "");
+}
+function isOfficialAmistioApiUrl(value) {
+  try {
+    return normalizeAmistioApiUrl(value) === officialAmistioApiUrl;
+  } catch {
+    return false;
+  }
+}
+
+// ../shared/src/repo-metadata.ts
+import { z as z2 } from "zod";
+var repoLinkMetadataSchema = z2.object({
+  amistioProjectId: z2.string().min(1),
+  amistioAccountId: z2.string().min(1),
+  repositoryLinkId: z2.string().min(1),
+  defaultBranch: z2.string().min(1).default("main"),
+  lastSyncedRevision: z2.coerce.number().int().nonnegative().default(0)
+});
+var syncedDocumentFrontmatterSchema = z2.object({
+  amistioDocumentId: z2.string().min(1),
+  amistioDocumentType: z2.string().min(1),
+  amistioRevision: z2.coerce.number().int().nonnegative(),
+  amistioContentHash: z2.string().min(1),
+  status: z2.string().optional()
+});
+function createProjectLinkMarkdown(metadata) {
+  return [
+    "---",
+    `amistioProjectId: ${metadata.amistioProjectId}`,
+    `amistioAccountId: ${metadata.amistioAccountId}`,
+    `repositoryLinkId: ${metadata.repositoryLinkId}`,
+    `defaultBranch: ${metadata.defaultBranch}`,
+    `lastSyncedRevision: ${metadata.lastSyncedRevision}`,
+    "---",
+    "",
+    "# Amistio Project Link",
+    "",
+    "This repository is paired with an Amistio project. Credentials are stored outside the repository on each user's machine.",
+    ""
+  ].join("\n");
+}
+
+// ../shared/src/repository-link.ts
+var scpStyleSshPattern = /^([A-Za-z0-9._-]+)@([A-Za-z0-9.-]+):(.+)$/;
+function parseRepositoryCloneUrl(input) {
+  const cloneUrl = input.trim();
+  if (!cloneUrl) {
+    throw new Error("Repository URL is required.");
+  }
+  if (isLocalPathLike(cloneUrl)) {
+    throw new Error("Use an HTTPS or SSH repository clone URL, not a local path.");
+  }
+  const scpMatch = scpStyleSshPattern.exec(cloneUrl);
+  if (scpMatch) {
+    const host = scpMatch[2];
+    const rawPath = scpMatch[3];
+    if (!host || !rawPath) {
+      throw new Error("Repository URL must include an owner and repository name.");
+    }
+    return buildParsedRepositoryCloneUrl({ cloneUrl, protocol: "ssh", host, rawPath });
+  }
+  let url;
+  try {
+    url = new URL(cloneUrl);
+  } catch {
+    throw new Error("Repository URL must be a valid HTTPS or SSH clone URL.");
+  }
+  if (url.protocol === "file:") {
+    throw new Error("Use an HTTPS or SSH repository clone URL, not a local path.");
+  }
+  if (url.protocol !== "https:" && url.protocol !== "ssh:") {
+    throw new Error("Repository URL must use HTTPS or SSH.");
+  }
+  if (url.protocol === "https:" && (url.username || url.password)) {
+    throw new Error("Repository URL must not include embedded credentials.");
+  }
+  if (url.protocol === "ssh:" && url.password) {
+    throw new Error("Repository SSH URL must not include a password.");
+  }
+  if (url.search || url.hash) {
+    throw new Error("Repository URL must not include query strings or fragments.");
+  }
+  return buildParsedRepositoryCloneUrl({
+    cloneUrl,
+    protocol: url.protocol === "https:" ? "https" : "ssh",
+    host: url.hostname,
+    rawPath: url.pathname
+  });
+}
+function repositoryCloneUrlsMatch(firstUrl, secondUrl) {
+  try {
+    return parseRepositoryCloneUrl(firstUrl).normalizedKey === parseRepositoryCloneUrl(secondUrl).normalizedKey;
+  } catch {
+    return false;
+  }
+}
+function buildParsedRepositoryCloneUrl({ cloneUrl, host, protocol, rawPath }) {
+  const normalizedHost = host.trim().toLowerCase();
+  if (!normalizedHost) {
+    throw new Error("Repository URL must include a host.");
+  }
+  const pathWithoutSlash = normalizeRepoPath(rawPath);
+  const segments = pathWithoutSlash.split("/").filter(Boolean);
+  if (segments.length < 2) {
+    throw new Error("Repository URL must include an owner and repository name.");
+  }
+  const repoSegment = segments[segments.length - 1];
+  const ownerSegment = segments[segments.length - 2];
+  const repoName = stripGitSuffix(repoSegment ?? "");
+  if (!repoName || !ownerSegment) {
+    throw new Error("Repository URL must include an owner and repository name.");
+  }
+  const normalizedSegments = [...segments.slice(0, -1), repoName].map((segment) => segment.toLowerCase());
+  const provider = inferRepositoryProvider(normalizedHost);
+  const repoOwner = ownerSegment;
+  const repoFullName = `${repoOwner}/${repoName}`;
+  return {
+    cloneUrl,
+    protocol,
+    host: normalizedHost,
+    path: pathWithoutSlash,
+    repoName,
+    normalizedKey: `${normalizedHost}/${normalizedSegments.join("/")}`,
+    ...provider ? { provider } : {},
+    repoOwner,
+    repoFullName
+  };
+}
+function normalizeRepoPath(rawPath) {
+  const withoutLeadingSlash = rawPath.trim().replace(/^\/+/, "").replace(/\/+$/, "");
+  if (!withoutLeadingSlash || withoutLeadingSlash.includes("..")) {
+    throw new Error("Repository URL path is not supported.");
+  }
+  return withoutLeadingSlash;
+}
+function stripGitSuffix(value) {
+  return value.replace(/\.git$/i, "");
+}
+function inferRepositoryProvider(host) {
+  if (host === "github.com" || host.endsWith(".github.com")) return "github";
+  if (host === "gitlab.com" || host.endsWith(".gitlab.com")) return "gitlab";
+  if (host === "bitbucket.org" || host.endsWith(".bitbucket.org")) return "bitbucket";
+  if (host.endsWith("dev.azure.com") || host.endsWith("visualstudio.com")) return "azureDevOps";
+  return "other";
+}
+function isLocalPathLike(value) {
+  return value.startsWith("/") || value.startsWith("./") || value.startsWith("../") || value.startsWith("~/") || /^[A-Za-z]:[\\/]/.test(value);
+}
+
+// ../shared/src/sync.ts
+import { createHash } from "node:crypto";
+function sha256ContentHash(content) {
+  return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function decideSyncState(state) {
+  const webChanged = Boolean(state.webHash && state.webHash !== state.lastSyncedHash);
+  const repoChanged = Boolean(state.repoHash && state.repoHash !== state.lastSyncedHash);
+  if (webChanged && repoChanged && state.webHash !== state.repoHash) {
+    return "conflict";
+  }
+  if (webChanged) {
+    return "pullWeb";
+  }
+  if (repoChanged) {
+    return "pushRepo";
+  }
+  return "clean";
+}
+
+// ../shared/src/next-action.ts
+var nextActionRunnerHeartbeatFreshMs = 15 * 60 * 1e3;
+function computeProjectNextAction(input) {
+  const nowMs = input.nowMs ?? Date.now();
+  if (!input.projectId) {
+    return {
+      kind: "noProject",
+      actor: "user",
+      tone: "neutral",
+      title: "Create a project",
+      message: "Create a project before linking a repository or starting runner work."
+    };
+  }
+  const activeRepositoryLinks = input.repositoryLinks.filter((link) => link.status !== "revoked");
+  const repositoryLink = activeRepositoryLinks[0];
+  if (!repositoryLink) {
+    return {
+      kind: "linkRepository",
+      actor: "user",
+      tone: "warning",
+      title: "Link a repository",
+      message: "Add the project repository so Amistio can pair a local runner."
+    };
+  }
+  const pairedRepositoryLinks = activeRepositoryLinks.filter((link) => Boolean(link.repoFingerprint));
+  if (!pairedRepositoryLinks.length) {
+    return {
+      kind: "pairRepository",
+      actor: "user",
+      tone: "warning",
+      title: "Pair the repository",
+      message: `Run the pairing command from ${repositoryLink.repoName} before queueing runner work.`,
+      repositoryLinkId: repositoryLink.repositoryLinkId,
+      updatedAt: repositoryLink.updatedAt
+    };
+  }
+  const runningWork = latestWorkItem(input.workItems.filter((item) => item.status === "running"));
+  if (runningWork) {
+    if (runningWork.workKind === "brainGeneration") {
+      return workAction(runningWork, "brainGenerationRunning", "runner", "warning", "Generating project brain", "The local runner is generating draft brain artifacts for review.");
+    }
+    if (runningWork.workKind === "planRevision") {
+      return workAction(runningWork, "planRevisionRunning", "runner", "warning", "Revising the plan", "The local runner is revising the generated plan from the conversation.");
+    }
+    return workAction(runningWork, "runnerRunningWork", "runner", "warning", "Runner is working", "The local runner has claimed approved implementation work.");
+  }
+  const generatedReview = generatedReviewState(input.documents);
+  if (generatedReview.unapproved.length > 0) {
+    const partial = generatedReview.approved.length > 0;
+    const title = partial ? "Finish generated review" : "Review generated artifacts";
+    const message = partial ? `${generatedReview.unapproved.length} generated artifact${generatedReview.unapproved.length === 1 ? "" : "s"} still need approval before implementation work can queue.` : `${generatedReview.unapproved.length} generated artifact${generatedReview.unapproved.length === 1 ? "" : "s"} need approval in the web app before the runner can implement them.`;
+    return {
+      kind: partial ? "generatedArtifactsPartiallyApproved" : "generatedArtifactsReview",
+      actor: "user",
+      tone: "warning",
+      title,
+      message,
+      count: generatedReview.unapproved.length,
+      ...generatedReview.unapproved[0]?.documentId ? { documentId: generatedReview.unapproved[0].documentId } : {},
+      ...latestTimestamp(generatedReview.unapproved.map((document) => document.updatedAt)) ? { updatedAt: latestTimestamp(generatedReview.unapproved.map((document) => document.updatedAt)) } : {}
+    };
+  }
+  const failedBrainGeneration = latestWorkItem(input.workItems.filter((item) => item.workKind === "brainGeneration" && item.status === "failed"));
+  if (failedBrainGeneration) {
+    return workAction(failedBrainGeneration, "brainGenerationFailed", "user", "danger", "Brain generation failed", failedBrainGeneration.lastStatusMessage ?? "Retry generation after checking the runner output.");
+  }
+  const failedPlanRevision = latestWorkItem(input.workItems.filter((item) => item.workKind === "planRevision" && item.status === "failed"));
+  if (failedPlanRevision) {
+    return workAction(failedPlanRevision, "planRevisionFailed", "user", "danger", "Plan revision failed", failedPlanRevision.lastStatusMessage ?? "Review the conversation and request another revision if needed.");
+  }
+  const blockedWork = latestWorkItem(input.workItems.filter((item) => item.status === "blocked" || item.status === "changesRequested"));
+  if (blockedWork) {
+    return workAction(blockedWork, "workBlocked", "user", "danger", "Work is blocked", blockedWork.lastStatusMessage ?? "Review the blocked work item before the runner can continue.");
+  }
+  const failedWork = latestWorkItem(input.workItems.filter((item) => item.status === "failed"));
+  if (failedWork) {
+    return workAction(failedWork, "workFailed", "user", "danger", "Work failed", failedWork.lastStatusMessage ?? "Review the failure and retry or update the plan.");
+  }
+  const queuedBrainGeneration = latestWorkItem(input.workItems.filter((item) => item.workKind === "brainGeneration" && item.status === "approved"));
+  const queuedPlanRevision = latestWorkItem(input.workItems.filter((item) => item.workKind === "planRevision" && item.status === "approved"));
+  const queuedImplementation = latestWorkItem(input.workItems.filter((item) => item.workKind !== "brainGeneration" && item.workKind !== "planRevision" && item.status === "approved"));
+  const queuedWork = queuedBrainGeneration ?? queuedPlanRevision ?? queuedImplementation;
+  const readiness = getSharedRunnerReadiness(pairedRepositoryLinks, input.runnerHeartbeats, nowMs);
+  if (queuedWork && !readiness.ready) {
+    const title = queuedWork.workKind === "brainGeneration" ? "Brain generation is queued" : queuedWork.workKind === "planRevision" ? "Plan revision is queued" : "Implementation is queued";
+    return runnerWaitAction(readiness, title);
+  }
+  if (queuedBrainGeneration) {
+    return workAction(queuedBrainGeneration, "brainGenerationQueued", "runner", "warning", "Brain generation queued", "The local runner can claim this queued brain-generation work.");
+  }
+  if (queuedPlanRevision) {
+    return workAction(queuedPlanRevision, "planRevisionQueued", "runner", "warning", "Plan revision queued", "The local runner can claim the requested plan revision.");
+  }
+  if (queuedImplementation) {
+    return workAction(queuedImplementation, "implementationQueued", "runner", "warning", "Implementation queued", "The local runner can claim approved implementation work.");
+  }
+  if (!readiness.ready) {
+    return runnerWaitAction(readiness, "Runner setup needed");
+  }
+  const completedWork = latestWorkItem(input.workItems.filter((item) => item.status === "completed"));
+  if (completedWork) {
+    return workAction(completedWork, "workCompleted", "none", "success", "Work completed", completedWork.lastStatusMessage ?? "The latest runner work is complete.");
+  }
+  return {
+    kind: "idle",
+    actor: "user",
+    tone: "success",
+    title: "Ready for the next task",
+    message: "The repository and runner are ready for a new project-brain request.",
+    ...readiness.repositoryLink?.repositoryLinkId ? { repositoryLinkId: readiness.repositoryLink.repositoryLinkId } : {},
+    ...readiness.heartbeat?.runnerId ? { runnerId: readiness.heartbeat.runnerId } : {},
+    ...readiness.heartbeat?.lastSeenAt ? { updatedAt: readiness.heartbeat.lastSeenAt } : {}
+  };
+}
+function formatProjectNextAction(action) {
+  return `${action.title}: ${action.message}`;
+}
+function runnerWaitAction(readiness, fallbackTitle) {
+  const repositoryName = readiness.repositoryLink?.repoName ?? "the paired repository";
+  if (readiness.reason === "runnerOffline") {
+    return {
+      kind: "runnerOffline",
+      actor: "user",
+      tone: "danger",
+      title: "Restart the runner",
+      message: `The runner for ${repositoryName} is offline. Start amistio run --watch from the paired checkout.`,
+      ...readiness.repositoryLink?.repositoryLinkId ? { repositoryLinkId: readiness.repositoryLink.repositoryLinkId } : {},
+      ...readiness.heartbeat?.runnerId ? { runnerId: readiness.heartbeat.runnerId } : {},
+      ...readiness.heartbeat?.lastSeenAt ? { updatedAt: readiness.heartbeat.lastSeenAt } : {}
+    };
+  }
+  if (readiness.reason === "runnerStale") {
+    return {
+      kind: "runnerStale",
+      actor: "user",
+      tone: "warning",
+      title: "Refresh the runner",
+      message: `The runner for ${repositoryName} has not checked in recently. Restart amistio run --watch from the paired checkout.`,
+      ...readiness.repositoryLink?.repositoryLinkId ? { repositoryLinkId: readiness.repositoryLink.repositoryLinkId } : {},
+      ...readiness.heartbeat?.runnerId ? { runnerId: readiness.heartbeat.runnerId } : {},
+      ...readiness.heartbeat?.lastSeenAt ? { updatedAt: readiness.heartbeat.lastSeenAt } : {}
+    };
+  }
+  return {
+    kind: "runnerMissing",
+    actor: "user",
+    tone: "warning",
+    title: fallbackTitle,
+    message: `Start amistio run --watch from ${repositoryName} so the local runner can claim work.`,
+    ...readiness.repositoryLink?.repositoryLinkId ? { repositoryLinkId: readiness.repositoryLink.repositoryLinkId } : {}
+  };
+}
+function getSharedRunnerReadiness(repositoryLinks, runnerHeartbeats, nowMs) {
+  const repositoryLinkIds = new Set(repositoryLinks.map((link) => link.repositoryLinkId));
+  const latestHeartbeat = runnerHeartbeats.filter((heartbeat) => repositoryLinkIds.has(heartbeat.repositoryLinkId)).sort((first, second) => heartbeatTime(second) - heartbeatTime(first))[0];
+  const repositoryLink = latestHeartbeat ? repositoryLinks.find((link) => link.repositoryLinkId === latestHeartbeat.repositoryLinkId) ?? repositoryLinks[0] : repositoryLinks[0];
+  if (!latestHeartbeat) {
+    return { ready: false, reason: "runnerMissing", ...repositoryLink ? { repositoryLink } : {} };
+  }
+  if (latestHeartbeat.status === "offline") {
+    return { ready: false, reason: "runnerOffline", ...repositoryLink ? { repositoryLink } : {}, heartbeat: latestHeartbeat };
+  }
+  if (!isFreshHeartbeat(latestHeartbeat, nowMs)) {
+    return { ready: false, reason: "runnerStale", ...repositoryLink ? { repositoryLink } : {}, heartbeat: latestHeartbeat };
+  }
+  return { ready: true, reason: "ready", ...repositoryLink ? { repositoryLink } : {}, heartbeat: latestHeartbeat };
+}
+function generatedReviewState(documents) {
+  const generated = documents.filter(isGeneratedDocument);
+  return {
+    approved: generated.filter((document) => document.status === "approved"),
+    unapproved: generated.filter((document) => document.status !== "approved" && document.status !== "rejected" && document.syncState !== "archived")
+  };
+}
+function isGeneratedDocument(document) {
+  const generatedDraftId = document.frontmatter.generatedDraftId;
+  return typeof generatedDraftId === "string" && generatedDraftId.length > 0;
+}
+function workAction(workItem, kind, actor, tone, title, message) {
+  return {
+    kind,
+    actor,
+    tone,
+    title,
+    message,
+    workItemId: workItem.workItemId,
+    ...workItem.claimedByRunnerId ? { runnerId: workItem.claimedByRunnerId } : {},
+    updatedAt: workItem.lastStatusAt
+  };
+}
+function latestWorkItem(workItems) {
+  return [...workItems].sort((first, second) => Date.parse(second.updatedAt) - Date.parse(first.updatedAt))[0];
+}
+function latestTimestamp(values) {
+  return values.sort((first, second) => Date.parse(second) - Date.parse(first))[0];
+}
+function heartbeatTime(heartbeat) {
+  const timestamp = Date.parse(heartbeat.lastSeenAt);
+  return Number.isNaN(timestamp) ? 0 : timestamp;
+}
+function isFreshHeartbeat(heartbeat, nowMs) {
+  const lastSeenMs = heartbeatTime(heartbeat);
+  return lastSeenMs > 0 && nowMs - lastSeenMs <= nextActionRunnerHeartbeatFreshMs;
+}
+
+// src/bootstrap.ts
+import { execFile } from "node:child_process";
+import { mkdir, readdir, stat } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+function buildGitCloneArgs(repoUrl, targetDir) {
+  return ["clone", repoUrl, targetDir];
+}
+async function cloneOrValidateRepository({ repoUrl, targetDir }) {
+  const resolvedTarget = path.resolve(targetDir);
+  const targetStat = await stat(resolvedTarget).catch((error) => {
+    if (isNotFoundError(error)) return void 0;
+    throw error;
+  });
+  if (!targetStat) {
+    await mkdir(path.dirname(resolvedTarget), { recursive: true });
+    await runGit(buildGitCloneArgs(repoUrl, resolvedTarget), "clone");
+    return { status: "cloned", targetDir: resolvedTarget };
+  }
+  if (!targetStat.isDirectory()) {
+    throw new Error("Bootstrap target exists and is not a directory.");
+  }
+  if (await isGitCheckout(resolvedTarget)) {
+    const originUrl = await runGit(["-C", resolvedTarget, "remote", "get-url", "origin"], "remote");
+    if (!repositoryCloneUrlsMatch(repoUrl, originUrl)) {
+      throw new Error("Bootstrap target is a Git checkout for a different repository.");
+    }
+    return { status: "validated", targetDir: resolvedTarget, originUrl };
+  }
+  const entries = await readdir(resolvedTarget);
+  if (entries.length > 0) {
+    throw new Error("Bootstrap target exists, is not empty, and is not the linked repository checkout.");
+  }
+  await runGit(buildGitCloneArgs(repoUrl, resolvedTarget), "clone");
+  return { status: "cloned", targetDir: resolvedTarget };
+}
+async function isGitCheckout(targetDir) {
+  try {
+    const result = await runGit(["-C", targetDir, "rev-parse", "--is-inside-work-tree"], "rev-parse");
+    return result.trim() === "true";
+  } catch {
+    return false;
+  }
+}
+async function runGit(args, operation) {
+  try {
+    const { stdout } = await execFileAsync("git", args, { maxBuffer: 1024 * 1024 });
+    return stdout.trim();
+  } catch {
+    if (operation === "clone") {
+      throw new Error("git clone failed. Confirm local Git credentials can access the repository.");
+    }
+    if (operation === "remote") {
+      throw new Error("Could not read the target checkout origin remote.");
+    }
+    throw new Error("Could not inspect the target Git checkout.");
+  }
+}
+function isNotFoundError(error) {
+  return Boolean(error && typeof error === "object" && "code" in error && error.code === "ENOENT");
+}
+
+// src/credential-store.ts
+import { chmod, mkdir as mkdir2, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path2 from "node:path";
+var LocalCredentialStore = class {
+  constructor(filePath = path2.join(os.homedir(), ".config", "amistio", "credentials.json")) {
+    this.filePath = filePath;
+  }
+  filePath;
+  async set(key, value) {
+    const data = await this.read();
+    data.credentials[key] = value;
+    await mkdir2(path2.dirname(this.filePath), { recursive: true });
+    await writeFile(this.filePath, JSON.stringify(data, null, 2), { encoding: "utf8", mode: 384 });
+    await chmod(this.filePath, 384);
+  }
+  async get(key) {
+    const data = await this.read();
+    return data.credentials[key];
+  }
+  async delete(key) {
+    const data = await this.read();
+    if (!(key in data.credentials)) {
+      return;
+    }
+    delete data.credentials[key];
+    await mkdir2(path2.dirname(this.filePath), { recursive: true });
+    await writeFile(this.filePath, JSON.stringify(data, null, 2), { encoding: "utf8", mode: 384 });
+    await chmod(this.filePath, 384);
+  }
+  async read() {
+    try {
+      return JSON.parse(await readFile(this.filePath, "utf8"));
+    } catch {
+      return { credentials: {} };
+    }
+  }
+};
+function credentialKey(accountId, projectId, repositoryLinkId) {
+  return `${accountId}:${projectId}:${repositoryLinkId}`;
+}
+
+// src/control-plane.ts
+import { mkdir as mkdir3, readFile as readFile2, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
+import path3 from "node:path";
+var controlPlaneFolders = [
+  "architecture",
+  "context",
+  "decisions",
+  "features",
+  "memory",
+  "plans",
+  path3.join("prompts", "shared"),
+  "workflows"
+];
+async function initControlPlane(rootDir) {
+  const created = [];
+  for (const folder of controlPlaneFolders) {
+    const fullPath = path3.join(rootDir, folder);
+    if (!await exists(fullPath)) {
+      await mkdir3(fullPath, { recursive: true });
+      created.push(folder);
+    }
+  }
+  await writeIfMissing(
+    path3.join(rootDir, "AGENTS.md"),
+    "# Agents\n\nRoot control-plane folders are the project brain. Keep architecture, context, decisions, features, memory, plans, prompts, and workflows in sync with product intent.\n"
+  );
+  await writeIfMissing(path3.join(rootDir, "context", "product.md"), "# Product Context\n\nDescribe the product direction here.\n");
+  await writeIfMissing(path3.join(rootDir, "architecture", "overview.md"), "# Architecture Overview\n\nDescribe the system shape here.\n");
+  return created;
+}
+async function inspectControlPlane(rootDir) {
+  const present = [];
+  const missing = [];
+  for (const folder of controlPlaneFolders) {
+    if (await exists(path3.join(rootDir, folder))) {
+      present.push(folder);
+    } else {
+      missing.push(folder);
+    }
+  }
+  return { present, missing };
+}
+async function writeProjectLink(rootDir, metadata) {
+  const contextDir = path3.join(rootDir, "context");
+  await mkdir3(contextDir, { recursive: true });
+  const filePath = path3.join(contextDir, "amistio-project.md");
+  await writeFile2(filePath, createProjectLinkMarkdown(metadata), "utf8");
+  return filePath;
+}
+async function readProjectLink(rootDir) {
+  const filePath = path3.join(rootDir, "context", "amistio-project.md");
+  if (!await exists(filePath)) {
+    return void 0;
+  }
+  const content = await readFile2(filePath, "utf8");
+  const frontmatter = parseFrontmatter(content);
+  return repoLinkMetadataSchema.parse(frontmatter);
+}
+function parseFrontmatter(content) {
+  if (!content.startsWith("---\n")) {
+    return {};
+  }
+  const end = content.indexOf("\n---", 4);
+  if (end === -1) {
+    return {};
+  }
+  const lines = content.slice(4, end).split("\n");
+  return Object.fromEntries(
+    lines.map((line) => {
+      const separator = line.indexOf(":");
+      if (separator === -1) {
+        return void 0;
+      }
+      return [line.slice(0, separator).trim(), line.slice(separator + 1).trim()];
+    }).filter((entry) => Boolean(entry))
+  );
+}
+async function writeIfMissing(filePath, content) {
+  if (await exists(filePath)) {
+    return;
+  }
+  await writeFile2(filePath, content, "utf8");
+}
+async function exists(filePath) {
+  try {
+    await stat2(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/api-client.ts
+import { z as z3 } from "zod";
+var ApiClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  async createPairingSession(projectId) {
+    return this.request(
+      "pairing-sessions",
+      z3.object({ pairingCode: z3.string(), expiresAt: z3.string() }),
+      {
+        method: "POST",
+        body: JSON.stringify({ projectId })
+      }
+    );
+  }
+  async consumePairingSession(input) {
+    return this.request(
+      "pairing-sessions",
+      z3.object({ repositoryLink: repositoryLinkItemSchema, token: z3.string().min(1) }),
+      {
+        method: "PATCH",
+        body: JSON.stringify(input)
+      }
+    );
+  }
+  async claimWork(projectId, runnerId, repositoryLinkId, leaseSeconds = 300) {
+    return this.request(
+      `/projects/${projectId}/work-items/claim`,
+      z3.object({ workItem: workItemSchema.optional() }).transform(({ workItem }) => ({ workItem })),
+      {
+        method: "POST",
+        body: JSON.stringify({ runnerId, repositoryLinkId, leaseSeconds })
+      }
+    );
+  }
+  async listWorkItems(projectId) {
+    return this.request(
+      `/projects/${projectId}/work-items`,
+      z3.object({ workItems: z3.array(workItemSchema) }),
+      { method: "GET" }
+    );
+  }
+  async listBrainDocuments(projectId) {
+    return this.request(
+      `/projects/${projectId}/brain-documents`,
+      z3.object({ documents: z3.array(brainDocumentItemSchema) }),
+      { method: "GET" }
+    );
+  }
+  async listPlanReviewMessages(projectId, documentId) {
+    const suffix = documentId ? `?documentId=${encodeURIComponent(documentId)}` : "";
+    return this.request(
+      `/projects/${projectId}/plan-review-messages${suffix}`,
+      z3.object({ messages: z3.array(planReviewMessageItemSchema) }),
+      { method: "GET" }
+    );
+  }
+  async pushBrainDocuments(projectId, documents) {
+    return this.request(
+      `/projects/${projectId}/brain-documents`,
+      z3.object({ documents: z3.array(brainDocumentItemSchema) }),
+      {
+        method: "POST",
+        body: JSON.stringify({ documents })
+      }
+    );
+  }
+  async listRunners(projectId) {
+    return this.request(
+      `/projects/${projectId}/runners`,
+      z3.object({ runners: z3.array(runnerHeartbeatItemSchema) }),
+      { method: "GET" }
+    );
+  }
+  async listRunnerCommands(projectId, runnerId, repositoryLinkId) {
+    return this.request(
+      `/projects/${projectId}/runner-commands?runnerId=${encodeURIComponent(runnerId)}&repositoryLinkId=${encodeURIComponent(repositoryLinkId)}`,
+      z3.object({ commands: z3.array(runnerCommandItemSchema) }),
+      { method: "GET" }
+    );
+  }
+  async updateRunnerCommand(projectId, commandId, input) {
+    return this.request(
+      `/projects/${projectId}/runner-commands/${commandId}`,
+      z3.object({ command: runnerCommandItemSchema }),
+      {
+        method: "PATCH",
+        body: JSON.stringify(input)
+      }
+    );
+  }
+  async getRunnerPreferences(projectId) {
+    const response = await this.request(
+      `/projects/${projectId}/runner-preferences`,
+      z3.object({
+        account: runnerSettingsItemSchema.optional(),
+        project: runnerSettingsItemSchema.optional(),
+        effective: z3.object({
+          tool: runnerToolSelectionSchema,
+          model: z3.string().optional(),
+          source: runnerPreferenceSourceSchema
+        })
+      }),
+      { method: "GET" }
+    );
+    return {
+      ...response.account ? { account: response.account } : {},
+      ...response.project ? { project: response.project } : {},
+      effective: response.effective
+    };
+  }
+  async sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, status, metadata) {
+    const heartbeatMetadata = typeof metadata === "string" ? { version: metadata } : metadata ?? {};
+    return this.request(
+      `/projects/${projectId}/runners`,
+      z3.object({ runner: runnerHeartbeatItemSchema }),
+      {
+        method: "POST",
+        body: JSON.stringify({ runnerId, repositoryLinkId, status, ...heartbeatMetadata, lastSeenAt: (/* @__PURE__ */ new Date()).toISOString() })
+      }
+    );
+  }
+  async listToolSessions(projectId) {
+    return this.request(
+      `/projects/${projectId}/tool-sessions`,
+      z3.object({ toolSessions: z3.array(toolSessionItemSchema) }),
+      { method: "GET" }
+    );
+  }
+  async createToolSession(projectId, session) {
+    return this.request(
+      `/projects/${projectId}/tool-sessions`,
+      z3.object({ toolSession: toolSessionItemSchema }),
+      {
+        method: "POST",
+        body: JSON.stringify(session)
+      }
+    );
+  }
+  async updateToolSession(projectId, toolSessionId, session) {
+    return this.request(
+      `/projects/${projectId}/tool-sessions/${toolSessionId}`,
+      z3.object({ toolSession: toolSessionItemSchema }),
+      {
+        method: "PATCH",
+        body: JSON.stringify(session)
+      }
+    );
+  }
+  async updateWorkStatus(projectId, workItemId, status, idempotencyKey, runnerId, telemetry = {}) {
+    return this.request(
+      `/projects/${projectId}/work-items/${workItemId}/status`,
+      z3.object({ workItem: workItemSchema }),
+      {
+        method: "PATCH",
+        body: JSON.stringify({ status, idempotencyKey, ...runnerId ? { runnerId } : {}, ...telemetry })
+      }
+    );
+  }
+  async submitBrainGenerationResult(projectId, workItemId, result) {
+    return this.request(
+      `/projects/${projectId}/work-items/${workItemId}/generation-result`,
+      z3.object({ draft: generatedDraftItemSchema, documents: z3.array(brainDocumentItemSchema), workItem: workItemSchema }),
+      {
+        method: "POST",
+        body: JSON.stringify(result)
+      }
+    );
+  }
+  async request(urlPath, schema, init) {
+    const response = await fetch(resolveApiUrl(this.options.apiUrl, urlPath), {
+      ...init,
+      headers: {
+        "content-type": "application/json",
+        "x-amistio-account-id": this.options.accountId,
+        ...this.options.token ? { authorization: `Bearer ${this.options.token}` } : {}
+      }
     });
-    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 (!response.ok) {
+      const detail = await response.text().catch(() => "");
+      throw new Error(`Amistio API request failed: ${response.status} ${response.statusText}${detail ? ` - ${detail}` : ""}`);
+    }
+    return schema.parse(await response.json());
+  }
+};
+var toolSessionMutationSchema = z3.object({
+  toolSessionId: z3.string().min(1).optional(),
+  repositoryLinkId: z3.string().min(1).optional(),
+  tool: z3.string().min(1).optional(),
+  provider: z3.string().min(1).optional(),
+  model: z3.string().min(1).optional(),
+  resumabilityScope: sessionResumabilityScopeSchema.optional(),
+  title: z3.string().min(1).optional(),
+  summary: z3.string().optional(),
+  tags: z3.array(z3.string()).optional(),
+  relatedDocumentIds: z3.array(z3.string()).optional(),
+  status: toolSessionStatusSchema.optional(),
+  createdByUserId: z3.string().min(1).optional(),
+  runnerId: z3.string().min(1).optional(),
+  lastWorkItemId: z3.string().min(1).optional(),
+  messageCount: z3.number().int().nonnegative().optional(),
+  estimatedInputTokens: z3.number().int().nonnegative().optional(),
+  estimatedOutputTokens: z3.number().int().nonnegative().optional(),
+  costUsd: z3.number().nonnegative().optional(),
+  sessionGroupKey: z3.string().min(1).optional(),
+  reusePolicy: sessionPolicySchema.optional(),
+  sessionDecision: sessionDecisionSchema.optional(),
+  closedReason: z3.string().optional()
+});
+function resolveApiUrl(apiUrl, urlPath) {
+  const base = apiUrl.endsWith("/") ? apiUrl.slice(0, -1) : apiUrl;
+  const path10 = urlPath.startsWith("/") ? urlPath : `/${urlPath}`;
+  return new URL(`${base}${path10}`);
+}
+
+// src/orchestrator.ts
+import { mkdir as mkdir4, writeFile as writeFile3 } from "node:fs/promises";
+import path4 from "node:path";
+async function createOrchestrationPrompt(options) {
+  const controlPlane = await inspectControlPlane(options.rootDir);
+  return [
+    "# Amistio Orchestration Task",
+    "",
+    "You are running locally through the Amistio CLI inside the user's repository.",
+    "Your job is to keep future agents on the same track by updating the Amistio control plane, not by rewriting the project from scratch.",
+    "",
+    "## Goal",
+    "",
+    options.goal,
+    "",
+    "## Orchestrator Principle",
+    "",
+    "The root control-plane files are the project brain. They exist so agentic coding sessions can continue from established context, decisions, memory, plans, workflows, and prompts instead of drifting into a fresh interpretation each time.",
+    "",
+    "## Repository Rules",
+    "",
+    "- Read AGENTS.md first when it exists.",
+    "- Read existing architecture, context, decisions, features, memory, plans, prompts, and workflows before proposing changes.",
+    "- Preserve existing intent. Add the next useful orchestration layer instead of replacing old content wholesale.",
+    "- Prefer small additive edits, dated notes, explicit decisions, focused plans, and executable prompts.",
+    "- Do not modify product source code unless the user's goal explicitly asks for implementation.",
+    "- Do not create a repo-local .amistio folder.",
+    "- Do not write access tokens, API keys, refresh tokens, local filesystem secrets, or machine-specific credentials into the repository.",
+    "- Do not commit changes.",
+    "",
+    "## Control-Plane Areas",
+    "",
+    "- AGENTS.md for agent operating rules.",
+    "- architecture/**/*.md for system shape and boundaries.",
+    "- context/**/*.md for product, stack, and implementation context.",
+    "- decisions/**/*.md for ADRs and durable choices.",
+    "- features/**/*.md for behavior specs and acceptance criteria.",
+    "- memory/**/*.md for lessons, patterns, and known pitfalls.",
+    "- plans/**/*.md for near-term execution plans.",
+    "- prompts/**/*.md for model-agnostic implementation prompts.",
+    "- workflows/**/*.md for repeatable procedures.",
+    "",
+    "## Current Control-Plane Folder Status",
+    "",
+    `Present: ${controlPlane.present.length ? controlPlane.present.join(", ") : "none"}`,
+    `Missing: ${controlPlane.missing.length ? controlPlane.missing.join(", ") : "none"}`,
+    "",
+    "## Expected Result",
+    "",
+    "- Update the smallest useful set of control-plane files needed to orient the next coding agent.",
+    "- Record any new decision, plan, prompt, workflow, memory, or context that prevents future drift.",
+    "- Keep old decisions visible. If something is superseded, say so explicitly instead of silently deleting it.",
+    "- Summarize changed files, why they changed, and the recommended next agent action."
+  ].join("\n");
+}
+async function writePromptFile(filePath, prompt) {
+  await mkdir4(path4.dirname(filePath), { recursive: true });
+  await writeFile3(filePath, prompt, "utf8");
+  return filePath;
+}
+
+// src/local-tool-runner.ts
+import { spawn } from "node:child_process";
+import { mkdtemp, rm, writeFile as writeFile4 } from "node:fs/promises";
+import os2 from "node:os";
+import path5 from "node:path";
+var localToolNames = runnerToolNames;
+var localToolAdapters = [
+  {
+    name: "opencode",
+    description: "opencode SDK adapter using @opencode-ai/sdk, with CLI fallback.",
+    sdkPackageName: "@opencode-ai/sdk",
+    sdkDisplayCommand: "@opencode-ai/sdk createOpencode().client.session.prompt()",
+    sdkRequiresExecutable: true,
+    executable: "opencode",
+    supportsSessionReuse: true,
+    resumabilityScope: "localMachine",
+    runWithSdk: runOpencodeSdk,
+    buildInvocation: ({ prompt }) => ({
+      command: "opencode",
+      args: ["run", prompt],
+      displayCommand: "opencode run <generated prompt>"
+    })
+  },
+  {
+    name: "claude",
+    description: "Claude Agent SDK adapter using @anthropic-ai/claude-agent-sdk, with CLI fallback.",
+    sdkPackageName: "@anthropic-ai/claude-agent-sdk",
+    sdkDisplayCommand: "@anthropic-ai/claude-agent-sdk query()",
+    executable: "claude",
+    supportsSessionReuse: false,
+    resumabilityScope: "none",
+    runWithSdk: runClaudeSdk,
+    buildInvocation: ({ prompt }) => ({
+      command: "claude",
+      args: ["-p", prompt],
+      displayCommand: "claude -p <generated prompt>"
+    })
+  },
+  {
+    name: "codex",
+    description: "Codex SDK adapter using @openai/codex-sdk, with CLI fallback.",
+    sdkPackageName: "@openai/codex-sdk",
+    sdkDisplayCommand: "@openai/codex-sdk Codex.startThread().run()",
+    executable: "codex",
+    supportsSessionReuse: false,
+    resumabilityScope: "none",
+    runWithSdk: runCodexSdk,
+    buildInvocation: ({ prompt }) => ({
+      command: "codex",
+      args: ["exec", prompt],
+      displayCommand: "codex exec <generated prompt>"
+    })
+  },
+  {
+    name: "copilot",
+    description: "GitHub Copilot SDK adapter using @github/copilot-sdk.",
+    sdkPackageName: "@github/copilot-sdk",
+    sdkDisplayCommand: "@github/copilot-sdk CopilotClient.createSession().sendAndWait()",
+    supportsModelSelection: true,
+    supportsSessionReuse: false,
+    resumabilityScope: "none",
+    runWithSdk: runCopilotSdk
+  },
+  {
+    name: "gemini",
+    description: "Gemini CLI adapter using prompt mode.",
+    executable: "gemini",
+    supportsSessionReuse: false,
+    resumabilityScope: "none",
+    buildInvocation: ({ prompt }) => ({
+      command: "gemini",
+      args: ["-p", prompt],
+      displayCommand: "gemini -p <generated prompt>"
+    })
+  },
+  {
+    name: "aider",
+    description: "Aider CLI adapter using a one-shot message.",
+    executable: "aider",
+    supportsSessionReuse: false,
+    resumabilityScope: "none",
+    buildInvocation: ({ prompt }) => ({
+      command: "aider",
+      args: ["--yes", "--message", prompt],
+      displayCommand: "aider --yes --message <generated prompt>"
+    })
+  },
+  {
+    name: "cursor-agent",
+    description: "Cursor agent CLI adapter using prompt mode when installed.",
+    executable: "cursor-agent",
+    supportsSessionReuse: false,
+    resumabilityScope: "none",
+    buildInvocation: ({ prompt }) => ({
+      command: "cursor-agent",
+      args: ["-p", prompt],
+      displayCommand: "cursor-agent -p <generated prompt>"
+    })
+  }
+];
+function isLocalToolName(value) {
+  return localToolNames.includes(value);
+}
+async function detectLocalTools() {
+  return Promise.all(
+    localToolAdapters.map(async (adapter) => {
+      const sdkAvailable = await isSdkAvailable(adapter);
+      const commandAvailable = adapter.executable ? await commandExists(adapter.executable) : false;
+      return {
+        name: adapter.name,
+        description: adapter.description,
+        available: sdkAvailable || commandAvailable,
+        sdkAvailable,
+        commandAvailable,
+        execution: sdkAvailable ? "sdk" : commandAvailable ? "command" : "unavailable",
+        supportsSessionReuse: Boolean(adapter.supportsSessionReuse),
+        resumabilityScope: adapter.resumabilityScope ?? "none",
+        supportsModelSelection: Boolean(adapter.supportsModelSelection)
+      };
+    })
+  );
+}
+async function runLocalTool(options) {
+  const promptTempDir = await mkdtemp(path5.join(os2.tmpdir(), "amistio-prompt-"));
+  const promptFilePath = path5.join(promptTempDir, "prompt.md");
+  await writeFile4(promptFilePath, options.prompt, "utf8");
+  try {
+    const runnerOptions = {
+      rootDir: options.rootDir,
+      prompt: options.prompt,
+      promptFilePath,
+      tool: options.tool ?? "auto",
+      ...options.model ? { model: options.model } : {}
+    };
+    if (options.toolCommand) {
+      runnerOptions.toolCommand = options.toolCommand;
+    }
+    const runner2 = await createToolRunner(runnerOptions);
+    const result = await executeToolRunner(runner2, {
+      rootDir: options.rootDir,
+      prompt: options.prompt,
+      promptFilePath,
+      streamOutput: Boolean(options.streamOutput),
+      ...options.session ? { session: options.session } : {}
     });
-    if (!options.stream && result.stdout.trim()) {
-        console.log(result.stdout.trim());
+    return {
+      toolName: runner2.toolName,
+      displayCommand: runner2.kind === "sdk" ? runner2.displayCommand : runner2.invocation.displayCommand,
+      supportsSessionReuse: runner2.kind === "sdk" ? Boolean(runner2.adapter.supportsSessionReuse) : false,
+      resumabilityScope: runner2.kind === "sdk" ? runner2.adapter.resumabilityScope ?? "none" : "none",
+      ...options.model ? { model: options.model } : {},
+      ...result
+    };
+  } finally {
+    await rm(promptTempDir, { recursive: true, force: true });
+  }
+}
+async function createToolRunPreview(options) {
+  const promptFilePath = path5.join(os2.tmpdir(), "amistio-generated-prompt.md");
+  const runnerOptions = {
+    rootDir: options.rootDir,
+    prompt: options.prompt,
+    promptFilePath,
+    tool: options.tool ?? "auto",
+    ...options.model ? { model: options.model } : {}
+  };
+  if (options.toolCommand) {
+    runnerOptions.toolCommand = options.toolCommand;
+  }
+  const runner2 = await createToolRunner(runnerOptions);
+  return {
+    toolName: runner2.toolName,
+    displayCommand: runner2.kind === "sdk" ? runner2.displayCommand : runner2.invocation.displayCommand,
+    supportsSessionReuse: runner2.kind === "sdk" ? Boolean(runner2.adapter.supportsSessionReuse) : false,
+    resumabilityScope: runner2.kind === "sdk" ? runner2.adapter.resumabilityScope ?? "none" : "none",
+    ...options.model ? { model: options.model } : {}
+  };
+}
+function createCustomToolInvocation(commandTemplate, input) {
+  const displayCommand = commandTemplate.replaceAll("{promptFile}", shellQuote(input.promptFilePath)).replaceAll("{root}", shellQuote(input.rootDir));
+  return {
+    command: displayCommand,
+    args: [],
+    displayCommand,
+    shell: true,
+    ...commandTemplate.includes("{promptFile}") ? {} : { stdin: input.prompt }
+  };
+}
+async function createToolRunner(options) {
+  if (options.toolCommand) {
+    return {
+      toolName: "custom",
+      kind: "command",
+      invocation: createCustomToolInvocation(options.toolCommand, options)
+    };
+  }
+  const tool = normalizeToolRequest(options.tool);
+  if (tool === "none") {
+    throw new Error("No local tool selected. Use --tool auto, a supported tool name, or --tool-command.");
+  }
+  const adapter = tool === "auto" ? await selectFirstAvailableAdapter(Boolean(options.model)) : await selectRequestedAdapter(tool);
+  if (options.model && !adapter.supportsModelSelection) {
+    throw new Error(`Model selection is not supported by ${adapter.name}. Remove --model or choose a model-aware adapter.`);
+  }
+  if (adapter.runWithSdk && await isSdkAvailable(adapter)) {
+    return {
+      toolName: adapter.name,
+      kind: "sdk",
+      displayCommand: adapter.sdkDisplayCommand ?? `${adapter.name} SDK`,
+      adapter
+    };
+  }
+  if (adapter.buildInvocation && adapter.executable && await commandExists(adapter.executable)) {
+    return {
+      toolName: adapter.name,
+      kind: "command",
+      invocation: adapter.buildInvocation(options)
+    };
+  }
+  throw new Error(`The ${adapter.name} SDK or executable was not found. Install the SDK/runtime or pass --tool-command.`);
+}
+async function executeToolRunner(runner2, input) {
+  if (runner2.kind === "command") {
+    return executeToolInvocation(runner2.invocation, input.rootDir, input.streamOutput);
+  }
+  try {
+    return await runner2.adapter.runWithSdk(input);
+  } catch (error) {
+    if (runner2.adapter.buildInvocation && runner2.adapter.executable && await commandExists(runner2.adapter.executable)) {
+      const fallback = runner2.adapter.buildInvocation(input);
+      const result = await executeToolInvocation(fallback, input.rootDir, input.streamOutput);
+      const sdkFailure = `SDK execution for ${runner2.adapter.name} failed, fell back to ${fallback.displayCommand}: ${errorMessage(error)}`;
+      return {
+        ...result,
+        stderr: result.stderr ? `${sdkFailure}
+${result.stderr}` : sdkFailure
+      };
     }
-    if (!options.stream && result.stderr.trim()) {
-        console.error(result.stderr.trim());
+    throw error;
+  }
+}
+function normalizeToolRequest(value) {
+  if (value === "auto" || value === "none" || isLocalToolName(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported local tool: ${value}. Supported tools: auto, none, ${localToolNames.join(", ")}.`);
+}
+async function selectFirstAvailableAdapter(requiresModelSelection = false) {
+  for (const adapter of localToolAdapters) {
+    if (requiresModelSelection && !adapter.supportsModelSelection) {
+      continue;
     }
-    if (result.exitCode !== 0) {
-        process.exitCode = result.exitCode;
+    const sdkAvailable = await isSdkAvailable(adapter);
+    const commandAvailable = adapter.executable ? await commandExists(adapter.executable) : false;
+    if (sdkAvailable || commandAvailable) {
+      return adapter;
     }
-});
-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
+  }
+  throw new Error(
+    requiresModelSelection ? "No installed local AI tool supports model selection. Remove --model or choose a model-aware adapter." : `No supported local AI tool was found. Install one of ${localToolNames.join(", ")} or pass --tool-command "your-tool --prompt-file {promptFile}".`
+  );
+}
+async function selectRequestedAdapter(tool) {
+  const adapter = localToolAdapters.find((candidate) => candidate.name === tool);
+  if (!adapter) {
+    throw new Error(`Unsupported local tool: ${tool}.`);
+  }
+  if (await isSdkAvailable(adapter)) {
+    return adapter;
+  }
+  if (adapter.executable && await commandExists(adapter.executable)) {
+    return adapter;
+  }
+  throw new Error(`The ${tool} SDK or executable was not found. Install it or pass --tool-command.`);
+}
+async function isSdkAvailable(adapter) {
+  if (!adapter.sdkPackageName || !adapter.runWithSdk) {
+    return false;
+  }
+  if (adapter.sdkRequiresExecutable && adapter.executable && !await commandExists(adapter.executable)) {
+    return false;
+  }
+  return packageAvailable(adapter.sdkPackageName);
+}
+async function packageAvailable(packageName) {
+  try {
+    await import(packageName);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function commandExists(command) {
+  const lookupCommand = process.platform === "win32" ? "where" : "which";
+  return new Promise((resolve) => {
+    const lookup = spawn(lookupCommand, [command], { stdio: "ignore" });
+    lookup.on("error", () => resolve(false));
+    lookup.on("close", (exitCode) => resolve(exitCode === 0));
+  });
+}
+async function executeToolInvocation(invocation, rootDir, streamOutput) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(invocation.command, invocation.args, {
+      cwd: rootDir,
+      env: process.env,
+      shell: invocation.shell ?? false,
+      stdio: ["pipe", "pipe", "pipe"]
     });
-    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;
+    let stdout = "";
+    let stderr = "";
+    child.on("error", reject);
+    child.stdout.setEncoding("utf8");
+    child.stderr.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk;
+      if (streamOutput) {
+        process.stdout.write(chunk);
+      }
     });
-    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 } : {})
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+      if (streamOutput) {
+        process.stderr.write(chunk);
+      }
     });
-    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 } : {})
+    child.stdin.on("error", () => void 0);
+    if (invocation.stdin) {
+      child.stdin.write(invocation.stdin);
+    }
+    child.stdin.end();
+    child.on("close", (exitCode) => {
+      resolve({ exitCode: exitCode ?? 1, stdout, stderr });
     });
-    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}`);
+  });
+}
+async function runOpencodeSdk(input) {
+  const { createOpencode } = await import("@opencode-ai/sdk");
+  const previousDirectory = process.cwd();
+  process.chdir(input.rootDir);
+  try {
+    const opencode = await createOpencode({ timeout: 1e4 });
+    try {
+      let providerSessionId = input.session?.providerSessionId;
+      if (!providerSessionId) {
+        const sessionResult = await opencode.client.session.create({
+          query: { directory: input.rootDir },
+          body: { title: "Amistio orchestration" }
+        });
+        if (sessionResult.error || !sessionResult.data) {
+          throw new Error(`opencode session create failed: ${JSON.stringify(sessionResult.error ?? "missing data")}`);
         }
-        catch (error) {
-            generationError = errorMessage(error);
+        providerSessionId = sessionResult.data.id;
+      }
+      const promptResult = await opencode.client.session.prompt({
+        path: { id: providerSessionId },
+        query: { directory: input.rootDir },
+        body: { parts: [{ type: "text", text: input.prompt }] }
+      });
+      if (promptResult.error || !promptResult.data) {
+        throw new Error(`opencode prompt failed: ${JSON.stringify(promptResult.error ?? "missing data")}`);
+      }
+      const stdout = extractTextParts(promptResult.data.parts);
+      if (input.streamOutput && stdout) {
+        process.stdout.write(stdout);
+      }
+      return { exitCode: 0, stdout, stderr: "", providerSessionId, messageCount: 1 };
+    } finally {
+      opencode.server.close();
+    }
+  } finally {
+    process.chdir(previousDirectory);
+  }
+}
+async function runClaudeSdk(input) {
+  const { query } = await import("@anthropic-ai/claude-agent-sdk");
+  let stdout = "";
+  let stderr = "";
+  let exitCode = 0;
+  for await (const message of query({
+    prompt: input.prompt,
+    options: {
+      cwd: input.rootDir,
+      permissionMode: "default",
+      tools: { type: "preset", preset: "claude_code" },
+      env: {
+        ...process.env,
+        CLAUDE_AGENT_SDK_CLIENT_APP: "amistio-cli/0.1.0"
+      }
+    }
+  })) {
+    if (isRecord(message) && message.type === "result") {
+      if (message.subtype === "success" && typeof message.result === "string") {
+        stdout += message.result;
+        if (input.streamOutput) {
+          process.stdout.write(message.result);
         }
+      } else {
+        exitCode = 1;
+        const resultMessage = message;
+        const errors = Array.isArray(resultMessage.errors) ? resultMessage.errors.map(String).join("\n") : "Claude Agent SDK execution failed.";
+        stderr += errors;
+      }
     }
-    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 } : {})
+  }
+  return { exitCode, stdout, stderr };
+}
+async function runCodexSdk(input) {
+  const { Codex } = await import("@openai/codex-sdk");
+  const codex = new Codex();
+  const thread = codex.startThread({
+    workingDirectory: input.rootDir,
+    sandboxMode: "workspace-write",
+    approvalPolicy: "on-request",
+    skipGitRepoCheck: true
+  });
+  const result = await thread.run(input.prompt);
+  if (input.streamOutput && result.finalResponse) {
+    process.stdout.write(result.finalResponse);
+  }
+  return { exitCode: 0, stdout: result.finalResponse, stderr: "" };
+}
+async function runCopilotSdk(input) {
+  const { CopilotClient, approveAll } = await import("@github/copilot-sdk");
+  const client = new CopilotClient({
+    cwd: input.rootDir,
+    logLevel: "error"
+  });
+  try {
+    await client.start();
+    const session = await client.createSession({
+      clientName: "amistio-cli",
+      model: input.model ?? process.env.AMISTIO_COPILOT_MODEL ?? "gpt-5",
+      workingDirectory: input.rootDir,
+      enableConfigDiscovery: true,
+      streaming: input.streamOutput,
+      onPermissionRequest: approveAll
     });
-    const sessionTelemetry = {
-        sessionPolicy: sessionContext.policy,
-        sessionDecision: sessionContext.decision,
-        sessionDecisionReason: sessionContext.reason,
-        ...(updatedToolSession ? { toolSessionId: updatedToolSession.toolSessionId } : {}),
-        ...(updatedToolSession?.sessionGroupKey ? { sessionGroupKey: updatedToolSession.sessionGroupKey } : {})
+    try {
+      let streamedOutput = "";
+      const unsubscribe = input.streamOutput ? session.on("assistant.message_delta", (event) => {
+        streamedOutput += event.data.deltaContent;
+        process.stdout.write(event.data.deltaContent);
+      }) : void 0;
+      try {
+        const response = await session.sendAndWait({ prompt: input.prompt }, 10 * 60 * 1e3);
+        const stdout = response?.data.content ?? streamedOutput;
+        return { exitCode: 0, stdout, stderr: "" };
+      } finally {
+        unsubscribe?.();
+      }
+    } finally {
+      await session.disconnect();
+    }
+  } finally {
+    await client.stop();
+  }
+}
+function extractTextParts(parts) {
+  if (!Array.isArray(parts)) {
+    return "";
+  }
+  return parts.filter(isRecord).map((part) => part.type === "text" && typeof part.text === "string" ? part.text : "").filter(Boolean).join("\n");
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+// src/runner-daemon.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { openSync } from "node:fs";
+import { mkdir as mkdir5, readdir as readdir2, readFile as readFile3, writeFile as writeFile5 } from "node:fs/promises";
+import os3 from "node:os";
+import path6 from "node:path";
+function currentRunnerMode() {
+  return process.env.AMISTIO_RUNNER_MODE === "background" ? "background" : "foreground";
+}
+function defaultRunnerMetadataDir() {
+  return path6.join(os3.homedir(), ".config", "amistio", "runners");
+}
+async function startRunnerDaemon(input) {
+  const metadataDir = input.metadataDir ?? defaultRunnerMetadataDir();
+  const existing = await readRunnerDaemonMetadata(input, metadataDir);
+  if (existing?.status === "running" && isProcessRunning(existing.pid)) {
+    throw new Error(`Background runner ${existing.runnerId} is already running with PID ${existing.pid}.`);
+  }
+  await mkdir5(metadataDir, { recursive: true });
+  const logPath = path6.join(metadataDir, `${runnerDaemonKey(input)}.log`);
+  const logFd = openSync(logPath, "a");
+  const child = spawn2(input.executablePath ?? process.execPath, [input.scriptPath ?? process.argv[1], ...input.args], {
+    cwd: input.rootDir,
+    detached: true,
+    env: {
+      ...process.env,
+      AMISTIO_RUNNER_MODE: "background"
+    },
+    stdio: ["ignore", logFd, logFd]
+  });
+  if (!child.pid) {
+    throw new Error("Failed to start background runner process.");
+  }
+  child.unref();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const metadata = {
+    schemaVersion: 1,
+    accountId: input.accountId,
+    projectId: input.projectId,
+    repositoryLinkId: input.repositoryLinkId,
+    runnerId: input.runnerId,
+    rootDir: path6.resolve(input.rootDir),
+    apiUrl: input.apiUrl,
+    pid: child.pid,
+    status: "running",
+    startedAt: now,
+    updatedAt: now,
+    hostname: os3.hostname(),
+    logPath
+  };
+  await writeRunnerDaemonMetadata(metadata, metadataDir);
+  return metadata;
+}
+async function restartRunnerDaemonProcess(metadata, args, input = {}) {
+  const metadataDir = input.metadataDir ?? defaultRunnerMetadataDir();
+  await mkdir5(metadataDir, { recursive: true });
+  const logPath = metadata.logPath ?? path6.join(metadataDir, `${runnerDaemonKey(metadata)}.log`);
+  const logFd = openSync(logPath, "a");
+  const child = spawn2(input.executablePath ?? process.execPath, [input.scriptPath ?? process.argv[1], ...args], {
+    cwd: metadata.rootDir,
+    detached: true,
+    env: {
+      ...process.env,
+      AMISTIO_RUNNER_MODE: "background"
+    },
+    stdio: ["ignore", logFd, logFd]
+  });
+  if (!child.pid) {
+    throw new Error("Failed to start replacement background runner process.");
+  }
+  child.unref();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const replacement = {
+    ...metadata,
+    pid: child.pid,
+    status: "running",
+    startedAt: now,
+    updatedAt: now,
+    hostname: os3.hostname(),
+    logPath
+  };
+  await writeRunnerDaemonMetadata(replacement, metadataDir);
+  return replacement;
+}
+async function listRunnerDaemonMetadata(input, metadataDir = defaultRunnerMetadataDir()) {
+  let entries;
+  try {
+    entries = await readdir2(metadataDir);
+  } catch {
+    return [];
+  }
+  const records = await Promise.all(
+    entries.filter((entry) => entry.endsWith(".json")).map(async (entry) => readRunnerDaemonMetadataFile(path6.join(metadataDir, entry)))
+  );
+  return records.filter((record) => Boolean(record)).filter((record) => record.accountId === input.accountId && record.projectId === input.projectId && record.repositoryLinkId === input.repositoryLinkId).filter((record) => !input.runnerId || record.runnerId === input.runnerId).sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt));
+}
+async function readRunnerDaemonMetadata(input, metadataDir = defaultRunnerMetadataDir()) {
+  return readRunnerDaemonMetadataFile(runnerDaemonMetadataPath(input, metadataDir));
+}
+async function writeRunnerDaemonMetadata(metadata, metadataDir = defaultRunnerMetadataDir()) {
+  await mkdir5(metadataDir, { recursive: true });
+  await writeFile5(runnerDaemonMetadataPath(metadata, metadataDir), JSON.stringify(metadata, null, 2), { encoding: "utf8", mode: 384 });
+}
+async function markRunnerDaemonStopped(metadata, metadataDir = defaultRunnerMetadataDir()) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const stopped = {
+    ...metadata,
+    status: "stopped",
+    stoppedAt: now,
+    updatedAt: now
+  };
+  await writeRunnerDaemonMetadata(stopped, metadataDir);
+  return stopped;
+}
+async function stopRunnerDaemonProcess(metadata) {
+  if (!isProcessRunning(metadata.pid)) {
+    return "not-running";
+  }
+  process.kill(metadata.pid, "SIGTERM");
+  for (let attempt = 0; attempt < 30; attempt += 1) {
+    if (!isProcessRunning(metadata.pid)) {
+      return "stopped";
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return isProcessRunning(metadata.pid) ? "not-running" : "stopped";
+}
+function isProcessRunning(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    const code = typeof error === "object" && error && "code" in error ? error.code : void 0;
+    return code === "EPERM";
+  }
+}
+function runnerDaemonRuntimeStatus(metadata) {
+  if (metadata.status === "stopped") {
+    return "stopped";
+  }
+  return isProcessRunning(metadata.pid) ? "running" : "stale";
+}
+function runnerDaemonUptime(metadata, now = Date.now()) {
+  const startedAt = Date.parse(metadata.startedAt);
+  if (!Number.isFinite(startedAt)) {
+    return "unknown";
+  }
+  const totalSeconds = Math.max(0, Math.floor((now - startedAt) / 1e3));
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) {
+    return `${hours}h ${minutes}m`;
+  }
+  if (minutes > 0) {
+    return `${minutes}m ${seconds}s`;
+  }
+  return `${seconds}s`;
+}
+function runnerDaemonMetadataPath(input, metadataDir) {
+  return path6.join(metadataDir, `${runnerDaemonKey(input)}.json`);
+}
+function runnerDaemonKey(input) {
+  return createHash2("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.runnerId}`).digest("hex");
+}
+async function readRunnerDaemonMetadataFile(filePath) {
+  try {
+    const parsed = JSON.parse(await readFile3(filePath, "utf8"));
+    if (parsed.schemaVersion !== 1 || !parsed.runnerId || !parsed.projectId || !parsed.repositoryLinkId) {
+      return void 0;
+    }
+    return parsed;
+  } catch {
+    return void 0;
+  }
+}
+
+// src/session-policy.ts
+var maxIdleMs = 24 * 60 * 60 * 1e3;
+var maxTotalMs = 7 * 24 * 60 * 60 * 1e3;
+var maxMessageCount = 80;
+var maxEstimatedTokens = 12e4;
+var maxCostUsd = 25;
+var relatednessThreshold = 20;
+function normalizeSessionPolicy(value) {
+  if (!value || value === "auto" || value === "new" || value === "none") {
+    return value ?? "auto";
+  }
+  if (/^continue:[A-Za-z0-9_.:-]+$/.test(value)) {
+    return value;
+  }
+  throw new Error(`Unsupported session policy: ${value}. Use auto, new, continue:<toolSessionId>, or none.`);
+}
+function selectToolSession(input) {
+  if (input.policy === "none") {
+    return { policy: input.policy, decision: "skipped", reason: "Session reuse was disabled for this run." };
+  }
+  if (!input.supportsSessionReuse) {
+    return {
+      policy: input.policy,
+      decision: "notSupported",
+      reason: `${input.toolName} does not expose reusable provider sessions; Amistio will record this as a one-shot tool session.`
     };
-    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 } : {})
+  }
+  if (input.policy === "new") {
+    return { policy: input.policy, decision: "forcedNew", reason: "The user requested a fresh tool session." };
+  }
+  const forcedSessionId = forcedContinueSessionId(input.policy);
+  if (forcedSessionId) {
+    const forced = input.sessions.find((session) => session.toolSessionId === forcedSessionId);
+    if (!forced) {
+      return { policy: input.policy, decision: "forcedNew", reason: `Requested session ${forcedSessionId} was not found; creating a fresh session.` };
+    }
+    const ineligibleReason = sessionIneligibleReason(forced, input, input.now ?? /* @__PURE__ */ new Date());
+    if (ineligibleReason) {
+      return { policy: input.policy, decision: "forcedNew", reason: `Requested session ${forcedSessionId} cannot be resumed: ${ineligibleReason}` };
+    }
+    return { policy: input.policy, decision: "forcedContinue", reason: `The user requested session ${forcedSessionId}.`, toolSession: forced };
+  }
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const candidates = input.sessions.map((session) => ({ session, ineligibleReason: sessionIneligibleReason(session, input, now), score: relatednessScore(session, input.workItem) })).filter((candidate) => !candidate.ineligibleReason).sort((a, b) => b.score - a.score || Date.parse(b.session.lastActivityAt) - Date.parse(a.session.lastActivityAt));
+  const best = candidates[0];
+  if (!best || best.score < relatednessThreshold) {
+    return {
+      policy: input.policy,
+      decision: "created",
+      reason: best ? `Best related session score ${best.score} was below ${relatednessThreshold}; creating a fresh session.` : "No eligible related session was found."
+    };
+  }
+  return {
+    policy: input.policy,
+    decision: "continued",
+    reason: `Reusing ${best.session.toolSessionId}; relatedness score ${best.score}.`,
+    toolSession: best.session
+  };
+}
+function forcedContinueSessionId(policy) {
+  return typeof policy === "string" && policy.startsWith("continue:") ? policy.slice("continue:".length) : void 0;
+}
+function sessionIneligibleReason(session, input, now) {
+  if (session.tool !== input.toolName) {
+    return `tool mismatch (${session.tool} != ${input.toolName})`;
+  }
+  if (session.repositoryLinkId && session.repositoryLinkId !== input.repositoryLinkId) {
+    return "repository link mismatch";
+  }
+  if (session.resumabilityScope === "localMachine" && session.runnerId && session.runnerId !== input.runnerId) {
+    return "session is scoped to another runner machine";
+  }
+  if (session.status === "closed" || session.status === "archived" || session.status === "blocked" || session.status === "unavailable") {
+    return `session is ${session.status}`;
+  }
+  if (Date.parse(session.lastActivityAt) + maxIdleMs < now.getTime()) {
+    return "session is idle past the reuse window";
+  }
+  if (Date.parse(session.createdAt) + maxTotalMs < now.getTime()) {
+    return "session is older than the reuse window";
+  }
+  if ((session.messageCount ?? 0) >= maxMessageCount) {
+    return "session message count is too high";
+  }
+  if ((session.estimatedInputTokens ?? 0) + (session.estimatedOutputTokens ?? 0) >= maxEstimatedTokens) {
+    return "session token estimate is too high";
+  }
+  if ((session.costUsd ?? 0) >= maxCostUsd) {
+    return "session cost is too high";
+  }
+  return void 0;
+}
+function relatednessScore(session, workItem) {
+  let score = 0;
+  if (session.sessionGroupKey && workItem.sessionGroupKey && session.sessionGroupKey === workItem.sessionGroupKey) {
+    score += 60;
+  }
+  if (session.lastWorkItemId && session.lastWorkItemId === workItem.workItemId) {
+    score += 40;
+  }
+  const titleOverlap = tokenOverlap(session.title, workItem.title);
+  score += titleOverlap * 8;
+  if (session.summary) {
+    score += tokenOverlap(session.summary, workItem.title) * 4;
+  }
+  for (const tag of session.tags) {
+    if (workItem.title.toLowerCase().includes(tag.toLowerCase())) {
+      score += 10;
+    }
+  }
+  return score;
+}
+function tokenOverlap(firstValue, secondValue) {
+  const firstTokens = new Set(tokens(firstValue));
+  return tokens(secondValue).filter((token) => firstTokens.has(token)).length;
+}
+function tokens(value) {
+  return value.toLowerCase().split(/[^a-z0-9]+/).filter((token) => token.length >= 4);
+}
+
+// src/sync.ts
+import { mkdir as mkdir6, readdir as readdir3, readFile as readFile4, stat as stat3, writeFile as writeFile6 } from "node:fs/promises";
+import path7 from "node:path";
+var syncRoots = ["architecture", "context", "decisions", "features", "memory", "plans", "prompts", "workflows"];
+async function collectSyncStatus(rootDir, webDocuments = []) {
+  const localDocuments = await readLocalSyncedDocuments(rootDir);
+  const webByDocumentId = new Map(webDocuments.map((document) => [document.documentId, document]));
+  const pullableWebDocuments = webDocuments.filter((document) => document.status === "approved" || document.syncState === "approved" || document.syncState === "synced");
+  const localByDocumentId = new Map(localDocuments.map((document) => [document.frontmatter.amistioDocumentId, document]));
+  const items = [];
+  for (const localDocument of localDocuments) {
+    const webDocument = webByDocumentId.get(localDocument.frontmatter.amistioDocumentId);
+    const localDirty = localDocument.contentHash !== localDocument.frontmatter.amistioContentHash;
+    const webHash = webDocument?.contentHash;
+    const decision = decideSyncState({
+      lastSyncedHash: localDocument.frontmatter.amistioContentHash,
+      repoHash: localDocument.contentHash,
+      ...webHash ? { webHash } : {}
     });
-    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", CLI_VERSION);
-    console.error(generationError ?? "Local runner generation failed.");
-    return { status: "failed", exitCode: toolResult.exitCode || 1 };
+    if (decision === "conflict") {
+      items.push({
+        repoPath: localDocument.repoPath,
+        documentId: localDocument.frontmatter.amistioDocumentId,
+        status: "conflicted",
+        reason: "web and repository revisions both changed"
+      });
+    } else if (localDirty || decision === "pushRepo") {
+      items.push({
+        repoPath: localDocument.repoPath,
+        documentId: localDocument.frontmatter.amistioDocumentId,
+        status: "dirty",
+        reason: "repository content changed since last synced hash"
+      });
+    } else if (decision === "pullWeb") {
+      items.push({
+        repoPath: localDocument.repoPath,
+        documentId: localDocument.frontmatter.amistioDocumentId,
+        status: "pending",
+        reason: "approved web revision is newer"
+      });
+    } else if (localDocument.frontmatter.status && !["approved", "synced"].includes(localDocument.frontmatter.status)) {
+      items.push({
+        repoPath: localDocument.repoPath,
+        documentId: localDocument.frontmatter.amistioDocumentId,
+        status: "pending",
+        reason: `local document is ${localDocument.frontmatter.status}`
+      });
+    } else {
+      items.push({
+        repoPath: localDocument.repoPath,
+        documentId: localDocument.frontmatter.amistioDocumentId,
+        status: "clean",
+        reason: "repository and web hashes match"
+      });
+    }
+  }
+  for (const webDocument of pullableWebDocuments) {
+    if (!localByDocumentId.has(webDocument.documentId)) {
+      items.push({
+        repoPath: webDocument.repoPath,
+        documentId: webDocument.documentId,
+        status: "pending",
+        reason: "approved web document has not been pulled"
+      });
+    }
+  }
+  const counts = {
+    clean: items.filter((item) => item.status === "clean").length,
+    pending: items.filter((item) => item.status === "pending").length,
+    dirty: items.filter((item) => item.status === "dirty").length,
+    conflicted: items.filter((item) => item.status === "conflicted").length
+  };
+  const status = counts.conflicted ? "conflicted" : counts.dirty ? "dirty" : counts.pending ? "pending" : "clean";
+  return { status, items, counts };
 }
-async function loadPairedApiContext(root, apiUrl) {
-    const metadata = await readProjectLink(root);
-    if (!metadata) {
-        return undefined;
+async function readLocalSyncedDocuments(rootDir) {
+  const markdownFiles = await findMarkdownFiles(rootDir);
+  const documents = [];
+  for (const fullPath of markdownFiles) {
+    const raw = await readFile4(fullPath, "utf8");
+    const parsed = parseSyncedMarkdown(raw);
+    if (!parsed) {
+      continue;
+    }
+    documents.push({
+      fullPath,
+      repoPath: toRepoPath(rootDir, fullPath),
+      frontmatter: parsed.frontmatter,
+      content: parsed.content,
+      contentHash: sha256ContentHash(parsed.content)
+    });
+  }
+  return documents;
+}
+async function materializeBrainDocuments(rootDir, documents, options = {}) {
+  const result = { written: [], skipped: [], conflicts: [] };
+  for (const inputDocument of documents) {
+    const document = brainDocumentItemSchema.parse(inputDocument);
+    const fullPath = safeRepoPath(rootDir, document.repoPath);
+    if (!isControlPlanePath(document.repoPath)) {
+      result.conflicts.push(`${document.repoPath}: refusing to write outside root control-plane folders`);
+      continue;
+    }
+    const existing = await readExistingSyncedDocument(fullPath);
+    if (existing.exists && !existing.document) {
+      result.conflicts.push(`${document.repoPath}: file exists without Amistio document metadata`);
+      continue;
+    }
+    if (existing.document && existing.document.frontmatter.amistioDocumentId !== document.documentId) {
+      result.conflicts.push(`${document.repoPath}: file belongs to ${existing.document.frontmatter.amistioDocumentId}`);
+      continue;
+    }
+    if (existing.document && existing.document.contentHash !== existing.document.frontmatter.amistioContentHash && !options.allowDirtyOverwrite) {
+      result.conflicts.push(`${document.repoPath}: local edits would be overwritten`);
+      continue;
+    }
+    if (existing.document && existing.document.frontmatter.amistioRevision >= document.revision && existing.document.contentHash === document.contentHash) {
+      result.skipped.push(document.repoPath);
+      continue;
+    }
+    await mkdir6(path7.dirname(fullPath), { recursive: true });
+    await writeFile6(fullPath, createSyncedDocumentMarkdown(document), "utf8");
+    result.written.push(document.repoPath);
+  }
+  return result;
+}
+async function collectDirtyDocumentsForPush(rootDir, metadata) {
+  const localDocuments = await readLocalSyncedDocuments(rootDir);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return localDocuments.filter((document) => document.contentHash !== document.frontmatter.amistioContentHash).map((document) => {
+    const documentType = documentTypeSchema.parse(document.frontmatter.amistioDocumentType);
+    return brainDocumentItemSchema.parse({
+      id: document.frontmatter.amistioDocumentId,
+      type: "brainDocument",
+      schemaVersion: 1,
+      accountId: metadata.amistioAccountId,
+      projectId: metadata.amistioProjectId,
+      documentId: document.frontmatter.amistioDocumentId,
+      documentType,
+      title: inferTitle(document.content, document.repoPath),
+      status: "reviewing",
+      repoPath: document.repoPath,
+      content: document.content,
+      contentHash: document.contentHash,
+      frontmatter: parseFrontmatterFromSyncedDocument(document.frontmatter),
+      revision: document.frontmatter.amistioRevision + 1,
+      source: "repo",
+      syncState: "dirtyInRepo",
+      createdAt: now,
+      updatedAt: now
+    });
+  });
+}
+function createSyncedDocumentMarkdown(document) {
+  return [
+    "---",
+    `amistioDocumentId: ${document.documentId}`,
+    `amistioDocumentType: ${document.documentType}`,
+    `amistioRevision: ${document.revision}`,
+    `amistioContentHash: ${document.contentHash}`,
+    `status: ${document.status}`,
+    "---",
+    document.content,
+    ""
+  ].join("\n");
+}
+function parseSyncedMarkdown(content) {
+  const rawFrontmatter = parseFrontmatter(content);
+  const frontmatter = syncedDocumentFrontmatterSchema.safeParse(rawFrontmatter);
+  if (!frontmatter.success) {
+    return void 0;
+  }
+  const closingMarker = content.indexOf("\n---", 4);
+  if (closingMarker === -1) {
+    return void 0;
+  }
+  const closingLineEnd = content.indexOf("\n", closingMarker + 4);
+  const bodyStart = closingLineEnd === -1 ? content.length : closingLineEnd + 1;
+  return { frontmatter: frontmatter.data, content: content.slice(bodyStart).replace(/\n$/, "") };
+}
+async function readExistingSyncedDocument(fullPath) {
+  try {
+    const raw = await readFile4(fullPath, "utf8");
+    const parsed = parseSyncedMarkdown(raw);
+    if (!parsed) {
+      return { exists: true };
     }
-    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 } : {})
-        })
+      exists: true,
+      document: {
+        fullPath,
+        repoPath: fullPath,
+        frontmatter: parsed.frontmatter,
+        content: parsed.content,
+        contentHash: sha256ContentHash(parsed.content)
+      }
     };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { exists: false };
+    }
+    throw error;
+  }
 }
-function selectPromptWorkItem(workItems, workItemId) {
-    if (workItemId) {
-        return workItems.find((item) => item.workItemId === workItemId || item.id === workItemId);
+async function findMarkdownFiles(rootDir) {
+  const files = [];
+  for (const syncRoot of syncRoots) {
+    const fullRoot = path7.join(rootDir, syncRoot);
+    if (!await exists2(fullRoot)) {
+      continue;
     }
-    return workItems.find((item) => isPromptReadyStatus(item.status));
+    await walkMarkdownFiles(fullRoot, files);
+  }
+  return files;
 }
-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
+async function walkMarkdownFiles(directory, files) {
+  for (const entry of await readdir3(directory, { withFileTypes: true })) {
+    const fullPath = path7.join(directory, entry.name);
+    if (entry.isDirectory()) {
+      await walkMarkdownFiles(fullPath, files);
+    } else if (entry.isFile() && entry.name.endsWith(".md")) {
+      files.push(fullPath);
+    }
+  }
+}
+function safeRepoPath(rootDir, repoPath) {
+  if (path7.isAbsolute(repoPath)) {
+    throw new Error(`Refusing to use absolute repo path: ${repoPath}`);
+  }
+  const normalized = path7.normalize(repoPath);
+  if (normalized === ".." || normalized.startsWith(`..${path7.sep}`)) {
+    throw new Error(`Refusing to use path outside the repository: ${repoPath}`);
+  }
+  const root = path7.resolve(rootDir);
+  const fullPath = path7.resolve(root, normalized);
+  if (!fullPath.startsWith(`${root}${path7.sep}`)) {
+    throw new Error(`Refusing to use path outside the repository: ${repoPath}`);
+  }
+  return fullPath;
+}
+function isControlPlanePath(repoPath) {
+  const normalized = path7.normalize(repoPath);
+  return syncRoots.some((syncRoot) => normalized === syncRoot || normalized.startsWith(`${syncRoot}${path7.sep}`));
+}
+function toRepoPath(rootDir, fullPath) {
+  return path7.relative(rootDir, fullPath).split(path7.sep).join("/");
+}
+function inferTitle(content, repoPath) {
+  const heading = content.split("\n").find((line) => line.startsWith("# "))?.replace(/^#\s+/, "").trim();
+  return heading || path7.basename(repoPath, path7.extname(repoPath));
+}
+function parseFrontmatterFromSyncedDocument(frontmatter) {
+  return {
+    amistioDocumentId: frontmatter.amistioDocumentId,
+    amistioDocumentType: frontmatter.amistioDocumentType,
+    amistioRevision: frontmatter.amistioRevision,
+    amistioContentHash: frontmatter.amistioContentHash,
+    ...frontmatter.status ? { status: frontmatter.status } : {}
+  };
+}
+async function exists2(filePath) {
+  try {
+    await stat3(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/tool-session-store.ts
+import { mkdir as mkdir7, readFile as readFile5, writeFile as writeFile7 } from "node:fs/promises";
+import os4 from "node:os";
+import path8 from "node:path";
+var LocalToolSessionStore = class {
+  constructor(filePath = defaultSessionStorePath()) {
+    this.filePath = filePath;
+  }
+  filePath;
+  async getProviderSessionId(toolSessionId, toolName) {
+    const data = await this.read();
+    const record = data[toolSessionId];
+    return record?.toolName === toolName ? record.providerSessionId : void 0;
+  }
+  async setProviderSessionId(toolSessionId, toolName, providerSessionId) {
+    const data = await this.read();
+    data[toolSessionId] = { toolName, providerSessionId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    await mkdir7(path8.dirname(this.filePath), { recursive: true });
+    await writeFile7(this.filePath, JSON.stringify(data, null, 2), "utf8");
+  }
+  async read() {
+    try {
+      return JSON.parse(await readFile5(this.filePath, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+};
+function defaultSessionStorePath() {
+  if (process.platform === "darwin") {
+    return path8.join(os4.homedir(), "Library", "Application Support", "Amistio", "tool-sessions.json");
+  }
+  if (process.platform === "win32") {
+    return path8.join(process.env.APPDATA ?? os4.homedir(), "Amistio", "tool-sessions.json");
+  }
+  return path8.join(process.env.XDG_STATE_HOME ?? path8.join(os4.homedir(), ".local", "state"), "amistio", "tool-sessions.json");
+}
+
+// src/work-runner.ts
+var generationResultStart = "AMISTIO_BRAIN_GENERATION_RESULT_START";
+var generationResultEnd = "AMISTIO_BRAIN_GENERATION_RESULT_END";
+function createWorkExecutionPrompt(workItem, context) {
+  if (workItem.workKind === "brainGeneration") {
+    return createBrainGenerationPrompt(workItem);
+  }
+  if (workItem.workKind === "planRevision") {
+    return createPlanRevisionPrompt(workItem, context?.planRevision);
+  }
+  return [
+    "# Amistio Work Execution",
+    "",
+    "You are running locally through the Amistio CLI inside the user's repository.",
+    "Execute the approved work item below using the repository's existing orchestration files, instructions, and constraints.",
+    "",
+    "## Work Item",
+    "",
+    `Title: ${workItem.title}`,
+    `Work item ID: ${workItem.workItemId}`,
+    `Project ID: ${workItem.projectId}`,
+    "",
+    "## Rules",
+    "",
+    "- Read AGENTS.md first when it exists.",
+    "- Read the relevant root control-plane files before implementation so the work stays aligned with existing direction.",
+    "- Keep changes focused on this work item.",
+    "- Preserve old decisions, plans, memory, and prompts unless the work item explicitly supersedes them.",
+    "- Do not commit changes.",
+    "- Do not write secrets into the repository.",
+    "- Do not create a repo-local .amistio folder.",
+    "- Run relevant verification commands when feasible and summarize results."
+  ].join("\n");
+}
+function createPlanRevisionPrompt(workItem, context) {
+  const messages = context?.messages ?? [];
+  return [
+    "# Amistio Plan Revision",
+    "",
+    "You are running locally through the Amistio CLI inside the user's repository.",
+    "Revise the selected generated plan using the user's conversation. Do not implement product/source code changes in this pass.",
+    "",
+    "## Work Item",
+    "",
+    `Title: ${workItem.title}`,
+    `Work item ID: ${workItem.workItemId}`,
+    `Project ID: ${workItem.projectId}`,
+    `Document ID: ${workItem.reviewDocumentId ?? "unknown"}`,
+    `Document revision: ${workItem.reviewDocumentRevision ?? "unknown"}`,
+    "",
+    "## Current Plan",
+    "",
+    context?.planDocument.content ?? "The current plan document could not be loaded. Explain the blocker in the result summary.",
+    "",
+    "## Conversation",
+    "",
+    messages.length ? messages.map((message) => `- ${message.role} / ${message.intent} / ${message.status} / rev ${message.documentRevision}: ${message.content}`).join("\n") : "No conversation messages were loaded.",
+    "",
+    "## Output Contract",
+    "",
+    "Print exactly one JSON object between the markers below with an artifacts array containing one revised plan artifact.",
+    'The artifact must use documentType "plan", keep the plan under plans/, and include the complete revised plan content.',
+    "",
+    generationResultStart,
+    '{"artifacts":[{"documentType":"plan","title":"Revised Plan","repoPath":"plans/PLAN-revised.md","content":"# Revised Plan\\n\\n## Goal\\n..."}]}',
+    generationResultEnd,
+    "",
+    "Do not put Markdown fences around the markers. Do not claim implementation is complete."
+  ].join("\n");
+}
+function parseBrainGenerationArtifacts(output) {
+  const start = output.indexOf(generationResultStart);
+  const end = output.indexOf(generationResultEnd, start + generationResultStart.length);
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error("Local AI generation did not return an Amistio brain generation result block.");
+  }
+  const payload = output.slice(start + generationResultStart.length, end).trim();
+  const parsed = JSON.parse(stripJsonFence(payload));
+  return brainGenerationResultSchema.parse(parsed).artifacts;
+}
+function createBrainGenerationPrompt(workItem) {
+  const wish = workItem.sourceWish ?? workItem.title;
+  return [
+    "# Amistio Brain Generation",
+    "",
+    "You are running locally through the Amistio CLI inside the user's repository.",
+    "Generate reviewable project-brain artifacts from the submitted wish. Do not implement product/source code changes in this pass.",
+    "",
+    "## Submitted Wish",
+    "",
+    wish,
+    "",
+    "## Work Item",
+    "",
+    `Title: ${workItem.title}`,
+    `Work item ID: ${workItem.workItemId}`,
+    `Project ID: ${workItem.projectId}`,
+    `Generated draft ID: ${workItem.generatedDraftId ?? "unknown"}`,
+    "",
+    "## Read First",
+    "",
+    "- Read AGENTS.md first when it exists.",
+    "- Read relevant files under architecture/, context/, decisions/, features/, memory/, plans/, prompts/, and workflows/ before drafting.",
+    "- Keep source code and secrets local. Do not include source-code payloads, access tokens, API keys, local credential paths, or provider session references in the result.",
+    "",
+    "## Generate Artifacts",
+    "",
+    "Return Markdown artifacts that should enter human review before implementation. Use only these document types and matching repo roots:",
+    "",
+    "- architecture -> architecture/",
+    "- context -> context/",
+    "- decision -> decisions/",
+    "- feature -> features/",
+    "- memory -> memory/",
+    "- plan -> plans/",
+    "- prompt -> prompts/",
+    "- workflow -> workflows/",
+    "",
+    "Each artifact needs documentType, title, repoPath, and content. Include at least a plan and an implementation prompt when implementation work is implied. Use model-agnostic prompt wording.",
+    "",
+    "## Output Contract",
+    "",
+    "Print exactly one JSON object between the markers below. The CLI will submit only this structured result back to Amistio.",
+    "",
+    generationResultStart,
+    '{"artifacts":[{"documentType":"plan","title":"Plan: Example","repoPath":"plans/PLAN-example.md","content":"# Plan: Example\\n\\n## Goal\\n..."}]}',
+    generationResultEnd,
+    "",
+    "Do not put Markdown fences around the markers. Do not claim implementation is complete."
+  ].join("\n");
+}
+function stripJsonFence(value) {
+  const trimmed = value.trim();
+  if (!trimmed.startsWith("```")) {
+    return trimmed;
+  }
+  return trimmed.replace(/^```(?:json)?\s*/i, "").replace(/```$/i, "").trim();
+}
+
+// src/runner-status.ts
+var watchStateReminderMs = 60 * 1e3;
+function formatWatchStartupContext(input) {
+  return [
+    `Runner ${input.runnerId} is watching project ${input.projectId}.`,
+    `Repository link: ${input.repositoryLinkId}`,
+    `API: ${input.apiUrl}`,
+    `Polling interval: ${input.intervalSeconds}s. Press Ctrl+C to stop.`
+  ];
+}
+function formatWatchIdleLine(action, intervalSeconds) {
+  return `${formatProjectNextAction(action)} Checking again in ${intervalSeconds}s.`;
+}
+function shouldPrintWatchState(action, previous, nowMs, reminderMs = watchStateReminderMs) {
+  const key = watchStateKey(action);
+  return !previous || previous.key !== key || nowMs - previous.printedAtMs >= reminderMs;
+}
+function watchStateKey(action) {
+  return [action.kind, action.message, action.workItemId, action.documentId, action.runnerId].filter(Boolean).join(":");
+}
+
+// src/index.ts
+var program = new Command();
+var defaultRoot = process.env.INIT_CWD ?? process.cwd();
+var apiUrlOptionDescription = `Amistio API URL override (or ${AMISTIO_API_URL_ENV})`;
+program.name("amistio").description("Amistio project brain CLI").version("0.1.2");
+var CLI_VERSION = "0.1.2";
+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
     });
-    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 } : {})
+    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}.`);
+});
+var 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.`);
+});
+var 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 }, { documents }, { runners }] = await Promise.all([
+    context.client.listWorkItems(context.metadata.amistioProjectId),
+    context.client.listBrainDocuments(context.metadata.amistioProjectId),
+    context.client.listRunners(context.metadata.amistioProjectId).catch(() => ({ runners: [] }))
+  ]);
+  const nextAction = computeProjectNextAction({
+    projectId: context.metadata.amistioProjectId,
+    repositoryLinks: [createCliRepositoryLink(context.metadata, options.root)],
+    documents,
+    workItems,
+    runnerHeartbeats: runners
+  });
+  console.log(`Next action: ${formatProjectNextAction(nextAction)}`);
+  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 writeFile8(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("--model <model>", "Model to request when the selected local tool supports model selection").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 } : {}, ...options.model ? { model: options.model } : {} });
+  console.log(`Running ${preview.toolName}: ${preview.displayCommand}`);
+  const result = await runLocalTool({
+    rootDir: options.root,
+    prompt,
+    tool: options.tool,
+    ...options.toolCommand ? { toolCommand: options.toolCommand } : {},
+    ...options.model ? { model: options.model } : {},
+    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").option("--model <model>", "Model to request when the selected local tool supports model selection").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("--background", "Start a detached background runner that watches for approved work").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, command) => {
+  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.background) {
+    if (options.dryRun) {
+      console.log("Background runners cannot be started in dry-run mode.");
+      process.exitCode = 1;
+      return;
+    }
+    const metadata = await startRunnerDaemon({
+      accountId: context.metadata.amistioAccountId,
+      projectId: context.metadata.amistioProjectId,
+      repositoryLinkId: context.metadata.repositoryLinkId,
+      runnerId: options.runnerId,
+      rootDir: path9.resolve(options.root),
+      apiUrl: options.apiUrl,
+      args: buildBackgroundRunnerArgs(options)
     });
-    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." } : {})
+    console.log(`Started background runner ${metadata.runnerId} with PID ${metadata.pid}.`);
+    if (metadata.logPath) {
+      console.log(`Log: ${metadata.logPath}`);
+    }
+    return;
+  }
+  if (options.watch) {
+    for (const line of formatWatchStartupContext({ runnerId: options.runnerId, projectId: context.metadata.amistioProjectId, repositoryLinkId: context.metadata.repositoryLinkId, apiUrl: options.apiUrl, intervalSeconds: options.intervalSeconds })) {
+      console.log(line);
+    }
+  }
+  let iterations = 0;
+  let lastWatchStateLog;
+  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),
+      ...command.getOptionValueSource("tool") === "cli" && options.tool ? { explicitTool: options.tool } : {},
+      ...command.getOptionValueSource("model") === "cli" && options.model ? { explicitModel: options.model } : {},
+      ...options.toolCommand ? { toolCommand: options.toolCommand } : {},
+      dryRun: Boolean(options.dryRun),
+      stream: options.stream,
+      commandContext: {
+        accountId: context.metadata.amistioAccountId,
+        apiUrl: options.apiUrl,
+        backgroundArgs: buildBackgroundRunnerArgs(options),
+        projectId: context.metadata.amistioProjectId,
+        repositoryLinkId: context.metadata.repositoryLinkId,
+        root: options.root,
+        runnerId: options.runnerId
+      },
+      suppressIdleOutput: Boolean(options.watch)
     });
-    return toolSession;
+    if (!options.watch || options.dryRun) {
+      if (result.exitCode !== 0) {
+        process.exitCode = result.exitCode;
+      }
+      return;
+    }
+    if (result.status === "idle" && result.nextAction) {
+      const nowMs = Date.now();
+      if (shouldPrintWatchState(result.nextAction, lastWatchStateLog, nowMs)) {
+        console.log(formatWatchIdleLine(result.nextAction, options.intervalSeconds));
+        lastWatchStateLog = { key: watchStateKey(result.nextAction), printedAtMs: nowMs };
+      }
+    }
+    if (result.stopRunner) {
+      return;
+    }
+    if (options.maxIterations !== void 0 && iterations >= options.maxIterations) {
+      console.log(`Runner stopped after ${iterations} polling attempt${iterations === 1 ? "" : "s"}.`);
+      return;
+    }
+    await delay(options.intervalSeconds * 1e3);
+  }
+});
+var runner = program.command("runner").description("Manage local Amistio runner processes");
+runner.command("status").description("Show background runner status for the paired repository").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--root <path>", "Repository root", defaultRoot).option("--runner-id <runnerId>", "Limit status to one runner ID").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 records = await listRunnerDaemonMetadata({
+    accountId: context.metadata.amistioAccountId,
+    projectId: context.metadata.amistioProjectId,
+    repositoryLinkId: context.metadata.repositoryLinkId,
+    ...options.runnerId ? { runnerId: options.runnerId } : {}
+  });
+  const runners = await context.client.listRunners(context.metadata.amistioProjectId).then((result) => result.runners).catch(() => []);
+  if (!records.length) {
+    console.log("No background runner metadata found for this paired repository.");
+    if (runners.length) {
+      console.log(`Last runner heartbeat: ${runners[0].runnerId} ${runners[0].status} at ${runners[0].lastSeenAt}.`);
+    }
+    return;
+  }
+  for (const record of records) {
+    const runtimeStatus = runnerDaemonRuntimeStatus(record);
+    const heartbeat = runners.find((item) => item.runnerId === record.runnerId);
+    console.log(`Runner ${record.runnerId}: ${runtimeStatus}`);
+    console.log(`  PID: ${record.pid}`);
+    console.log(`  Uptime: ${runtimeStatus === "running" ? runnerDaemonUptime(record) : "not running"}`);
+    console.log(`  Project: ${record.projectId}`);
+    console.log(`  Repository link: ${record.repositoryLinkId}`);
+    console.log(`  Root: ${record.rootDir}`);
+    console.log(`  API: ${record.apiUrl}`);
+    console.log(`  Host: ${record.hostname}`);
+    if (record.logPath) {
+      console.log(`  Log: ${record.logPath}`);
+    }
+    if (heartbeat) {
+      console.log(`  Last heartbeat: ${heartbeat.status} at ${heartbeat.lastSeenAt}${heartbeat.version ? ` (${heartbeat.version})` : ""}`);
+    }
+  }
+});
+runner.command("stop").description("Stop a background runner for the paired repository").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--root <path>", "Repository root", defaultRoot).option("--runner-id <runnerId>", "Runner ID to stop when multiple background runners exist").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 records = await listRunnerDaemonMetadata({
+    accountId: context.metadata.amistioAccountId,
+    projectId: context.metadata.amistioProjectId,
+    repositoryLinkId: context.metadata.repositoryLinkId,
+    ...options.runnerId ? { runnerId: options.runnerId } : {}
+  });
+  if (!records.length) {
+    console.log("No background runner metadata found for this paired repository.");
+    return;
+  }
+  if (records.length > 1 && !options.runnerId) {
+    console.log(`Multiple background runners found: ${records.map((record2) => record2.runnerId).join(", ")}. Pass --runner-id to stop one.`);
+    process.exitCode = 1;
+    return;
+  }
+  const record = records[0];
+  const stopResult = await stopRunnerDaemonProcess(record);
+  await markRunnerDaemonStopped(record);
+  await context.client.sendRunnerHeartbeat(context.metadata.amistioProjectId, record.runnerId, context.metadata.repositoryLinkId, "offline", {
+    version: CLI_VERSION,
+    mode: "background",
+    hostname: record.hostname
+  }).catch(() => void 0);
+  console.log(stopResult === "stopped" ? `Stopped background runner ${record.runnerId}.` : `Marked background runner ${record.runnerId} stopped; process was not running.`);
+});
+async function runNextWorkItem({
+  apiClient,
+  dryRun,
+  projectId,
+  repositoryLinkId,
+  root,
+  runnerId,
+  sessionPolicy,
+  stream,
+  explicitModel,
+  explicitTool,
+  toolCommand,
+  commandContext,
+  suppressIdleOutput
+}) {
+  const toolConfig = await resolveRunnerToolConfig({
+    apiClient,
+    projectId,
+    ...explicitModel ? { explicitModel } : {},
+    ...explicitTool ? { explicitTool } : {},
+    ...toolCommand ? { toolCommand } : {}
+  });
+  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, toolConfig.ready ? "online" : "blocked", runnerHeartbeatMetadata(toolConfig));
+  const commandResult = await runPendingRunnerCommand(apiClient, commandContext, runnerHeartbeatMetadata(toolConfig));
+  if (commandResult.handled) {
+    if (commandResult.message) {
+      console.log(commandResult.message);
+    }
+    return { status: commandResult.succeeded ? "completed" : "failed", exitCode: commandResult.succeeded ? 0 : 1, ...commandResult.stopRunner ? { stopRunner: true } : {} };
+  }
+  if (!toolConfig.ready) {
+    console.log(toolConfig.message);
+    return { status: "blocked", exitCode: 1 };
+  }
+  const result = await apiClient.claimWork(projectId, runnerId, repositoryLinkId);
+  if (!result.workItem) {
+    const nextAction = await loadProjectNextAction(apiClient, projectId, repositoryLinkId, root);
+    const message = formatProjectNextAction(nextAction);
+    if (!suppressIdleOutput) {
+      console.log(message);
+    }
+    return { status: "idle", exitCode: 0, nextAction, message };
+  }
+  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "running", runnerHeartbeatMetadata(toolConfig));
+  const prompt = await createRunnerWorkPrompt(apiClient, projectId, result.workItem);
+  if (dryRun || toolConfig.tool === "none") {
+    console.log(prompt);
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+    return { status: "preview", exitCode: 0 };
+  }
+  const preview = await createToolRunPreview({ rootDir: root, prompt, tool: toolConfig.tool, ...toolCommand ? { toolCommand } : {}, ...toolConfig.model ? { model: toolConfig.model } : {} });
+  const sessionContext = await prepareToolSession({
+    apiClient,
+    projectId,
+    repositoryLinkId,
+    runnerId,
+    sessionPolicy: result.workItem.sessionPolicy ?? sessionPolicy,
+    toolName: preview.toolName,
+    ...toolConfig.model ? { model: toolConfig.model } : {},
+    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) : void 0;
+  const toolResult = await runLocalTool({
+    rootDir: root,
+    prompt,
+    tool: toolConfig.tool,
+    ...toolCommand ? { toolCommand } : {},
+    ...toolConfig.model ? { model: toolConfig.model } : {},
+    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", runnerHeartbeatMetadata(toolConfig));
+    await markToolSessionBlocked(apiClient, projectId, sessionContext.toolSession, errorMessage2(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" || result.workItem.workKind === "planRevision") {
+    return finalizeBrainGenerationWork({
+      apiClient,
+      durationMs: Date.now() - startedAt,
+      projectId,
+      repositoryLinkId,
+      runnerId,
+      sessionContext,
+      toolConfig,
+      toolName: preview.toolName,
+      toolResult,
+      workItem: result.workItem
+    });
+  }
+  const finalStatus = toolResult.exitCode === 0 ? "completed" : "failed";
+  const durationMs = Date.now() - startedAt;
+  const failureExcerpt = toolResult.exitCode === 0 ? void 0 : 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 !== void 0 ? { messageCount: toolResult.messageCount } : {},
+    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
+    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
+    ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {}
+  });
+  const statusResult = await apiClient.updateWorkStatus(
+    projectId,
+    result.workItem.workItemId,
+    finalStatus,
+    `run_${result.workItem.workItemId}_${randomUUID()}`,
+    runnerId,
+    {
+      tool: preview.toolName,
+      ...toolResult.model ? { model: toolResult.model } : {},
+      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 !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
+      ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
+      ...toolResult.costUsd !== void 0 ? { costUsd: toolResult.costUsd } : {},
+      ...failureExcerpt ? { error: failureExcerpt } : {}
+    }
+  );
+  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+  const durationSeconds = Math.round(durationMs / 1e3);
+  console.log(`Marked ${statusResult.workItem.workItemId} ${statusResult.workItem.status} after ${durationSeconds}s.`);
+  return { status: finalStatus, exitCode: toolResult.exitCode };
 }
-async function markToolSessionBlocked(apiClient, projectId, session, reason) {
-    if (!session) {
-        return;
+async function runPendingRunnerCommand(apiClient, context, heartbeatMetadata) {
+  const { commands } = await apiClient.listRunnerCommands(context.projectId, context.runnerId, context.repositoryLinkId).catch(() => ({ commands: [] }));
+  const command = commands.filter((item) => item.status === "pending" || item.status === "acknowledged" || item.status === "running").sort((first, second) => Date.parse(first.createdAt) - Date.parse(second.createdAt))[0];
+  if (!command) {
+    return { handled: false, succeeded: true };
+  }
+  await updateRunnerCommandStatus(apiClient, context, command, "acknowledged", "Command acknowledged by local runner.");
+  await updateRunnerCommandStatus(apiClient, context, command, "running", `Running ${runnerCommandLabel(command.commandKind)} command.`);
+  const result = await executeRunnerCommand(command, context);
+  await updateRunnerCommandStatus(apiClient, context, command, result.succeeded ? "completed" : "failed", result.message, result.error);
+  if (command.commandKind === "remove" && result.succeeded) {
+    await new LocalCredentialStore().delete(credentialKey(context.accountId, context.projectId, context.repositoryLinkId));
+  }
+  if (result.stopRunner && command.commandKind === "remove") {
+    await apiClient.sendRunnerHeartbeat(context.projectId, context.runnerId, context.repositoryLinkId, "offline", heartbeatMetadata).catch(() => void 0);
+  }
+  return { handled: true, succeeded: result.succeeded, message: result.message, ...result.stopRunner ? { stopRunner: true } : {} };
+}
+async function updateRunnerCommandStatus(apiClient, context, command, status, message, error) {
+  const result = await apiClient.updateRunnerCommand(context.projectId, command.commandId, {
+    runnerId: context.runnerId,
+    repositoryLinkId: context.repositoryLinkId,
+    status,
+    idempotencyKey: `runner_command_${command.commandId}_${status}_${randomUUID()}`,
+    message,
+    ...error ? { error } : {}
+  });
+  return result.command;
+}
+async function executeRunnerCommand(command, context) {
+  if (command.commandKind === "remove") {
+    return { succeeded: true, stopRunner: true, message: "Runner credential revoked. This local runner will stop after removing its stored credential." };
+  }
+  if (command.commandKind === "restart") {
+    return restartCurrentRunner(context);
+  }
+  return runOfficialCliUpdate();
+}
+async function restartCurrentRunner(context) {
+  if (currentRunnerMode() !== "background") {
+    return { succeeded: false, message: "Foreground runners cannot be restarted remotely. Stop and start the local command manually." };
+  }
+  const [metadata] = await listRunnerDaemonMetadata({ accountId: context.accountId, projectId: context.projectId, repositoryLinkId: context.repositoryLinkId, runnerId: context.runnerId });
+  if (!metadata) {
+    return { succeeded: false, message: "Background runner metadata was not found, so restart needs manual action." };
+  }
+  try {
+    const replacement = await restartRunnerDaemonProcess(metadata, context.backgroundArgs);
+    return { succeeded: true, stopRunner: true, message: `Replacement background runner started with PID ${replacement.pid}.` };
+  } catch (error) {
+    return { succeeded: false, message: "Background restart failed.", error: errorMessage2(error) };
+  }
+}
+async function runOfficialCliUpdate() {
+  const result = await runOfficialUpdateProcess("npm", ["install", "-g", "@amistio/cli"], 12e4);
+  if (result.exitCode === 0) {
+    return { succeeded: true, message: "Official Amistio CLI update command completed." };
+  }
+  return { succeeded: false, message: "Official Amistio CLI update command failed.", error: result.output || `npm exited with code ${result.exitCode}.` };
+}
+function runOfficialUpdateProcess(command, args, timeoutMs) {
+  return new Promise((resolve) => {
+    const child = spawn3(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let output = "";
+    const timer = setTimeout(() => {
+      output += "Timed out while running official CLI update.\n";
+      child.kill("SIGTERM");
+    }, timeoutMs);
+    child.stdout?.on("data", (chunk) => {
+      output += chunk.toString("utf8");
+    });
+    child.stderr?.on("data", (chunk) => {
+      output += chunk.toString("utf8");
+    });
+    child.on("error", (error) => {
+      clearTimeout(timer);
+      resolve({ exitCode: 1, output: error.message });
+    });
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolve({ exitCode: code ?? 1, output: truncateLogExcerpt(output) });
+    });
+  });
+}
+function runnerCommandLabel(commandKind) {
+  if (commandKind === "update") return "update";
+  if (commandKind === "restart") return "restart";
+  return "remove";
+}
+async function finalizeBrainGenerationWork({
+  apiClient,
+  durationMs,
+  projectId,
+  repositoryLinkId,
+  runnerId,
+  sessionContext,
+  toolConfig,
+  toolName,
+  toolResult,
+  workItem
+}) {
+  let artifacts;
+  let generationError;
+  if (toolResult.exitCode === 0) {
+    try {
+      artifacts = parseBrainGenerationArtifacts(`${toolResult.stdout}
+${toolResult.stderr}`);
+    } catch (error) {
+      generationError = errorMessage2(error);
     }
-    await apiClient.updateToolSession(projectId, session.toolSessionId, {
-        status: "blocked",
-        summary: reason,
-        closedReason: reason
+  } 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 !== void 0 ? { messageCount: toolResult.messageCount } : {},
+    ...toolResult.tokensIn !== void 0 ? { tokensIn: toolResult.tokensIn } : {},
+    ...toolResult.tokensOut !== void 0 ? { tokensOut: toolResult.tokensOut } : {},
+    ...toolResult.costUsd !== void 0 ? { 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 completionMessage = workItem.workKind === "planRevision" ? `${toolName} returned a revised plan for review.` : `${toolName} generated ${artifacts.length} brain artifact${artifacts.length === 1 ? "" : "s"}.`;
+    const result = await apiClient.submitBrainGenerationResult(projectId, workItem.workItemId, {
+      status: "completed",
+      runnerId,
+      idempotencyKey: `generation_${workItem.workItemId}_${randomUUID()}`,
+      artifacts,
+      tool: toolName,
+      durationMs,
+      ...sessionTelemetry,
+      message: completionMessage
     });
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
+    console.log(workItem.workKind === "planRevision" ? "Revised plan returned for review." : `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", runnerHeartbeatMetadata(toolConfig));
+  console.error(generationError ?? "Local runner generation failed.");
+  return { status: "failed", exitCode: toolResult.exitCode || 1 };
+}
+async function createRunnerWorkPrompt(apiClient, projectId, workItem) {
+  if (workItem.workKind !== "planRevision" || !workItem.reviewDocumentId) {
+    return createWorkExecutionPrompt(workItem);
+  }
+  const [{ documents }, { messages }] = await Promise.all([
+    apiClient.listBrainDocuments(projectId),
+    apiClient.listPlanReviewMessages(projectId, workItem.reviewDocumentId)
+  ]);
+  const planDocument = documents.find((document) => document.documentId === workItem.reviewDocumentId || document.id === workItem.reviewDocumentId);
+  return createWorkExecutionPrompt(workItem, {
+    ...planDocument ? { planRevision: { planDocument, messages } } : {}
+  });
+}
+async function loadPairedApiContext(root, apiUrl) {
+  const metadata = await readProjectLink(root);
+  if (!metadata) {
+    return void 0;
+  }
+  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 } : {}
+    })
+  };
+}
+async function loadProjectNextAction(apiClient, projectId, repositoryLinkId, root) {
+  const [{ workItems }, { documents }, { runners }] = await Promise.all([
+    apiClient.listWorkItems(projectId),
+    apiClient.listBrainDocuments(projectId),
+    apiClient.listRunners(projectId).catch(() => ({ runners: [] }))
+  ]);
+  return computeProjectNextAction({
+    projectId,
+    repositoryLinks: [createCliRepositoryLink({ amistioAccountId: "local_runner", amistioProjectId: projectId, repositoryLinkId, defaultBranch: "main", lastSyncedRevision: 0 }, root)],
+    documents,
+    workItems,
+    runnerHeartbeats: runners
+  });
+}
+function createCliRepositoryLink(metadata, root) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: metadata.repositoryLinkId,
+    type: "repositoryLink",
+    schemaVersion: 1,
+    accountId: metadata.amistioAccountId,
+    projectId: metadata.amistioProjectId,
+    repositoryLinkId: metadata.repositoryLinkId,
+    repoName: inferRepoName(root),
+    repoFingerprint: createRepoFingerprint(metadata.amistioAccountId, metadata.amistioProjectId, metadata.repositoryLinkId),
+    defaultBranch: metadata.defaultBranch,
+    status: "active",
+    createdAt: now,
+    updatedAt: now
+  };
+}
+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,
+  model,
+  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: toolSession2 } = await apiClient.updateToolSession(projectId, selection.toolSession.toolSessionId, {
+      status: "active",
+      runnerId,
+      lastWorkItemId: workItem.workItemId,
+      reusePolicy: sessionPolicy
+    });
+    return { ...selection, toolSession: toolSession2 };
+  }
+  const toolSessionId = `tool_session_${randomUUID()}`;
+  const { toolSession } = await apiClient.createToolSession(projectId, {
+    toolSessionId,
+    repositoryLinkId,
+    tool: toolName,
+    provider: toolName,
+    ...model ? { model } : {},
+    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 void 0;
+  }
+  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 !== void 0 ? { estimatedInputTokens: (session.estimatedInputTokens ?? 0) + tokensIn } : {},
+    ...tokensOut !== void 0 ? { estimatedOutputTokens: (session.estimatedOutputTokens ?? 0) + tokensOut } : {},
+    ...costUsd !== void 0 ? { 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";
+  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;
+  const trimmed = value.trim();
+  if (!trimmed) {
+    return void 0;
+  }
+  return trimmed.length > 300 ? `${trimmed.slice(0, 300)}...` : trimmed;
 }
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
+function errorMessage2(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;
+  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;
+  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";
+  return path9.basename(path9.resolve(root)) || "repository";
 }
 function createRepoFingerprint(accountId, projectId, repositoryLinkId) {
-    return createHash("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");
+  return createHash3("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");
 }
 function defaultApiUrl() {
-    const envApiUrl = process.env[AMISTIO_API_URL_ENV]?.trim();
-    return envApiUrl || officialAmistioApiUrl;
+  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());
+  return command.getOptionValueSource("apiUrl") === "cli" || Boolean(process.env[AMISTIO_API_URL_ENV]?.trim());
 }
 function formatApiUrlFlag(apiUrl) {
-    return isOfficialAmistioApiUrl(apiUrl) ? "" : ` --api-url ${formatShellArg(apiUrl)}`;
+  return isOfficialAmistioApiUrl(apiUrl) ? "" : ` --api-url ${formatShellArg(apiUrl)}`;
 }
 function formatShellArg(value) {
-    return /^[A-Za-z0-9_./:@-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
+  return /^[A-Za-z0-9_./:@-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
+}
+async function resolveRunnerToolConfig({ apiClient, explicitModel, explicitTool, projectId, toolCommand }) {
+  const capabilities = toRunnerToolCapabilities(await detectLocalTools());
+  if (toolCommand) {
+    return {
+      ready: true,
+      tool: explicitTool ?? "auto",
+      capabilities,
+      source: "cli",
+      status: "custom",
+      effectiveTool: "custom",
+      ...explicitTool && explicitTool !== "none" && explicitTool !== "auto" && isLocalToolName(explicitTool) ? { requestedTool: explicitTool } : explicitTool === "auto" ? { requestedTool: "auto" } : {},
+      ...explicitModel ? { model: explicitModel } : {},
+      message: "Using local custom tool command."
+    };
+  }
+  if (explicitTool === "none") {
+    if (explicitModel) {
+      return unavailableToolConfig({ capabilities, source: "cli", status: "modelUnsupported", message: "--model cannot be used with --tool none.", tool: "none", model: explicitModel });
+    }
+    return { ready: true, tool: "none", capabilities, source: "cli", status: "none", message: "No local tool selected." };
+  }
+  if (explicitTool && explicitTool !== "auto" && !isLocalToolName(explicitTool)) {
+    return unavailableToolConfig({ capabilities, source: "cli", status: "unavailable", message: `Unsupported local tool: ${explicitTool}.`, tool: explicitTool, ...explicitModel ? { model: explicitModel } : {} });
+  }
+  const remotePreference = explicitTool || explicitModel ? void 0 : await apiClient.getRunnerPreferences(projectId).then((response) => response.effective).catch(() => void 0);
+  const requestedTool = explicitTool ?? remotePreference?.tool ?? "auto";
+  const model = explicitModel ?? remotePreference?.model;
+  const source = explicitTool || explicitModel ? "cli" : remotePreference?.source ?? "default";
+  return resolveRequestedTool({ capabilities, requestedTool, source, ...model ? { model } : {} });
+}
+function resolveRequestedTool({ capabilities, model, requestedTool, source }) {
+  if (requestedTool === "auto") {
+    const candidate = capabilities.find((capability2) => capability2.available && (!model || capability2.supportsModelSelection));
+    if (!candidate) {
+      return unavailableToolConfig({
+        capabilities,
+        source,
+        status: model ? "modelUnsupported" : "unavailable",
+        requestedTool,
+        tool: "auto",
+        ...model ? { model } : {},
+        message: model ? "No installed local tool can honor the selected model." : "No supported local AI tool is installed."
+      });
+    }
+    return { ready: true, tool: "auto", capabilities, source, status: "resolved", requestedTool, effectiveTool: candidate.name, ...model ? { model } : {} };
+  }
+  const capability = capabilities.find((candidate) => candidate.name === requestedTool);
+  if (!capability?.available) {
+    return unavailableToolConfig({ capabilities, source, status: "unavailable", requestedTool, tool: requestedTool, ...model ? { model } : {}, message: `${requestedTool} is selected but is not available on this runner.` });
+  }
+  if (model && !capability.supportsModelSelection) {
+    return unavailableToolConfig({ capabilities, source, status: "modelUnsupported", requestedTool, effectiveTool: requestedTool, tool: requestedTool, model, message: `${requestedTool} is available but does not support Amistio model selection yet.` });
+  }
+  return { ready: true, tool: requestedTool, capabilities, source, status: "resolved", requestedTool, effectiveTool: requestedTool, ...model ? { model } : {} };
+}
+function unavailableToolConfig(input) {
+  return {
+    ready: false,
+    tool: input.tool,
+    capabilities: input.capabilities,
+    source: input.source,
+    status: input.status,
+    message: input.message,
+    ...input.requestedTool ? { requestedTool: input.requestedTool } : {},
+    ...input.effectiveTool ? { effectiveTool: input.effectiveTool } : {},
+    ...input.model ? { model: input.model } : {}
+  };
+}
+function toRunnerToolCapabilities(tools) {
+  return tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description,
+    available: tool.available,
+    sdkAvailable: tool.sdkAvailable,
+    commandAvailable: tool.commandAvailable,
+    execution: tool.execution,
+    supportsSessionReuse: tool.supportsSessionReuse,
+    resumabilityScope: tool.resumabilityScope,
+    supportsModelSelection: tool.supportsModelSelection
+  }));
+}
+function buildBackgroundRunnerArgs(options) {
+  const args = [
+    "run",
+    "--watch",
+    "--api-url",
+    options.apiUrl,
+    "--runner-id",
+    options.runnerId,
+    "--root",
+    path9.resolve(options.root),
+    "--session",
+    options.session,
+    "--interval-seconds",
+    String(options.intervalSeconds)
+  ];
+  if (options.tool) {
+    args.push("--tool", options.tool);
+  }
+  if (options.toolCommand) {
+    args.push("--tool-command", options.toolCommand);
+  }
+  if (options.model) {
+    args.push("--model", options.model);
+  }
+  if (options.maxIterations !== void 0) {
+    args.push("--max-iterations", String(options.maxIterations));
+  }
+  if (!options.stream) {
+    args.push("--no-stream");
+  }
+  return args;
+}
+function runnerHeartbeatMetadata(toolConfig, mode = currentRunnerMode()) {
+  return {
+    version: CLI_VERSION,
+    mode,
+    hostname: os5.hostname(),
+    ...toolConfig?.capabilities ? { capabilities: toolConfig.capabilities } : {},
+    ...toolConfig?.requestedTool ? { requestedTool: toolConfig.requestedTool } : {},
+    ...toolConfig?.effectiveTool ? { effectiveTool: toolConfig.effectiveTool } : {},
+    ...toolConfig?.model ? { effectiveModel: toolConfig.model } : {},
+    ...toolConfig?.source ? { preferenceSource: toolConfig.source } : {},
+    ...toolConfig?.status ? { preferenceStatus: toolConfig.status } : {},
+    ...toolConfig?.message ? { preferenceMessage: toolConfig.message } : {}
+  };
 }
 async function delay(milliseconds) {
-    await new Promise((resolve) => setTimeout(resolve, milliseconds));
+  await new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 program.parseAsync().catch((error) => {
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exitCode = 1;
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
 });
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map