@amistio/cli 0.1.1 → 0.1.2

package/dist/index.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { createHash as createHash2, randomUUID } from "node:crypto";
-import { writeFile as writeFile7 } from "node:fs/promises";
-import path8 from "node:path";
+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";
 
 // ../shared/src/schemas.ts
@@ -24,6 +26,9 @@ var itemTypeSchema = z.enum([
   "workItem",
   "runnerHeartbeat",
   "runnerExecutionLog",
+  "runnerCredential",
+  "runnerCommand",
+  "planReviewMessage",
   "toolSession",
   "activityEvent",
   "pairingSession"
@@ -60,7 +65,7 @@ var workStatusSchema = z.enum([
 ]);
 var sourceSchema = z.enum(["web", "repo", "generated", "runner"]);
 var executionModeSchema = z.enum(["localRunner", "cloudSandbox"]);
-var workKindSchema = z.enum(["brainGeneration", "implementation"]);
+var workKindSchema = z.enum(["brainGeneration", "implementation", "planRevision"]);
 var generatedDraftStatusSchema = z.enum(["queued", "generating", "reviewing", "approved", "rejected", "changesRequested", "failed"]);
 var generatedBrainArtifactSchema = z.object({
   documentType: documentTypeSchema,
@@ -76,6 +81,27 @@ var sessionPolicySchema = z.union([z.enum(["auto", "new", "none"]), z.string().r
 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({
@@ -182,6 +208,10 @@ var workItemSchema = baseItemSchema.extend({
   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),
@@ -201,8 +231,25 @@ var runnerHeartbeatItemSchema = baseItemSchema.extend({
   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),
@@ -232,6 +279,57 @@ var runnerExecutionLogItemSchema = baseItemSchema.extend({
   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),
@@ -275,7 +373,11 @@ var projectItemUnionSchema = z.discriminatedUnion("type", [
   syncConflictItemSchema,
   workItemSchema,
   runnerHeartbeatItemSchema,
+  runnerSettingsItemSchema,
   runnerExecutionLogItemSchema,
+  runnerCredentialItemSchema,
+  runnerCommandItemSchema,
+  planReviewMessageItemSchema,
   toolSessionItemSchema
 ]);
 
@@ -461,6 +563,211 @@ function decideSyncState(state) {
   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";
@@ -544,6 +851,16 @@ var LocalCredentialStore = class {
     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"));
@@ -699,6 +1016,14 @@ var ApiClient = class {
       { 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`,
@@ -709,13 +1034,58 @@ var ApiClient = class {
       }
     );
   }
-  async sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, status, version) {
+  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, ...version ? { version } : {}, lastSeenAt: (/* @__PURE__ */ new Date()).toISOString() })
+        body: JSON.stringify({ runnerId, repositoryLinkId, status, ...heartbeatMetadata, lastSeenAt: (/* @__PURE__ */ new Date()).toISOString() })
       }
     );
   }
@@ -808,8 +1178,8 @@ var toolSessionMutationSchema = z3.object({
 });
 function resolveApiUrl(apiUrl, urlPath) {
   const base = apiUrl.endsWith("/") ? apiUrl.slice(0, -1) : apiUrl;
-  const path9 = urlPath.startsWith("/") ? urlPath : `/${urlPath}`;
-  return new URL(`${base}${path9}`);
+  const path10 = urlPath.startsWith("/") ? urlPath : `/${urlPath}`;
+  return new URL(`${base}${path10}`);
 }
 
 // src/orchestrator.ts
@@ -878,7 +1248,7 @@ 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 = ["opencode", "claude", "codex", "copilot", "gemini", "aider", "cursor-agent"];
+var localToolNames = runnerToolNames;
 var localToolAdapters = [
   {
     name: "opencode",
@@ -931,6 +1301,7 @@ var localToolAdapters = [
     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
@@ -988,7 +1359,8 @@ async function detectLocalTools() {
         commandAvailable,
         execution: sdkAvailable ? "sdk" : commandAvailable ? "command" : "unavailable",
         supportsSessionReuse: Boolean(adapter.supportsSessionReuse),
-        resumabilityScope: adapter.resumabilityScope ?? "none"
+        resumabilityScope: adapter.resumabilityScope ?? "none",
+        supportsModelSelection: Boolean(adapter.supportsModelSelection)
       };
     })
   );
@@ -1002,13 +1374,14 @@ async function runLocalTool(options) {
       rootDir: options.rootDir,
       prompt: options.prompt,
       promptFilePath,
-      tool: options.tool ?? "auto"
+      tool: options.tool ?? "auto",
+      ...options.model ? { model: options.model } : {}
     };
     if (options.toolCommand) {
       runnerOptions.toolCommand = options.toolCommand;
     }
-    const runner = await createToolRunner(runnerOptions);
-    const result = await executeToolRunner(runner, {
+    const runner2 = await createToolRunner(runnerOptions);
+    const result = await executeToolRunner(runner2, {
       rootDir: options.rootDir,
       prompt: options.prompt,
       promptFilePath,
@@ -1016,10 +1389,11 @@ async function runLocalTool(options) {
       ...options.session ? { session: options.session } : {}
     });
     return {
-      toolName: runner.toolName,
-      displayCommand: runner.kind === "sdk" ? runner.displayCommand : runner.invocation.displayCommand,
-      supportsSessionReuse: runner.kind === "sdk" ? Boolean(runner.adapter.supportsSessionReuse) : false,
-      resumabilityScope: runner.kind === "sdk" ? runner.adapter.resumabilityScope ?? "none" : "none",
+      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 {
@@ -1032,17 +1406,19 @@ async function createToolRunPreview(options) {
     rootDir: options.rootDir,
     prompt: options.prompt,
     promptFilePath,
-    tool: options.tool ?? "auto"
+    tool: options.tool ?? "auto",
+    ...options.model ? { model: options.model } : {}
   };
   if (options.toolCommand) {
     runnerOptions.toolCommand = options.toolCommand;
   }
-  const runner = await createToolRunner(runnerOptions);
+  const runner2 = await createToolRunner(runnerOptions);
   return {
-    toolName: runner.toolName,
-    displayCommand: runner.kind === "sdk" ? runner.displayCommand : runner.invocation.displayCommand,
-    supportsSessionReuse: runner.kind === "sdk" ? Boolean(runner.adapter.supportsSessionReuse) : false,
-    resumabilityScope: runner.kind === "sdk" ? runner.adapter.resumabilityScope ?? "none" : "none"
+    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) {
@@ -1067,7 +1443,10 @@ async function createToolRunner(options) {
   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() : await selectRequestedAdapter(tool);
+  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,
@@ -1085,17 +1464,17 @@ async function createToolRunner(options) {
   }
   throw new Error(`The ${adapter.name} SDK or executable was not found. Install the SDK/runtime or pass --tool-command.`);
 }
-async function executeToolRunner(runner, input) {
-  if (runner.kind === "command") {
-    return executeToolInvocation(runner.invocation, input.rootDir, input.streamOutput);
+async function executeToolRunner(runner2, input) {
+  if (runner2.kind === "command") {
+    return executeToolInvocation(runner2.invocation, input.rootDir, input.streamOutput);
   }
   try {
-    return await runner.adapter.runWithSdk(input);
+    return await runner2.adapter.runWithSdk(input);
   } catch (error) {
-    if (runner.adapter.buildInvocation && runner.adapter.executable && await commandExists(runner.adapter.executable)) {
-      const fallback = runner.adapter.buildInvocation(input);
+    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 ${runner.adapter.name} failed, fell back to ${fallback.displayCommand}: ${errorMessage(error)}`;
+      const sdkFailure = `SDK execution for ${runner2.adapter.name} failed, fell back to ${fallback.displayCommand}: ${errorMessage(error)}`;
       return {
         ...result,
         stderr: result.stderr ? `${sdkFailure}
@@ -1111,8 +1490,11 @@ function normalizeToolRequest(value) {
   }
   throw new Error(`Unsupported local tool: ${value}. Supported tools: auto, none, ${localToolNames.join(", ")}.`);
 }
-async function selectFirstAvailableAdapter() {
+async function selectFirstAvailableAdapter(requiresModelSelection = false) {
   for (const adapter of localToolAdapters) {
+    if (requiresModelSelection && !adapter.supportsModelSelection) {
+      continue;
+    }
     const sdkAvailable = await isSdkAvailable(adapter);
     const commandAvailable = adapter.executable ? await commandExists(adapter.executable) : false;
     if (sdkAvailable || commandAvailable) {
@@ -1120,7 +1502,7 @@ async function selectFirstAvailableAdapter() {
     }
   }
   throw new Error(
-    `No supported local AI tool was found. Install one of ${localToolNames.join(", ")} or pass --tool-command "your-tool --prompt-file {promptFile}".`
+    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) {
@@ -1292,7 +1674,7 @@ async function runCopilotSdk(input) {
     await client.start();
     const session = await client.createSession({
       clientName: "amistio-cli",
-      model: process.env.AMISTIO_COPILOT_MODEL ?? "gpt-5",
+      model: input.model ?? process.env.AMISTIO_COPILOT_MODEL ?? "gpt-5",
       workingDirectory: input.rootDir,
       enableConfigDiscovery: true,
       streaming: input.streamOutput,
@@ -1334,6 +1716,187 @@ 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;
@@ -1455,8 +2018,8 @@ function tokens(value) {
 }
 
 // src/sync.ts
-import { mkdir as mkdir5, readdir as readdir2, readFile as readFile3, stat as stat3, writeFile as writeFile5 } from "node:fs/promises";
-import path6 from "node:path";
+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);
@@ -1533,7 +2096,7 @@ async function readLocalSyncedDocuments(rootDir) {
   const markdownFiles = await findMarkdownFiles(rootDir);
   const documents = [];
   for (const fullPath of markdownFiles) {
-    const raw = await readFile3(fullPath, "utf8");
+    const raw = await readFile4(fullPath, "utf8");
     const parsed = parseSyncedMarkdown(raw);
     if (!parsed) {
       continue;
@@ -1574,8 +2137,8 @@ async function materializeBrainDocuments(rootDir, documents, options = {}) {
       result.skipped.push(document.repoPath);
       continue;
     }
-    await mkdir5(path6.dirname(fullPath), { recursive: true });
-    await writeFile5(fullPath, createSyncedDocumentMarkdown(document), "utf8");
+    await mkdir6(path7.dirname(fullPath), { recursive: true });
+    await writeFile6(fullPath, createSyncedDocumentMarkdown(document), "utf8");
     result.written.push(document.repoPath);
   }
   return result;
@@ -1636,7 +2199,7 @@ function parseSyncedMarkdown(content) {
 }
 async function readExistingSyncedDocument(fullPath) {
   try {
-    const raw = await readFile3(fullPath, "utf8");
+    const raw = await readFile4(fullPath, "utf8");
     const parsed = parseSyncedMarkdown(raw);
     if (!parsed) {
       return { exists: true };
@@ -1661,7 +2224,7 @@ async function readExistingSyncedDocument(fullPath) {
 async function findMarkdownFiles(rootDir) {
   const files = [];
   for (const syncRoot of syncRoots) {
-    const fullRoot = path6.join(rootDir, syncRoot);
+    const fullRoot = path7.join(rootDir, syncRoot);
     if (!await exists2(fullRoot)) {
       continue;
     }
@@ -1670,8 +2233,8 @@ async function findMarkdownFiles(rootDir) {
   return files;
 }
 async function walkMarkdownFiles(directory, files) {
-  for (const entry of await readdir2(directory, { withFileTypes: true })) {
-    const fullPath = path6.join(directory, entry.name);
+  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")) {
@@ -1680,30 +2243,30 @@ async function walkMarkdownFiles(directory, files) {
   }
 }
 function safeRepoPath(rootDir, repoPath) {
-  if (path6.isAbsolute(repoPath)) {
+  if (path7.isAbsolute(repoPath)) {
     throw new Error(`Refusing to use absolute repo path: ${repoPath}`);
   }
-  const normalized = path6.normalize(repoPath);
-  if (normalized === ".." || normalized.startsWith(`..${path6.sep}`)) {
+  const normalized = path7.normalize(repoPath);
+  if (normalized === ".." || normalized.startsWith(`..${path7.sep}`)) {
     throw new Error(`Refusing to use path outside the repository: ${repoPath}`);
   }
-  const root = path6.resolve(rootDir);
-  const fullPath = path6.resolve(root, normalized);
-  if (!fullPath.startsWith(`${root}${path6.sep}`)) {
+  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 = path6.normalize(repoPath);
-  return syncRoots.some((syncRoot) => normalized === syncRoot || normalized.startsWith(`${syncRoot}${path6.sep}`));
+  const normalized = path7.normalize(repoPath);
+  return syncRoots.some((syncRoot) => normalized === syncRoot || normalized.startsWith(`${syncRoot}${path7.sep}`));
 }
 function toRepoPath(rootDir, fullPath) {
-  return path6.relative(rootDir, fullPath).split(path6.sep).join("/");
+  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 || path6.basename(repoPath, path6.extname(repoPath));
+  return heading || path7.basename(repoPath, path7.extname(repoPath));
 }
 function parseFrontmatterFromSyncedDocument(frontmatter) {
   return {
@@ -1724,9 +2287,9 @@ async function exists2(filePath) {
 }
 
 // src/tool-session-store.ts
-import { mkdir as mkdir6, readFile as readFile4, writeFile as writeFile6 } from "node:fs/promises";
-import os3 from "node:os";
-import path7 from "node:path";
+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;
@@ -1740,12 +2303,12 @@ var LocalToolSessionStore = class {
   async setProviderSessionId(toolSessionId, toolName, providerSessionId) {
     const data = await this.read();
     data[toolSessionId] = { toolName, providerSessionId, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-    await mkdir6(path7.dirname(this.filePath), { recursive: true });
-    await writeFile6(this.filePath, JSON.stringify(data, null, 2), "utf8");
+    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 readFile4(this.filePath, "utf8"));
+      return JSON.parse(await readFile5(this.filePath, "utf8"));
     } catch {
       return {};
     }
@@ -1753,21 +2316,24 @@ var LocalToolSessionStore = class {
 };
 function defaultSessionStorePath() {
   if (process.platform === "darwin") {
-    return path7.join(os3.homedir(), "Library", "Application Support", "Amistio", "tool-sessions.json");
+    return path8.join(os4.homedir(), "Library", "Application Support", "Amistio", "tool-sessions.json");
   }
   if (process.platform === "win32") {
-    return path7.join(process.env.APPDATA ?? os3.homedir(), "Amistio", "tool-sessions.json");
+    return path8.join(process.env.APPDATA ?? os4.homedir(), "Amistio", "tool-sessions.json");
   }
-  return path7.join(process.env.XDG_STATE_HOME ?? path7.join(os3.homedir(), ".local", "state"), "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) {
+function createWorkExecutionPrompt(workItem, context) {
   if (workItem.workKind === "brainGeneration") {
     return createBrainGenerationPrompt(workItem);
   }
+  if (workItem.workKind === "planRevision") {
+    return createPlanRevisionPrompt(workItem, context?.planRevision);
+  }
   return [
     "# Amistio Work Execution",
     "",
@@ -1792,6 +2358,42 @@ function createWorkExecutionPrompt(workItem) {
     "- 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);
@@ -1861,12 +2463,33 @@ function stripJsonFence(value) {
   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.1");
-var CLI_VERSION = "0.1.1";
+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.");
@@ -2019,7 +2642,19 @@ work.command("list").description("List queued work without claiming it").option(
     console.log("Repository is not paired. Run `amistio pair` first.");
     return;
   }
-  const { workItems } = await context.client.listWorkItems(context.metadata.amistioProjectId);
+  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;
@@ -2042,7 +2677,7 @@ work.command("prompt").description("Print or write an approved work prompt witho
   }
   const prompt = createWorkExecutionPrompt(workItem);
   if (options.out) {
-    await writeFile7(options.out, prompt, "utf8");
+    await writeFile8(options.out, prompt, "utf8");
     console.log(`Wrote work prompt to ${options.out}.`);
   } else {
     console.log(prompt);
@@ -2056,7 +2691,7 @@ program.command("tools").description("List local AI coding tools that the Amisti
   }
   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) => {
+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) {
@@ -2068,13 +2703,14 @@ program.command("orchestrate").description("Update the Amistio control plane thr
     return;
   }
   const sessionPolicy = normalizeSessionPolicy(options.session);
-  const preview = await createToolRunPreview({ rootDir: options.root, prompt, tool: options.tool, ...options.toolCommand ? { toolCommand: options.toolCommand } : {} });
+  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) } }
   });
@@ -2088,7 +2724,7 @@ program.command("orchestrate").description("Update the Amistio control plane thr
     process.exitCode = result.exitCode;
   }
 });
-program.command("run").description("Claim and run approved Amistio work locally").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--runner-id <runnerId>", "Stable runner ID", `runner_${randomUUID()}`).option("--root <path>", "Repository root", defaultRoot).option("--tool <name>", "Local tool to use: auto, none, opencode, claude, codex, copilot, gemini, aider, cursor-agent", "auto").option("--tool-command <command>", "Custom local command. Use {promptFile} and {root} placeholders when supported").option("--session <policy>", "Tool session policy: auto, new, continue:<toolSessionId>, or none", "auto").option("--dry-run", "Claim work and print the generated execution prompt without running a tool").option("--watch", "Keep polling for approved work until stopped").option("--interval-seconds <seconds>", "Polling interval for --watch", parsePositiveInteger, 10).option("--max-iterations <count>", "Stop watch mode after this many polling attempts", parsePositiveInteger).option("--no-stream", "Capture local tool output instead of streaming it").action(async (options) => {
+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.");
@@ -2099,10 +2735,34 @@ program.command("run").description("Claim and run approved Amistio work locally"
     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)
+    });
+    console.log(`Started background runner ${metadata.runnerId} with PID ${metadata.pid}.`);
+    if (metadata.logPath) {
+      console.log(`Log: ${metadata.logPath}`);
+    }
+    return;
+  }
   if (options.watch) {
-    console.log(`Runner ${options.runnerId} is watching ${context.metadata.amistioProjectId} every ${options.intervalSeconds}s. Press Ctrl+C to stop.`);
+    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({
@@ -2112,10 +2772,21 @@ program.command("run").description("Claim and run approved Amistio work locally"
       runnerId: options.runnerId,
       root: options.root,
       sessionPolicy: normalizeSessionPolicy(options.session),
-      tool: options.tool,
+      ...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
+      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)
     });
     if (!options.watch || options.dryRun) {
       if (result.exitCode !== 0) {
@@ -2123,16 +2794,94 @@ program.command("run").description("Claim and run approved Amistio work locally"
       }
       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;
     }
-    if (result.status === "idle") {
-      console.log(`No approved work item is available. Checking again in ${options.intervalSeconds}s.`);
-    }
     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,
@@ -2142,23 +2891,48 @@ async function runNextWorkItem({
   runnerId,
   sessionPolicy,
   stream,
-  tool,
-  toolCommand
+  explicitModel,
+  explicitTool,
+  toolCommand,
+  commandContext,
+  suppressIdleOutput
 }) {
-  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", CLI_VERSION);
+  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) {
-    console.log("No approved work item is available.");
-    return { status: "idle", exitCode: 0 };
+    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", CLI_VERSION);
-  const prompt = createWorkExecutionPrompt(result.workItem);
-  if (dryRun || tool === "none") {
+  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", CLI_VERSION);
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
     return { status: "preview", exitCode: 0 };
   }
-  const preview = await createToolRunPreview({ rootDir: root, prompt, tool, ...toolCommand ? { toolCommand } : {} });
+  const preview = await createToolRunPreview({ rootDir: root, prompt, tool: toolConfig.tool, ...toolCommand ? { toolCommand } : {}, ...toolConfig.model ? { model: toolConfig.model } : {} });
   const sessionContext = await prepareToolSession({
     apiClient,
     projectId,
@@ -2166,6 +2940,7 @@ async function runNextWorkItem({
     runnerId,
     sessionPolicy: result.workItem.sessionPolicy ?? sessionPolicy,
     toolName: preview.toolName,
+    ...toolConfig.model ? { model: toolConfig.model } : {},
     supportsSessionReuse: preview.supportsSessionReuse,
     resumabilityScope: preview.resumabilityScope,
     workItem: result.workItem
@@ -2177,8 +2952,9 @@ async function runNextWorkItem({
   const toolResult = await runLocalTool({
     rootDir: root,
     prompt,
-    tool,
+    tool: toolConfig.tool,
     ...toolCommand ? { toolCommand } : {},
+    ...toolConfig.model ? { model: toolConfig.model } : {},
     streamOutput: stream,
     ...sessionContext.toolSession ? {
       session: {
@@ -2189,7 +2965,7 @@ async function runNextWorkItem({
       }
     } : {}
   }).catch(async (error) => {
-    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "blocked", CLI_VERSION);
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "blocked", runnerHeartbeatMetadata(toolConfig));
     await markToolSessionBlocked(apiClient, projectId, sessionContext.toolSession, errorMessage2(error));
     throw error;
   });
@@ -2202,7 +2978,7 @@ async function runNextWorkItem({
   if (!stream && toolResult.stderr.trim()) {
     console.error(toolResult.stderr.trim());
   }
-  if (result.workItem.workKind === "brainGeneration") {
+  if (result.workItem.workKind === "brainGeneration" || result.workItem.workKind === "planRevision") {
     return finalizeBrainGenerationWork({
       apiClient,
       durationMs: Date.now() - startedAt,
@@ -2210,6 +2986,7 @@ async function runNextWorkItem({
       repositoryLinkId,
       runnerId,
       sessionContext,
+      toolConfig,
       toolName: preview.toolName,
       toolResult,
       workItem: result.workItem
@@ -2239,6 +3016,7 @@ async function runNextWorkItem({
     runnerId,
     {
       tool: preview.toolName,
+      ...toolResult.model ? { model: toolResult.model } : {},
       durationMs,
       message: `${preview.toolName} exited with code ${toolResult.exitCode}.`,
       sessionPolicy: sessionContext.policy,
@@ -2252,11 +3030,100 @@ async function runNextWorkItem({
       ...failureExcerpt ? { error: failureExcerpt } : {}
     }
   );
-  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", CLI_VERSION);
+  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 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,
@@ -2264,6 +3131,7 @@ async function finalizeBrainGenerationWork({
   repositoryLinkId,
   runnerId,
   sessionContext,
+  toolConfig,
   toolName,
   toolResult,
   workItem
@@ -2302,6 +3170,7 @@ ${toolResult.stderr}`);
     ...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,
@@ -2310,10 +3179,10 @@ ${toolResult.stderr}`);
       tool: toolName,
       durationMs,
       ...sessionTelemetry,
-      message: `${toolName} generated ${artifacts.length} brain artifact${artifacts.length === 1 ? "" : "s"}.`
+      message: completionMessage
     });
-    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", CLI_VERSION);
-    console.log(`Generated ${result.documents.length} brain artifact${result.documents.length === 1 ? "" : "s"} for review.`);
+    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, {
@@ -2326,10 +3195,23 @@ ${toolResult.stderr}`);
     message: `${toolName} did not produce valid brain artifacts.`,
     ...generationError ? { error: generationError } : {}
   });
-  await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", CLI_VERSION);
+  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) {
@@ -2348,6 +3230,37 @@ async function loadPairedApiContext(root, apiUrl) {
     })
   };
 }
+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);
@@ -2366,6 +3279,7 @@ async function prepareToolSession({
   supportsSessionReuse,
   resumabilityScope,
   toolName,
+  model,
   workItem
 }) {
   const { toolSessions } = await apiClient.listToolSessions(projectId);
@@ -2396,6 +3310,7 @@ async function prepareToolSession({
     repositoryLinkId,
     tool: toolName,
     provider: toolName,
+    ...model ? { model } : {},
     resumabilityScope: supportsSessionReuse ? resumabilityScope : "none",
     title: workItem.title,
     summary: selection.reason,
@@ -2479,10 +3394,10 @@ function parsePositiveInteger(value) {
   return parsed;
 }
 function inferRepoName(root) {
-  return path8.basename(path8.resolve(root)) || "repository";
+  return path9.basename(path9.resolve(root)) || "repository";
 }
 function createRepoFingerprint(accountId, projectId, repositoryLinkId) {
-  return createHash2("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();
@@ -2497,6 +3412,133 @@ function formatApiUrlFlag(apiUrl) {
 function formatShellArg(value) {
   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));
 }