@amistio/cli 0.1.7 → 0.1.9

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { createHash as createHash6, randomUUID } from "node:crypto";
+import { createHash as createHash7, randomUUID } from "node:crypto";
 import { writeFile as writeFile9 } from "node:fs/promises";
 import os7 from "node:os";
 import path13 from "node:path";
@@ -120,13 +120,55 @@ 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", "channelUnsupported", "custom", "none"]);
+var runnerPreferenceStatusSchema = z.enum(["resolved", "unavailable", "modelUnsupported", "variantUnsupported", "reasoningUnsupported", "channelUnsupported", "custom", "none"]);
 var runnerInvocationChannelSchema = z.enum(["auto", "sdk", "command"]);
 var runnerEffectiveInvocationChannelSchema = z.enum(["sdk", "command"]);
+var runnerReasoningEffortSchema = z.enum(["auto", "low", "medium", "high", "xhigh"]);
+var runnerProviderModelStatusSchema = z.enum(["alpha", "beta", "deprecated", "active"]);
+var runnerProviderIdSchema = z.string().trim().min(1).max(120);
+var runnerProviderModelIdSchema = z.string().trim().min(1).max(200);
+var runnerProviderModelLimitSchema = z.object({
+  context: z.number().nonnegative().optional(),
+  input: z.number().nonnegative().optional(),
+  output: z.number().nonnegative().optional()
+}).strict();
+var runnerProviderModelModalitiesSchema = z.object({
+  input: z.array(z.enum(["text", "audio", "image", "video", "pdf"])).max(12).optional(),
+  output: z.array(z.enum(["text", "audio", "image", "video", "pdf"])).max(12).optional()
+}).strict();
+var runnerProviderModelVariantSchema = z.object({
+  disabled: z.boolean().optional()
+}).strict();
+var runnerProviderModelSchema = z.object({
+  id: runnerProviderModelIdSchema.optional(),
+  name: z.string().trim().min(1).max(200).optional(),
+  family: z.string().trim().min(1).max(120).optional(),
+  releaseDate: z.string().trim().min(1).max(40).optional(),
+  attachment: z.boolean().optional(),
+  reasoning: z.boolean().optional(),
+  temperature: z.boolean().optional(),
+  toolCall: z.boolean().optional(),
+  status: runnerProviderModelStatusSchema.optional(),
+  limit: runnerProviderModelLimitSchema.optional(),
+  modalities: runnerProviderModelModalitiesSchema.optional(),
+  supportedReasoningEfforts: z.array(runnerReasoningEffortSchema).max(8).optional(),
+  variants: z.record(z.string().trim().min(1).max(120), runnerProviderModelVariantSchema).optional()
+}).strict();
+var runnerProviderConfigSchema = z.object({
+  id: runnerProviderIdSchema.optional(),
+  name: z.string().trim().min(1).max(160).optional(),
+  api: z.string().trim().min(1).max(80).optional(),
+  models: z.record(runnerProviderModelIdSchema, runnerProviderModelSchema).default({})
+}).strict();
+var runnerProviderCatalogSchema = z.record(runnerProviderIdSchema, runnerProviderConfigSchema);
 var runnerToolModelPreferenceSchema = z.object({
   tool: runnerToolSelectionSchema.optional(),
   invocationChannel: runnerInvocationChannelSchema.optional(),
-  model: z.string().trim().min(1).max(160).optional()
+  model: z.string().trim().min(1).max(160).optional(),
+  providerId: runnerProviderIdSchema.optional(),
+  modelId: runnerProviderModelIdSchema.optional(),
+  modelVariant: z.string().trim().min(1).max(120).optional(),
+  reasoningEffort: runnerReasoningEffortSchema.optional()
 });
 var runnerToolCapabilitySchema = z.object({
   name: runnerToolNameSchema,
@@ -138,6 +180,7 @@ var runnerToolCapabilitySchema = z.object({
   supportsSessionReuse: z.boolean(),
   resumabilityScope: sessionResumabilityScopeSchema,
   supportsModelSelection: z.boolean(),
+  providerCatalog: runnerProviderCatalogSchema.optional(),
   supportsBranchIsolation: z.boolean().optional(),
   supportsGitWorktreeIsolation: z.boolean().optional()
 });
@@ -159,6 +202,7 @@ var runnerResourceUsageSchema = z.object({
 var workIsolationModeSchema = z.enum(["none", "primaryCheckout", "branch", "gitWorktree"]);
 var repositoryLinkSourceSchema = z.enum(["web", "cli"]);
 var repositoryCloneStatusSchema = z.enum(["notCloned", "cloned", "validated", "failed"]);
+var repositoryBrainAutoSyncStatusSchema = z.enum(["disabled", "enabledInactive", "active", "synced", "failed", "blocked", "conflicted"]);
 var projectStatusSchema = z.enum(["active", "archived"]);
 var workspaceScopeKindSchema = z.enum(["personal", "organization"]);
 var personalWorkspaceScopeSchema = z.object({
@@ -229,6 +273,7 @@ var repositoryLinkItemSchema = baseItemSchema.extend({
   linkedByUserId: z.string().min(1).optional(),
   linkSource: repositoryLinkSourceSchema.optional(),
   cloneStatus: repositoryCloneStatusSchema.optional(),
+  autoSyncEnabled: z.boolean().optional(),
   lastValidatedAt: isoDateTimeSchema.optional(),
   status: z.enum(["active", "revoked"]).default("active")
 });
@@ -350,13 +395,29 @@ var runnerHeartbeatItemSchema = baseItemSchema.extend({
   capabilities: z.array(runnerToolCapabilitySchema).optional(),
   requestedTool: runnerToolSelectionSchema.optional(),
   requestedInvocationChannel: runnerInvocationChannelSchema.optional(),
+  requestedProviderId: runnerProviderIdSchema.optional(),
+  requestedModelId: runnerProviderModelIdSchema.optional(),
+  requestedModelVariant: z.string().trim().min(1).max(120).optional(),
+  requestedReasoningEffort: runnerReasoningEffortSchema.optional(),
   effectiveTool: z.union([runnerToolNameSchema, z.literal("custom")]).optional(),
   effectiveInvocationChannel: runnerEffectiveInvocationChannelSchema.optional(),
   effectiveModel: z.string().min(1).optional(),
+  effectiveProviderId: runnerProviderIdSchema.optional(),
+  effectiveModelId: runnerProviderModelIdSchema.optional(),
+  effectiveModelVariant: z.string().trim().min(1).max(120).optional(),
+  effectiveReasoningEffort: runnerReasoningEffortSchema.optional(),
   preferenceSource: runnerPreferenceSourceSchema.optional(),
   preferenceStatus: runnerPreferenceStatusSchema.optional(),
   preferenceMessage: z.string().optional(),
   resourceUsage: runnerResourceUsageSchema.optional(),
+  autoSyncStatus: repositoryBrainAutoSyncStatusSchema.optional(),
+  autoSyncMessage: z.string().max(400).optional(),
+  autoSyncLastStartedAt: isoDateTimeSchema.optional(),
+  autoSyncLastSuccessAt: isoDateTimeSchema.optional(),
+  autoSyncLastFailureAt: isoDateTimeSchema.optional(),
+  autoSyncPushedCount: z.number().int().nonnegative().optional(),
+  autoSyncSkippedCount: z.number().int().nonnegative().optional(),
+  autoSyncConflictCount: z.number().int().nonnegative().optional(),
   lastSeenAt: isoDateTimeSchema
 });
 var runnerSettingsItemSchema = baseItemSchema.extend({
@@ -410,6 +471,7 @@ var runnerCredentialItemSchema = baseItemSchema.extend({
   projectId: z.string().min(1),
   runnerCredentialId: z.string().min(1),
   repositoryLinkId: z.string().min(1),
+  runnerId: z.string().min(1).optional(),
   pairedByUserId: z.string().min(1).optional(),
   machineId: z.string().min(1).optional(),
   tokenHash: z.string().min(32),
@@ -719,6 +781,8 @@ var pairingSessionItemSchema = baseItemSchema.extend({
   projectId: z.string().min(1),
   createdByUserId: z.string().min(1),
   expiresAt: isoDateTimeSchema,
+  failedAttemptCount: z.number().int().nonnegative().optional(),
+  lastFailedAttemptAt: isoDateTimeSchema.optional(),
   status: z.enum(["pending", "confirmed", "expired", "revoked"])
 });
 var projectItemUnionSchema = z.discriminatedUnion("type", [
@@ -1433,6 +1497,13 @@ var ApiClient = class {
       { method: "GET" }
     );
   }
+  async listRepositoryLinks(projectId) {
+    return this.request(
+      `/projects/${projectId}/repository-links`,
+      z3.object({ repositoryLinks: z3.array(repositoryLinkItemSchema) }),
+      { method: "GET" }
+    );
+  }
   async listPlanReviewMessages(projectId, documentId) {
     const suffix = documentId ? `?documentId=${encodeURIComponent(documentId)}` : "";
     return this.request(
@@ -1500,6 +1571,10 @@ var ApiClient = class {
           tool: runnerToolSelectionSchema,
           invocationChannel: runnerInvocationChannelSchema,
           model: z3.string().optional(),
+          providerId: z3.string().optional(),
+          modelId: z3.string().optional(),
+          modelVariant: z3.string().optional(),
+          reasoningEffort: runnerReasoningEffortSchema.optional(),
           source: runnerPreferenceSourceSchema
         })
       }),
@@ -1722,10 +1797,87 @@ async function writePromptFile(filePath, prompt) {
 
 // src/local-tool-runner.ts
 import { spawn } from "node:child_process";
-import { mkdtemp, rm, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdtemp, readFile as readFile3, rm, writeFile as writeFile4 } from "node:fs/promises";
 import os2 from "node:os";
 import path5 from "node:path";
 var localToolNames = runnerToolNames;
+var allReasoningEfforts = ["auto", "low", "medium", "high", "xhigh"];
+var highReasoningEfforts = ["auto", "high", "xhigh"];
+var builtInProviderCatalogs = {
+  opencode: {
+    anthropic: {
+      id: "anthropic",
+      name: "Anthropic",
+      api: "anthropic",
+      models: {
+        "claude-opus-4.6": reasoningModel("claude-opus-4.6", "Claude Opus 4.6", "claude", highReasoningEfforts),
+        "claude-sonnet-4.5": reasoningModel("claude-sonnet-4.5", "Claude Sonnet 4.5", "claude", highReasoningEfforts)
+      }
+    },
+    openai: {
+      id: "openai",
+      name: "OpenAI",
+      api: "openai",
+      models: {
+        "gpt-5": reasoningModel("gpt-5", "GPT-5", "gpt", allReasoningEfforts)
+      }
+    }
+  },
+  claude: {
+    anthropic: {
+      id: "anthropic",
+      name: "Anthropic",
+      api: "anthropic",
+      models: {
+        "claude-opus-4.6": reasoningModel("claude-opus-4.6", "Claude Opus 4.6", "claude", highReasoningEfforts),
+        "claude-sonnet-4.5": reasoningModel("claude-sonnet-4.5", "Claude Sonnet 4.5", "claude", highReasoningEfforts)
+      }
+    }
+  },
+  codex: {
+    openai: {
+      id: "openai",
+      name: "OpenAI",
+      api: "openai",
+      models: {
+        "gpt-5": reasoningModel("gpt-5", "GPT-5", "gpt", allReasoningEfforts)
+      }
+    }
+  },
+  copilot: {
+    "github-copilot": {
+      id: "github-copilot",
+      name: "GitHub Copilot",
+      api: "copilot",
+      models: {
+        "gpt-5": reasoningModel("gpt-5", "GPT-5", "gpt", allReasoningEfforts),
+        "claude-opus-4.6": reasoningModel("claude-opus-4.6", "Claude Opus 4.6", "claude", highReasoningEfforts)
+      }
+    }
+  },
+  gemini: {
+    google: {
+      id: "google",
+      name: "Google",
+      api: "google",
+      models: {
+        "gemini-3-pro": reasoningModel("gemini-3-pro", "Gemini 3 Pro", "gemini", highReasoningEfforts)
+      }
+    }
+  }
+};
+function reasoningModel(id, name, family, supportedReasoningEfforts) {
+  return {
+    id,
+    name,
+    family,
+    status: "active",
+    reasoning: true,
+    toolCall: true,
+    supportedReasoningEfforts,
+    variants: { standard: {} }
+  };
+}
 var localToolAdapters = [
   {
     name: "opencode",
@@ -1734,13 +1886,15 @@ var localToolAdapters = [
     sdkDisplayCommand: "@opencode-ai/sdk createOpencode().client.session.prompt()",
     sdkRequiresExecutable: true,
     executable: "opencode",
+    supportsModelSelection: true,
     supportsSessionReuse: true,
     resumabilityScope: "localMachine",
+    providerCatalog: builtInProviderCatalogs.opencode,
     runWithSdk: runOpencodeSdk,
-    buildInvocation: ({ prompt }) => ({
+    buildInvocation: ({ prompt, model }) => ({
       command: "opencode",
-      args: ["run", prompt],
-      displayCommand: "opencode run <generated prompt>"
+      args: ["run", ...model ? ["--model", model] : [], prompt],
+      displayCommand: model ? "opencode run --model <selected model> <generated prompt>" : "opencode run <generated prompt>"
     })
   },
   {
@@ -1749,13 +1903,15 @@ var localToolAdapters = [
     sdkPackageName: "@anthropic-ai/claude-agent-sdk",
     sdkDisplayCommand: "@anthropic-ai/claude-agent-sdk query()",
     executable: "claude",
+    supportsModelSelection: true,
     supportsSessionReuse: false,
     resumabilityScope: "none",
+    providerCatalog: builtInProviderCatalogs.claude,
     runWithSdk: runClaudeSdk,
-    buildInvocation: ({ prompt }) => ({
+    buildInvocation: ({ prompt, model }) => ({
       command: "claude",
-      args: ["-p", prompt],
-      displayCommand: "claude -p <generated prompt>"
+      args: [...model ? ["--model", model] : [], "-p", prompt],
+      displayCommand: model ? "claude --model <selected model> -p <generated prompt>" : "claude -p <generated prompt>"
     })
   },
   {
@@ -1764,13 +1920,15 @@ var localToolAdapters = [
     sdkPackageName: "@openai/codex-sdk",
     sdkDisplayCommand: "@openai/codex-sdk Codex.startThread().run()",
     executable: "codex",
+    supportsModelSelection: true,
     supportsSessionReuse: false,
     resumabilityScope: "none",
+    providerCatalog: builtInProviderCatalogs.codex,
     runWithSdk: runCodexSdk,
-    buildInvocation: ({ prompt }) => ({
+    buildInvocation: ({ prompt, model }) => ({
       command: "codex",
-      args: ["exec", prompt],
-      displayCommand: "codex exec <generated prompt>"
+      args: ["exec", ...model ? ["--model", model] : [], prompt],
+      displayCommand: model ? "codex exec --model <selected model> <generated prompt>" : "codex exec <generated prompt>"
     })
   },
   {
@@ -1781,18 +1939,21 @@ var localToolAdapters = [
     supportsModelSelection: true,
     supportsSessionReuse: false,
     resumabilityScope: "none",
+    providerCatalog: builtInProviderCatalogs.copilot,
     runWithSdk: runCopilotSdk
   },
   {
     name: "gemini",
     description: "Gemini CLI adapter using prompt mode.",
     executable: "gemini",
+    supportsModelSelection: true,
     supportsSessionReuse: false,
     resumabilityScope: "none",
-    buildInvocation: ({ prompt }) => ({
+    providerCatalog: builtInProviderCatalogs.gemini,
+    buildInvocation: ({ prompt, model }) => ({
       command: "gemini",
-      args: ["-p", prompt],
-      displayCommand: "gemini -p <generated prompt>"
+      args: [...model ? ["--model", model] : [], "-p", prompt],
+      displayCommand: model ? "gemini --model <selected model> -p <generated prompt>" : "gemini -p <generated prompt>"
     })
   },
   {
@@ -1828,6 +1989,7 @@ async function detectLocalTools() {
     localToolAdapters.map(async (adapter) => {
       const sdkAvailable = await isSdkAvailable(adapter);
       const commandAvailable = adapter.executable ? await commandExists(adapter.executable) : false;
+      const providerCatalog = await detectProviderCatalog(adapter);
       return {
         name: adapter.name,
         description: adapter.description,
@@ -1837,7 +1999,8 @@ async function detectLocalTools() {
         execution: sdkAvailable ? "sdk" : commandAvailable ? "command" : "unavailable",
         supportsSessionReuse: Boolean(adapter.supportsSessionReuse),
         resumabilityScope: adapter.resumabilityScope ?? "none",
-        supportsModelSelection: Boolean(adapter.supportsModelSelection)
+        supportsModelSelection: Boolean(adapter.supportsModelSelection),
+        ...providerCatalog ? { providerCatalog } : {}
       };
     })
   );
@@ -1846,6 +2009,7 @@ 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");
+  const modelConfig = normalizeModelOptions(options);
   try {
     const runnerOptions = {
       rootDir: options.rootDir,
@@ -1853,7 +2017,7 @@ async function runLocalTool(options) {
       promptFilePath,
       tool: options.tool ?? "auto",
       invocationChannel: options.invocationChannel ?? "auto",
-      ...options.model ? { model: options.model } : {}
+      ...modelConfig
     };
     if (options.toolCommand) {
       runnerOptions.toolCommand = options.toolCommand;
@@ -1864,14 +2028,15 @@ async function runLocalTool(options) {
       prompt: options.prompt,
       promptFilePath,
       streamOutput: Boolean(options.streamOutput),
+      ...modelConfig,
       ...options.session ? { session: options.session } : {}
-    });
+    }, options.timeoutMs);
     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 } : {},
+      ...modelConfig,
       ...result
     };
   } finally {
@@ -1880,13 +2045,14 @@ async function runLocalTool(options) {
 }
 async function createToolRunPreview(options) {
   const promptFilePath = path5.join(os2.tmpdir(), "amistio-generated-prompt.md");
+  const modelConfig = normalizeModelOptions(options);
   const runnerOptions = {
     rootDir: options.rootDir,
     prompt: options.prompt,
     promptFilePath,
     tool: options.tool ?? "auto",
     invocationChannel: options.invocationChannel ?? "auto",
-    ...options.model ? { model: options.model } : {}
+    ...modelConfig
   };
   if (options.toolCommand) {
     runnerOptions.toolCommand = options.toolCommand;
@@ -1897,7 +2063,20 @@ async function createToolRunPreview(options) {
     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 } : {}
+    ...modelConfig
+  };
+}
+function normalizeModelOptions(options) {
+  const model = options.model?.trim() || (options.providerId?.trim() && options.modelId?.trim() ? `${options.providerId.trim()}/${options.modelId.trim()}` : options.modelId?.trim()) || void 0;
+  const providerId = options.providerId?.trim();
+  const modelId = options.modelId?.trim();
+  const modelVariant = options.modelVariant?.trim();
+  return {
+    ...model ? { model } : {},
+    ...providerId ? { providerId } : {},
+    ...modelId ? { modelId } : {},
+    ...modelVariant ? { modelVariant } : {},
+    ...options.reasoningEffort ? { reasoningEffort: options.reasoningEffort } : {}
   };
 }
 function createCustomToolInvocation(commandTemplate, input) {
@@ -1922,9 +2101,13 @@ 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(Boolean(options.model), options.invocationChannel) : await selectRequestedAdapter(tool, options.invocationChannel);
-  if (options.model && !adapter.supportsModelSelection) {
-    throw new Error(`Model selection is not supported by ${adapter.name}. Remove --model or choose a model-aware adapter.`);
+  const requiresModelSelection = Boolean(options.model || options.providerId || options.modelId || options.modelVariant || options.reasoningEffort && options.reasoningEffort !== "auto");
+  if (requiresModelSelection && !options.model) {
+    throw new Error("Provider-backed model configuration requires --model or --provider with --model-id.");
+  }
+  const adapter = tool === "auto" ? await selectFirstAvailableAdapter(requiresModelSelection, options.invocationChannel) : await selectRequestedAdapter(tool, options.invocationChannel);
+  if (requiresModelSelection && !adapter.supportsModelSelection) {
+    throw new Error(`Model selection is not supported by ${adapter.name}. Remove model configuration or choose a model-aware adapter.`);
   }
   if (options.invocationChannel !== "command" && adapter.runWithSdk && await isSdkAvailable(adapter)) {
     return {
@@ -1950,16 +2133,16 @@ 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(runner2, input) {
+async function executeToolRunner(runner2, input, timeoutMs) {
   if (runner2.kind === "command") {
-    return executeToolInvocation(runner2.invocation, input.rootDir, input.streamOutput);
+    return executeToolInvocation(runner2.invocation, input.rootDir, input.streamOutput, timeoutMs);
   }
   try {
-    return await runner2.adapter.runWithSdk(input);
+    return await withTimeout(runner2.adapter.runWithSdk(input), timeoutMs, runner2.displayCommand);
   } catch (error) {
     if (runner2.allowCommandFallback && 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 result = await executeToolInvocation(fallback, input.rootDir, input.streamOutput, timeoutMs);
       const sdkFailure = `SDK execution for ${runner2.adapter.name} failed, fell back to ${fallback.displayCommand}: ${errorMessage(error)}`;
       return {
         ...result,
@@ -2048,7 +2231,148 @@ async function commandExists(command) {
     lookup.on("close", (exitCode) => resolve(exitCode === 0));
   });
 }
-async function executeToolInvocation(invocation, rootDir, streamOutput) {
+async function detectProviderCatalog(adapter) {
+  const opencodeCatalog = adapter.name === "opencode" ? await loadOpencodeProviderCatalog() : void 0;
+  return mergeProviderCatalogs(adapter.providerCatalog, opencodeCatalog);
+}
+async function loadOpencodeProviderCatalog() {
+  const configPaths = [
+    path5.join(os2.homedir(), ".config", "opencode", "opencode.json"),
+    path5.join(os2.homedir(), ".config", "opencode", "config.json"),
+    path5.join(process.cwd(), "opencode.json")
+  ];
+  for (const configPath of configPaths) {
+    try {
+      const parsed = JSON.parse(await readFile3(configPath, "utf8"));
+      const providerValue = isRecord(parsed) ? parsed.provider : void 0;
+      const catalog = sanitizeProviderCatalog(providerValue);
+      if (catalog) return catalog;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function mergeProviderCatalogs(...catalogs) {
+  const merged = {};
+  for (const catalog of catalogs) {
+    if (!catalog) continue;
+    for (const [providerId, provider] of Object.entries(catalog)) {
+      const existing = isRecord(merged[providerId]) ? merged[providerId] : void 0;
+      const existingModels = existing && isRecord(existing.models) ? existing.models : {};
+      merged[providerId] = {
+        ...existing,
+        ...provider,
+        id: provider.id ?? providerId,
+        models: { ...existingModels, ...provider.models }
+      };
+    }
+  }
+  const parsed = runnerProviderCatalogSchema.safeParse(merged);
+  return parsed.success && Object.keys(parsed.data).length ? parsed.data : void 0;
+}
+function sanitizeProviderCatalog(value) {
+  if (!isRecord(value)) return void 0;
+  const catalog = {};
+  for (const [providerId, providerValue] of Object.entries(value)) {
+    const provider = sanitizeProviderConfig(providerId, providerValue);
+    if (provider) catalog[providerId] = provider;
+  }
+  const parsed = runnerProviderCatalogSchema.safeParse(catalog);
+  return parsed.success && Object.keys(parsed.data).length ? parsed.data : void 0;
+}
+function sanitizeProviderConfig(providerId, value) {
+  if (!isRecord(value)) return void 0;
+  const models = sanitizeProviderModels(value.models);
+  if (!Object.keys(models).length) return void 0;
+  return {
+    id: stringValue(value.id) ?? providerId,
+    ...stringValue(value.name) ? { name: stringValue(value.name) } : {},
+    ...stringValue(value.api) ? { api: stringValue(value.api) } : {},
+    models
+  };
+}
+function sanitizeProviderModels(value) {
+  if (!isRecord(value)) return {};
+  const models = {};
+  for (const [modelId, modelValue] of Object.entries(value)) {
+    const model = sanitizeProviderModel(modelId, modelValue);
+    if (model) models[modelId] = model;
+  }
+  return models;
+}
+function sanitizeProviderModel(modelId, value) {
+  if (!isRecord(value)) return void 0;
+  const reasoning = booleanValue(value.reasoning);
+  const releaseDate = stringValue(value.release_date) ?? stringValue(value.releaseDate);
+  const toolCall = booleanValue(value.tool_call) ?? booleanValue(value.toolCall);
+  const limit = sanitizeLimit(value.limit);
+  const modalities = sanitizeModalities(value.modalities);
+  const variants = sanitizeVariants(value.variants);
+  const model = {
+    id: stringValue(value.id) ?? modelId,
+    ...stringValue(value.name) ? { name: stringValue(value.name) } : {},
+    ...stringValue(value.family) ? { family: stringValue(value.family) } : {},
+    ...releaseDate ? { releaseDate } : {},
+    ...booleanValue(value.attachment) !== void 0 ? { attachment: booleanValue(value.attachment) } : {},
+    ...reasoning !== void 0 ? { reasoning } : {},
+    ...booleanValue(value.temperature) !== void 0 ? { temperature: booleanValue(value.temperature) } : {},
+    ...toolCall !== void 0 ? { toolCall } : {},
+    ...stringValue(value.status) ? { status: stringValue(value.status) } : {},
+    ...limit ? { limit } : {},
+    ...modalities ? { modalities } : {},
+    ...variants ? { variants } : {}
+  };
+  const supportedReasoningEfforts = sanitizeReasoningEfforts(value.supportedReasoningEfforts) ?? sanitizeReasoningEfforts(value.supported_reasoning_efforts) ?? (reasoning ? allReasoningEfforts : void 0);
+  if (supportedReasoningEfforts) model.supportedReasoningEfforts = supportedReasoningEfforts;
+  return model;
+}
+function sanitizeLimit(value) {
+  if (!isRecord(value)) return void 0;
+  const limit = {
+    ...numberValue(value.context) !== void 0 ? { context: numberValue(value.context) } : {},
+    ...numberValue(value.input) !== void 0 ? { input: numberValue(value.input) } : {},
+    ...numberValue(value.output) !== void 0 ? { output: numberValue(value.output) } : {}
+  };
+  return Object.keys(limit).length ? limit : void 0;
+}
+function sanitizeModalities(value) {
+  if (!isRecord(value)) return void 0;
+  const modalities = {
+    ...stringArrayValue(value.input) ? { input: stringArrayValue(value.input) } : {},
+    ...stringArrayValue(value.output) ? { output: stringArrayValue(value.output) } : {}
+  };
+  return Object.keys(modalities).length ? modalities : void 0;
+}
+function sanitizeVariants(value) {
+  if (!isRecord(value)) return void 0;
+  const variants = {};
+  for (const [variantId, variantValue] of Object.entries(value)) {
+    variants[variantId] = isRecord(variantValue) && booleanValue(variantValue.disabled) !== void 0 ? { disabled: booleanValue(variantValue.disabled) } : {};
+  }
+  return Object.keys(variants).length ? variants : void 0;
+}
+function sanitizeReasoningEfforts(value) {
+  const values = stringArrayValue(value);
+  if (!values) return void 0;
+  const efforts = values.filter((candidate) => allReasoningEfforts.includes(candidate));
+  return efforts.length ? efforts : void 0;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : void 0;
+}
+function booleanValue(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function stringArrayValue(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+}
+async function executeToolInvocation(invocation, rootDir, streamOutput, timeoutMs) {
   return new Promise((resolve, reject) => {
     const child = spawn(invocation.command, invocation.args, {
       cwd: rootDir,
@@ -2058,7 +2382,33 @@ async function executeToolInvocation(invocation, rootDir, streamOutput) {
     });
     let stdout = "";
     let stderr = "";
-    child.on("error", reject);
+    let settled = false;
+    let forceKillTimer;
+    const timeout = timeoutMs && timeoutMs > 0 ? setTimeout(() => {
+      if (settled) return;
+      stderr += `${toolTimeoutMessage(invocation.displayCommand, timeoutMs)}
+`;
+      child.kill("SIGTERM");
+      forceKillTimer = setTimeout(() => child.kill("SIGKILL"), 5e3);
+      forceKillTimer.unref?.();
+      rejectOnce(new Error(toolTimeoutMessage(invocation.displayCommand, timeoutMs)));
+    }, timeoutMs) : void 0;
+    timeout?.unref?.();
+    const resolveOnce = (value) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      resolve(value);
+    };
+    const rejectOnce = (error) => {
+      if (settled) return;
+      settled = true;
+      if (timeout) clearTimeout(timeout);
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      reject(error);
+    };
+    child.on("error", rejectOnce);
     child.stdout.setEncoding("utf8");
     child.stderr.setEncoding("utf8");
     child.stdout.on("data", (chunk) => {
@@ -2079,10 +2429,40 @@ async function executeToolInvocation(invocation, rootDir, streamOutput) {
     }
     child.stdin.end();
     child.on("close", (exitCode) => {
-      resolve({ exitCode: exitCode ?? 1, stdout, stderr });
+      if (forceKillTimer) clearTimeout(forceKillTimer);
+      resolveOnce({ exitCode: exitCode ?? 1, stdout, stderr });
     });
   });
 }
+async function withTimeout(promise, timeoutMs, displayCommand) {
+  if (!timeoutMs || timeoutMs <= 0) {
+    return promise;
+  }
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error(toolTimeoutMessage(displayCommand, timeoutMs))), timeoutMs);
+    timeout.unref?.();
+    promise.then(
+      (value) => {
+        clearTimeout(timeout);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      }
+    );
+  });
+}
+function toolTimeoutMessage(displayCommand, timeoutMs) {
+  return `Local tool timed out after ${formatTimeoutDuration(timeoutMs)}: ${displayCommand}`;
+}
+function formatTimeoutDuration(timeoutMs) {
+  if (timeoutMs < 1e3) {
+    return `${timeoutMs}ms`;
+  }
+  const seconds = timeoutMs / 1e3;
+  return Number.isInteger(seconds) ? `${seconds}s` : `${seconds.toFixed(1)}s`;
+}
 async function runOpencodeSdk(input) {
   const { createOpencode } = await import("@opencode-ai/sdk");
   const previousDirectory = process.cwd();
@@ -2170,7 +2550,7 @@ async function runCodexSdk(input) {
   return { exitCode: 0, stdout: result.finalResponse, stderr: "" };
 }
 async function runCopilotSdk(input) {
-  const { CopilotClient, approveAll } = await import("@github/copilot-sdk");
+  const { CopilotClient } = await import("@github/copilot-sdk");
   const client = new CopilotClient({
     cwd: input.rootDir,
     logLevel: "error"
@@ -2183,7 +2563,7 @@ async function runCopilotSdk(input) {
       workingDirectory: input.rootDir,
       enableConfigDiscovery: true,
       streaming: input.streamOutput,
-      onPermissionRequest: approveAll
+      onPermissionRequest: createCopilotPermissionHandler()
     });
     try {
       let streamedOutput = "";
@@ -2205,15 +2585,24 @@ async function runCopilotSdk(input) {
     await client.stop();
   }
 }
+function createCopilotPermissionHandler(env = process.env) {
+  const allowAllPermissions = isCopilotApproveAllEnabled(env);
+  return (request) => {
+    if (allowAllPermissions || request.kind === "read") {
+      return { kind: "approve-once" };
+    }
+    return { kind: "reject" };
+  };
+}
+function isCopilotApproveAllEnabled(env = process.env) {
+  return /^(1|true|yes)$/i.test(env.AMISTIO_COPILOT_APPROVE_ALL ?? "");
+}
 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);
 }
@@ -2225,7 +2614,7 @@ function shellQuote(value) {
 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 { mkdir as mkdir5, readdir as readdir2, readFile as readFile4, writeFile as writeFile5 } from "node:fs/promises";
 import os3 from "node:os";
 import path6 from "node:path";
 function currentRunnerMode() {
@@ -2392,7 +2781,7 @@ function runnerDaemonKey(input) {
 }
 async function readRunnerDaemonMetadataFile(filePath) {
   try {
-    const parsed = JSON.parse(await readFile3(filePath, "utf8"));
+    const parsed = JSON.parse(await readFile4(filePath, "utf8"));
     if (parsed.schemaVersion !== 1 || !parsed.runnerId || !parsed.projectId || !parsed.repositoryLinkId) {
       return void 0;
     }
@@ -2405,7 +2794,7 @@ async function readRunnerDaemonMetadataFile(filePath) {
 // src/runner-service.ts
 import { spawn as spawn3 } from "node:child_process";
 import { createHash as createHash3 } from "node:crypto";
-import { mkdir as mkdir6, readFile as readFile4, rm as rm2, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir6, readFile as readFile5, rm as rm2, writeFile as writeFile6 } from "node:fs/promises";
 import os4 from "node:os";
 import path7 from "node:path";
 function detectRunnerServicePlatform(platform = process.platform) {
@@ -2471,7 +2860,7 @@ async function removeRunnerService(input) {
 }
 async function readRunnerServiceMetadata(input, metadataDir = defaultRunnerMetadataDir()) {
   try {
-    const parsed = JSON.parse(await readFile4(runnerServiceMetadataPath(input, metadataDir), "utf8"));
+    const parsed = JSON.parse(await readFile5(runnerServiceMetadataPath(input, metadataDir), "utf8"));
     if (parsed.schemaVersion !== 1 || !parsed.serviceName || !parsed.serviceFilePath) {
       return void 0;
     }
@@ -2751,10 +3140,28 @@ function tokens(value) {
 }
 
 // src/sync.ts
-import { mkdir as mkdir7, readdir as readdir3, readFile as readFile5, stat as stat3, writeFile as writeFile7 } from "node:fs/promises";
+import { execFile as execFile3 } from "node:child_process";
+import { createHash as createHash4 } from "node:crypto";
+import { mkdir as mkdir7, readdir as readdir3, readFile as readFile6, stat as stat3, writeFile as writeFile7 } from "node:fs/promises";
 import path8 from "node:path";
+import { promisify as promisify3 } from "node:util";
+var execFileAsync3 = promisify3(execFile3);
 var legacySyncRoots = ["architecture", "context", "decisions", "features", "memory", "plans", "prompts", "workflows"];
 var syncRoots = legacySyncRoots.map((syncRoot) => `docs/${syncRoot}`);
+var documentTypeByRoot = {
+  architecture: "architecture",
+  context: "context",
+  decisions: "decision",
+  features: "feature",
+  memory: "memory",
+  plans: "plan",
+  prompts: "prompt",
+  workflows: "workflow"
+};
+var autoSyncMetadataPaths = /* @__PURE__ */ new Set(["docs/context/amistio-project.md", "context/amistio-project.md"]);
+var autoSyncExcludedDirectoryNames = /* @__PURE__ */ new Set([".git", "node_modules", ".pnpm-store", ".next", "dist", "build", "coverage", ".cache", "cache", "tmp", "temp", "vendor"]);
+var autoSyncGeneratedPathSegments = /* @__PURE__ */ new Set(["generated", "__generated__", "vendor", "vendors"]);
+var defaultAutoSyncMaxFileKb = 256;
 async function collectSyncStatus(rootDir, webDocuments = []) {
   const localDocuments = await readLocalSyncedDocuments(rootDir);
   const normalizedWebDocuments = webDocuments.map((document) => ({ ...document, repoPath: canonicalControlPlaneRepoPath(document.repoPath) }));
@@ -2831,7 +3238,7 @@ async function readLocalSyncedDocuments(rootDir) {
   const markdownFiles = await findMarkdownFiles(rootDir);
   const documents = [];
   for (const fullPath of markdownFiles) {
-    const raw = await readFile5(fullPath, "utf8");
+    const raw = await readFile6(fullPath, "utf8");
     const parsed = parseSyncedMarkdown(raw);
     if (!parsed) {
       continue;
@@ -2914,6 +3321,29 @@ async function collectDirtyDocumentsForPush(rootDir, metadata) {
     });
   });
 }
+async function collectAutoSyncDocumentsForPush(rootDir, metadata, existingDocuments = [], options = {}) {
+  const dirtyDocuments = await collectDirtyDocumentsForPush(rootDir, metadata);
+  const external = await collectExternalBrainDocumentsForPush(rootDir, metadata, existingDocuments, options);
+  return {
+    documents: [...dirtyDocuments, ...external.documents],
+    managedDocumentIds: dirtyDocuments.map((document) => document.documentId),
+    skipped: external.skipped,
+    counts: autoSyncSkipCounts(external.skipped)
+  };
+}
+function autoSyncSkipCounts(skipped) {
+  return {
+    metadata: skipped.filter((item) => item.reason === "metadata").length,
+    template: skipped.filter((item) => item.reason === "template").length,
+    unsupported: skipped.filter((item) => item.reason === "unsupported").length,
+    tooLarge: skipped.filter((item) => item.reason === "tooLarge").length,
+    alreadyManaged: skipped.filter((item) => item.reason === "alreadyManaged").length,
+    unchanged: skipped.filter((item) => item.reason === "unchanged").length,
+    conflicted: skipped.filter((item) => item.reason === "conflicted").length,
+    excluded: skipped.filter((item) => item.reason === "excluded").length,
+    unreadable: skipped.filter((item) => item.reason === "unreadable").length
+  };
+}
 function createSyncedDocumentMarkdown(document) {
   return [
     "---",
@@ -2943,7 +3373,7 @@ function parseSyncedMarkdown(content) {
 }
 async function readExistingSyncedDocument(fullPath) {
   try {
-    const raw = await readFile5(fullPath, "utf8");
+    const raw = await readFile6(fullPath, "utf8");
     const parsed = parseSyncedMarkdown(raw);
     if (!parsed) {
       return { exists: true };
@@ -3020,6 +3450,145 @@ function inferTitle(content, repoPath) {
   const heading = content.split("\n").find((line) => line.startsWith("# "))?.replace(/^#\s+/, "").trim();
   return heading || path8.basename(repoPath, path8.extname(repoPath));
 }
+async function collectExternalBrainDocumentsForPush(rootDir, metadata, existingDocuments, options) {
+  const root = path8.resolve(rootDir);
+  const maxBytes = (options.maxFileKb ?? defaultAutoSyncMaxFileKb) * 1024;
+  const syncedAt = options.syncedAt ?? (/* @__PURE__ */ new Date()).toISOString();
+  const existingById = new Map(existingDocuments.map((document) => [document.documentId, document]));
+  const repoPaths = await listAutoSyncCandidatePaths(root);
+  const documents = [];
+  const skipped = [];
+  for (const repoPath of repoPaths) {
+    const normalizedRepoPath = normalizeRepoPath3(repoPath);
+    const canonicalRepoPath = canonicalControlPlaneRepoPath(normalizedRepoPath);
+    const skipReason = autoSyncPathSkipReason(normalizedRepoPath);
+    if (skipReason) {
+      skipped.push({ repoPath: normalizedRepoPath, reason: skipReason });
+      continue;
+    }
+    const fullPath = safeRepoPath(root, normalizedRepoPath);
+    const fileStat = await stat3(fullPath).catch(() => void 0);
+    if (!fileStat?.isFile()) {
+      skipped.push({ repoPath: normalizedRepoPath, reason: "unreadable" });
+      continue;
+    }
+    if (fileStat.size > maxBytes) {
+      skipped.push({ repoPath: normalizedRepoPath, reason: "tooLarge" });
+      continue;
+    }
+    const content = await readFile6(fullPath, "utf8").catch(() => void 0);
+    if (content === void 0) {
+      skipped.push({ repoPath: normalizedRepoPath, reason: "unreadable" });
+      continue;
+    }
+    if (parseSyncedMarkdown(content)) {
+      skipped.push({ repoPath: normalizedRepoPath, reason: "alreadyManaged" });
+      continue;
+    }
+    const documentType = documentTypeForRepoPath(canonicalRepoPath);
+    if (!documentType) {
+      skipped.push({ repoPath: normalizedRepoPath, reason: "unsupported" });
+      continue;
+    }
+    const contentHash = sha256ContentHash(content);
+    const documentId = stableExternalDocumentId(metadata, canonicalRepoPath);
+    const existing = existingById.get(documentId);
+    if (existing?.syncState === "conflicted" || existing?.status === "conflicted") {
+      skipped.push({ repoPath: normalizedRepoPath, reason: "conflicted" });
+      continue;
+    }
+    const lastAutoSyncedHash = typeof existing?.frontmatter.autoSyncedSourceHash === "string" ? existing.frontmatter.autoSyncedSourceHash : void 0;
+    if (existing?.contentHash === contentHash || lastAutoSyncedHash === contentHash) {
+      skipped.push({ repoPath: normalizedRepoPath, reason: "unchanged" });
+      continue;
+    }
+    const revision = existing ? existing.revision + 1 : 0;
+    documents.push(brainDocumentItemSchema.parse({
+      id: documentId,
+      type: "brainDocument",
+      schemaVersion: 1,
+      accountId: metadata.amistioAccountId,
+      projectId: metadata.amistioProjectId,
+      documentId,
+      documentType,
+      title: inferTitle(content, canonicalRepoPath),
+      status: "reviewing",
+      repoPath: canonicalRepoPath,
+      content,
+      contentHash,
+      frontmatter: {
+        ...existing?.frontmatter ?? {},
+        externalBrainPath: normalizedRepoPath,
+        autoSyncedByCommand: "amistio sync watch",
+        autoSyncedAt: syncedAt,
+        autoSyncedSourceHash: contentHash,
+        ...lastAutoSyncedHash ? { amistioContentHash: lastAutoSyncedHash } : {}
+      },
+      revision,
+      source: "repo",
+      syncState: "dirtyInRepo",
+      createdAt: existing?.createdAt ?? syncedAt,
+      updatedAt: syncedAt
+    }));
+  }
+  return { documents, skipped };
+}
+async function listAutoSyncCandidatePaths(rootDir) {
+  const gitFiles = await execFileAsync3("git", ["-C", rootDir, "ls-files", "--cached", "--others", "--exclude-standard"]).then(({ stdout }) => stdout).catch(() => void 0);
+  if (gitFiles !== void 0) {
+    return uniqueSortedRepoPaths(gitFiles.split("\n").map(normalizeRepoPath3).filter((repoPath) => repoPath && isRecognizedBrainRepoPath(repoPath)));
+  }
+  const files = [];
+  for (const syncRoot of [...syncRoots, ...legacySyncRoots]) {
+    const fullRoot = path8.join(rootDir, syncRoot);
+    if (await exists2(fullRoot)) {
+      await walkAutoSyncFiles(rootDir, fullRoot, files);
+    }
+  }
+  return uniqueSortedRepoPaths(files);
+}
+async function walkAutoSyncFiles(rootDir, directory, files) {
+  for (const entry of await readdir3(directory, { withFileTypes: true }).catch(() => [])) {
+    const fullPath = path8.join(directory, entry.name);
+    const repoPath = normalizeRepoPath3(path8.relative(rootDir, fullPath));
+    if (entry.isDirectory()) {
+      if (!autoSyncExcludedDirectoryNames.has(entry.name)) {
+        await walkAutoSyncFiles(rootDir, fullPath, files);
+      }
+    } else if (entry.isFile() && isRecognizedBrainRepoPath(repoPath)) {
+      files.push(repoPath);
+    }
+  }
+}
+function autoSyncPathSkipReason(repoPath) {
+  if (autoSyncMetadataPaths.has(repoPath)) return "metadata";
+  if (isControlPlaneTemplateRepoPath(repoPath)) return "template";
+  if (!/\.(md|mdx)$/i.test(repoPath)) return "unsupported";
+  const basename = repoPath.split("/").at(-1)?.toLowerCase() ?? "";
+  if (basename.startsWith(".") || basename.endsWith(".lock") || basename.includes(".env") || basename.includes("secret") || basename.includes("credential")) return "excluded";
+  if (repoPath.split("/").some((segment) => autoSyncExcludedDirectoryNames.has(segment) || autoSyncGeneratedPathSegments.has(segment))) return "excluded";
+  return void 0;
+}
+function isRecognizedBrainRepoPath(repoPath) {
+  const normalized = normalizeRepoPath3(repoPath);
+  const [firstSegment, secondSegment] = normalized.split("/");
+  return Boolean(firstSegment === "docs" && secondSegment && legacySyncRoots.includes(secondSegment) || firstSegment && legacySyncRoots.includes(firstSegment));
+}
+function documentTypeForRepoPath(repoPath) {
+  const normalized = normalizeRepoPath3(repoPath);
+  const segments = normalized.split("/");
+  const root = segments[0] === "docs" ? segments[1] : segments[0];
+  return root && root in documentTypeByRoot ? documentTypeByRoot[root] : void 0;
+}
+function stableExternalDocumentId(metadata, repoPath) {
+  return `doc_external_${createHash4("sha256").update(`${metadata.amistioAccountId}:${metadata.amistioProjectId}:${metadata.repositoryLinkId}:${repoPath}`).digest("hex").slice(0, 24)}`;
+}
+function normalizeRepoPath3(repoPath) {
+  return repoPath.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+}
+function uniqueSortedRepoPaths(repoPaths) {
+  return [...new Set(repoPaths)].sort((first, second) => first.localeCompare(second));
+}
 function parseFrontmatterFromSyncedDocument(frontmatter) {
   return {
     amistioDocumentId: frontmatter.amistioDocumentId,
@@ -3039,7 +3608,7 @@ async function exists2(filePath) {
 }
 
 // src/tool-session-store.ts
-import { mkdir as mkdir8, readFile as readFile6, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile7, writeFile as writeFile8 } from "node:fs/promises";
 import os5 from "node:os";
 import path9 from "node:path";
 var LocalToolSessionStore = class {
@@ -3060,7 +3629,7 @@ var LocalToolSessionStore = class {
   }
   async read() {
     try {
-      return JSON.parse(await readFile6(this.filePath, "utf8"));
+      return JSON.parse(await readFile7(this.filePath, "utf8"));
     } catch {
       return {};
     }
@@ -3360,7 +3929,7 @@ function stripJsonFence(value) {
 }
 
 // src/runner-status.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 var watchStateReminderMs = 60 * 1e3;
 function formatWatchStartupContext(input) {
   return [
@@ -3381,7 +3950,7 @@ function watchStateKey(action) {
   return [action.kind, action.message, action.workItemId, action.documentId, action.runnerId].filter(Boolean).join(":");
 }
 function stableRunnerId(input) {
-  const digest = createHash4("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.machineId}`).digest("hex").slice(0, 20);
+  const digest = createHash5("sha256").update(`${input.accountId}:${input.projectId}:${input.repositoryLinkId}:${input.machineId}`).digest("hex").slice(0, 20);
   return `runner_${digest}`;
 }
 
@@ -3505,12 +4074,12 @@ function roundNumber(value, digits) {
 }
 
 // src/importer.ts
-import { execFile as execFile3 } from "node:child_process";
-import { createHash as createHash5 } from "node:crypto";
-import { readdir as readdir4, readFile as readFile7, stat as stat4 } from "node:fs/promises";
+import { execFile as execFile4 } from "node:child_process";
+import { createHash as createHash6 } from "node:crypto";
+import { readdir as readdir4, readFile as readFile8, stat as stat4 } from "node:fs/promises";
 import path10 from "node:path";
-import { promisify as promisify3 } from "node:util";
-var execFileAsync3 = promisify3(execFile3);
+import { promisify as promisify4 } from "node:util";
+var execFileAsync4 = promisify4(execFile4);
 var defaultMaxFileKb = 256;
 var controlPlaneRoots2 = ["architecture", "context", "decisions", "features", "memory", "plans", "prompts", "workflows"];
 var excludedDirectoryNames = /* @__PURE__ */ new Set([".git", "node_modules", ".pnpm-store", ".next", "dist", "build", "coverage", ".cache", "cache", "tmp", "temp", "vendor"]);
@@ -3573,7 +4142,7 @@ async function scanLegacyDocuments(options) {
       skipped.push({ repoPath, reason: "tooLarge" });
       continue;
     }
-    const content = await readFile7(fullPath, "utf8").catch(() => void 0);
+    const content = await readFile8(fullPath, "utf8").catch(() => void 0);
     if (content === void 0) {
       skipped.push({ repoPath, reason: "unreadable" });
       continue;
@@ -3654,7 +4223,7 @@ function parseOptionalOriginCloneUrl(originUrl) {
 async function listRepositoryPaths(rootDir) {
   const gitFiles = await runGit2(["-C", rootDir, "ls-files", "--cached", "--others", "--exclude-standard"]).catch(() => void 0);
   if (gitFiles !== void 0) {
-    return gitFiles.split("\n").map((line) => normalizeRepoPath3(line)).filter((line) => line.length > 0);
+    return gitFiles.split("\n").map((line) => normalizeRepoPath4(line)).filter((line) => line.length > 0);
   }
   const files = [];
   await walkRepository(rootDir, rootDir, files);
@@ -3664,7 +4233,7 @@ async function walkRepository(rootDir, directory, files) {
   const entries = await readdir4(directory, { withFileTypes: true }).catch(() => []);
   for (const entry of entries) {
     const fullPath = path10.join(directory, entry.name);
-    const repoPath = normalizeRepoPath3(path10.relative(rootDir, fullPath));
+    const repoPath = normalizeRepoPath4(path10.relative(rootDir, fullPath));
     if (entry.isDirectory()) {
       if (!excludedDirectoryNames.has(entry.name)) {
         await walkRepository(rootDir, fullPath, files);
@@ -3684,7 +4253,7 @@ function matchesIncludeExclude(repoPath, include, exclude) {
   return true;
 }
 function wildcardMatch(pattern, repoPath) {
-  const normalizedPattern = normalizeRepoPath3(pattern);
+  const normalizedPattern = normalizeRepoPath4(pattern);
   const escaped = normalizedPattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "::DOUBLE_STAR_SLASH::").replace(/\*\*/g, "::DOUBLE_STAR::").replace(/\?/g, "[^/]").replace(/\*/g, "[^/]*").replace(/::DOUBLE_STAR_SLASH::/g, "(?:.*/)?").replace(/::DOUBLE_STAR::/g, ".*");
   return new RegExp(`^${escaped}$`).test(repoPath);
 }
@@ -3737,7 +4306,7 @@ function uniqueDestinationPath(basePath, sourcePath, usedPaths) {
   return uniquePath;
 }
 function isCanonicalControlPlanePath(repoPath) {
-  const [firstSegment, secondSegment] = normalizeRepoPath3(repoPath).split("/");
+  const [firstSegment, secondSegment] = normalizeRepoPath4(repoPath).split("/");
   return firstSegment === "docs" && Boolean(secondSegment && controlPlaneRoots2.includes(secondSegment));
 }
 function isLegacyControlPlanePath(repoPath) {
@@ -3770,13 +4339,13 @@ function stableImportDocumentId(accountId, projectId, repositoryLinkId, sourcePa
   return `doc_import_${hashText(`${accountId}\0${projectId}\0${repositoryLinkId}\0${sourcePath}`, 24)}`;
 }
 function hashText(value, length) {
-  return createHash5("sha256").update(value).digest("hex").slice(0, length);
+  return createHash6("sha256").update(value).digest("hex").slice(0, length);
 }
-function normalizeRepoPath3(value) {
+function normalizeRepoPath4(value) {
   return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
 }
 async function runGit2(args) {
-  const { stdout } = await execFileAsync3("git", args, { maxBuffer: 10 * 1024 * 1024 });
+  const { stdout } = await execFileAsync4("git", args, { maxBuffer: 10 * 1024 * 1024 });
   return stdout.trim();
 }
 
@@ -3810,9 +4379,24 @@ function buildBackgroundRunnerArgs(options) {
   if (options.model) {
     args.push("--model", options.model);
   }
+  const providerId = options.providerId ?? options.provider;
+  if (providerId) {
+    args.push("--provider", providerId);
+  }
+  if (options.modelId) {
+    args.push("--model-id", options.modelId);
+  }
+  if (options.modelVariant) {
+    args.push("--model-variant", options.modelVariant);
+  }
+  if (options.reasoningEffort) {
+    args.push("--reasoning-effort", options.reasoningEffort);
+  }
   if (options.maxIterations !== void 0) {
     args.push("--max-iterations", String(options.maxIterations));
   }
+  args.push("--max-preflight-attempts", String(options.maxPreflightAttempts));
+  args.push("--tool-timeout-seconds", String(options.toolTimeoutSeconds));
   if (!options.stream) {
     args.push("--no-stream");
   }
@@ -3858,11 +4442,11 @@ function truncateProcessOutput(value) {
 }
 
 // src/git-worktree.ts
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 import { mkdir as mkdir9, stat as stat5 } from "node:fs/promises";
 import path12 from "node:path";
-import { promisify as promisify4 } from "node:util";
-var execFileAsync4 = promisify4(execFile4);
+import { promisify as promisify5 } from "node:util";
+var execFileAsync5 = promisify5(execFile5);
 function needsGitWorktreeIsolation(workItem) {
   return (workItem.workKind ?? "implementation") === "implementation";
 }
@@ -3923,11 +4507,11 @@ async function assertBaseRevision(repoRoot, baseRevision, currentHead) {
   }
 }
 async function gitOutput(cwd, args) {
-  const { stdout } = await execFileAsync4("git", args, { cwd, maxBuffer: 1024 * 1024 });
+  const { stdout } = await execFileAsync5("git", args, { cwd, maxBuffer: 1024 * 1024 });
   return stdout.trim();
 }
 async function gitCommandSucceeds(cwd, args) {
-  return execFileAsync4("git", args, { cwd }).then(() => true, () => false);
+  return execFileAsync5("git", args, { cwd }).then(() => true, () => false);
 }
 async function pathExists(value) {
   return stat5(value).then(() => true, () => false);
@@ -3960,6 +4544,10 @@ var CLI_VERSION = readCliPackageVersion();
 var program = new Command();
 var defaultRoot = process.env.INIT_CWD ?? process.cwd();
 var apiUrlOptionDescription = `Amistio API URL override (or ${AMISTIO_API_URL_ENV})`;
+var DEFAULT_MAX_PREFLIGHT_ATTEMPTS = 3;
+var DEFAULT_TOOL_TIMEOUT_SECONDS = 30 * 60;
+var RUNNER_WORK_LEASE_SECONDS = 300;
+var RUNNER_WORK_LEASE_RENEWAL_MS = 12e4;
 program.name("amistio").description("Amistio project brain CLI").version(CLI_VERSION);
 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);
@@ -3986,7 +4574,8 @@ program.command("bootstrap").description("Clone a linked repository locally, pre
     repositoryLinkId: options.repositoryLink,
     repoName: parsedRepoUrl.repoName,
     repoFingerprint: createRepoFingerprint(options.account, options.project, options.repositoryLink),
-    defaultBranch: options.defaultBranch
+    defaultBranch: options.defaultBranch,
+    machineId: runnerMachineId()
   });
   const filePath = await writeProjectLink(checkout.targetDir, {
     amistioAccountId: options.account,
@@ -4038,6 +4627,7 @@ program.command("import").description("Pair an existing checkout and import lega
     repoName: repository.repoName,
     repoFingerprint: repository.repoFingerprint,
     defaultBranch: repository.defaultBranch,
+    machineId: runnerMachineId(),
     ...parsedCloneUrl ? { cloneUrl: parsedCloneUrl.cloneUrl } : {},
     ...parsedCloneUrl?.provider ? { provider: parsedCloneUrl.provider } : {},
     ...parsedCloneUrl?.repoOwner ? { repoOwner: parsedCloneUrl.repoOwner } : {},
@@ -4084,7 +4674,8 @@ program.command("pair").description("Pair this repository with an Amistio web pr
       repositoryLinkId,
       repoName: inferRepoName(pairingRoot),
       repoFingerprint: createRepoFingerprint(options.account, options.project, repositoryLinkId),
-      defaultBranch: options.defaultBranch
+      defaultBranch: options.defaultBranch,
+      machineId: runnerMachineId()
     });
     repositoryLinkId = pairing.repositoryLink.repositoryLinkId;
     credential = credential ?? pairing.token;
@@ -4175,6 +4766,45 @@ sync.command("push").description("Push local brain changes to Amistio for review
   await materializeBrainDocuments(options.root, documents, { allowDirtyOverwrite: true });
   console.log(`Pushed ${documents.length} local document${documents.length === 1 ? "" : "s"} for web review.`);
 });
+sync.command("watch").description("Watch repository brain folders and auto-sync eligible local changes").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--root <path>", "Repository root", defaultRoot).option("--runner-id <runnerId>", "Stable watcher runner ID").option("--interval-seconds <seconds>", "Polling interval", parsePositiveInteger, 10).option("--max-iterations <count>", "Stop watch mode after this many polling attempts", parsePositiveInteger).option("--max-file-kb <kb>", "Maximum Markdown/MDX file size to auto-sync", parsePositiveInteger, 256).option("--once", "Run one auto-sync cycle and exit").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;
+  }
+  const runnerId = options.runnerId ?? stableRunnerId({
+    accountId: context.metadata.amistioAccountId,
+    projectId: context.metadata.amistioProjectId,
+    repositoryLinkId: context.metadata.repositoryLinkId,
+    machineId: runnerMachineId()
+  });
+  console.log(`Auto-sync watcher: ${runnerId}`);
+  console.log(`Project: ${context.metadata.amistioProjectId}`);
+  console.log(`Repository link: ${context.metadata.repositoryLinkId}`);
+  let iterations = 0;
+  while (true) {
+    iterations += 1;
+    const result = await runAutoSyncCycle({
+      context,
+      maxFileKb: options.maxFileKb,
+      quietDisabled: false,
+      root: options.root,
+      runnerId
+    });
+    console.log(formatAutoSyncCycleResult(result));
+    if (options.once || result.status === "disabled") return;
+    if (options.maxIterations !== void 0 && iterations >= options.maxIterations) {
+      console.log(`Auto-sync watcher stopped after ${iterations} polling attempt${iterations === 1 ? "" : "s"}.`);
+      return;
+    }
+    await delay(options.intervalSeconds * 1e3);
+  }
+});
 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);
@@ -4231,7 +4861,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("--invocation-channel <channel>", "Local invocation channel: auto, sdk, or command", parseInvocationChannel, "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) => {
+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("--invocation-channel <channel>", "Local invocation channel: auto, sdk, or command", parseInvocationChannel, "auto").option("--model <model>", "Model to request when the selected local tool supports model selection").option("--provider <providerId>", "Provider id for provider-backed model configuration").option("--model-id <modelId>", "Provider catalog model id to request").option("--model-variant <variant>", "Provider catalog model variant to request").option("--reasoning-effort <effort>", "Reasoning effort: auto, low, medium, high, or xhigh", parseReasoningEffort).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) {
@@ -4243,7 +4873,8 @@ 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, invocationChannel: options.invocationChannel, ...options.toolCommand ? { toolCommand: options.toolCommand } : {}, ...options.model ? { model: options.model } : {} });
+  const localModelConfig = localModelConfigOptions(options);
+  const preview = await createToolRunPreview({ rootDir: options.root, prompt, tool: options.tool, invocationChannel: options.invocationChannel, ...options.toolCommand ? { toolCommand: options.toolCommand } : {}, ...localModelConfig });
   console.log(`Running ${preview.toolName}: ${preview.displayCommand}`);
   const result = await runLocalTool({
     rootDir: options.root,
@@ -4251,7 +4882,7 @@ program.command("orchestrate").description("Update the Amistio control plane thr
     tool: options.tool,
     invocationChannel: options.invocationChannel,
     ...options.toolCommand ? { toolCommand: options.toolCommand } : {},
-    ...options.model ? { model: options.model } : {},
+    ...localModelConfig,
     streamOutput: options.stream,
     ...sessionPolicy === "none" ? {} : { session: { toolSessionId: `local_orchestration_${randomUUID()}`, policy: sessionPolicy, decision: localSessionDecision(sessionPolicy) } }
   });
@@ -4265,7 +4896,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").option("--root <path>", "Repository root", defaultRoot).option("--tool <name>", "Local tool to use: auto, none, opencode, claude, codex, copilot, gemini, aider, cursor-agent").option("--invocation-channel <channel>", "Local invocation channel: auto, sdk, or command", parseInvocationChannel).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").option("--verbose", "Print detailed runner errors while watching").action(async (options, command) => {
+program.command("run").description("Claim and run approved Amistio work locally").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--runner-id <runnerId>", "Stable runner ID").option("--root <path>", "Repository root", defaultRoot).option("--tool <name>", "Local tool to use: auto, none, opencode, claude, codex, copilot, gemini, aider, cursor-agent").option("--invocation-channel <channel>", "Local invocation channel: auto, sdk, or command", parseInvocationChannel).option("--model <model>", "Model to request when the selected local tool supports model selection").option("--provider <providerId>", "Provider id for provider-backed model configuration").option("--model-id <modelId>", "Provider catalog model id to request").option("--model-variant <variant>", "Provider catalog model variant to request").option("--reasoning-effort <effort>", "Reasoning effort: auto, low, medium, high, or xhigh", parseReasoningEffort).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("--max-preflight-attempts <count>", "Fail setup/preflight failures after this many claimed attempts", parsePositiveInteger, DEFAULT_MAX_PREFLIGHT_ATTEMPTS).option("--tool-timeout-seconds <seconds>", "Fail local tool execution after this many seconds", parsePositiveInteger, DEFAULT_TOOL_TIMEOUT_SECONDS).option("--no-stream", "Capture local tool output instead of streaming it").option("--verbose", "Print detailed runner errors while watching").action(async (options, command) => {
   const context = await loadPairedApiContext(options.root, options.apiUrl);
   if (!context) {
     console.log("Repository is not paired. Run `amistio pair` first.");
@@ -4437,7 +5068,7 @@ runner.command("stop").description("Stop a background runner for the paired repo
   console.log(stopResult === "stopped" ? `Stopped background runner ${record.runnerId}.` : `Marked background runner ${record.runnerId} stopped; process was not running.`);
 });
 var runnerService = runner.command("service").description("Manage a user-level startup service for the paired runner");
-runnerService.command("install").description("Install a user-level startup service for this paired repository runner").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--root <path>", "Repository root", defaultRoot).option("--runner-id <runnerId>", "Stable runner ID").option("--tool <name>", "Local tool to use: auto, opencode, claude, codex, copilot, gemini, aider, cursor-agent").option("--invocation-channel <channel>", "Local invocation channel: auto, sdk, or command", parseInvocationChannel).option("--model <model>", "Model to request when the selected local tool supports model selection").option("--session <policy>", "Tool session policy: auto, new, continue:<toolSessionId>, or none", "auto").option("--interval-seconds <seconds>", "Polling interval for the service runner", parsePositiveInteger, 10).option("--no-stream", "Capture local tool output instead of streaming it").option("--verbose", "Print detailed runner errors").option("--dry-run", "Print the startup service descriptor without installing it").action(async (options) => {
+runnerService.command("install").description("Install a user-level startup service for this paired repository runner").option("--api-url <url>", apiUrlOptionDescription, defaultApiUrl()).option("--root <path>", "Repository root", defaultRoot).option("--runner-id <runnerId>", "Stable runner ID").option("--tool <name>", "Local tool to use: auto, opencode, claude, codex, copilot, gemini, aider, cursor-agent").option("--invocation-channel <channel>", "Local invocation channel: auto, sdk, or command", parseInvocationChannel).option("--model <model>", "Model to request when the selected local tool supports model selection").option("--provider <providerId>", "Provider id for provider-backed model configuration").option("--model-id <modelId>", "Provider catalog model id to request").option("--model-variant <variant>", "Provider catalog model variant to request").option("--reasoning-effort <effort>", "Reasoning effort: auto, low, medium, high, or xhigh", parseReasoningEffort).option("--session <policy>", "Tool session policy: auto, new, continue:<toolSessionId>, or none", "auto").option("--interval-seconds <seconds>", "Polling interval for the service runner", parsePositiveInteger, 10).option("--max-preflight-attempts <count>", "Fail setup/preflight failures after this many claimed attempts", parsePositiveInteger, DEFAULT_MAX_PREFLIGHT_ATTEMPTS).option("--tool-timeout-seconds <seconds>", "Fail local tool execution after this many seconds", parsePositiveInteger, DEFAULT_TOOL_TIMEOUT_SECONDS).option("--no-stream", "Capture local tool output instead of streaming it").option("--verbose", "Print detailed runner errors").option("--dry-run", "Print the startup service descriptor without installing it").action(async (options) => {
   const context = await loadPairedApiContext(options.root, options.apiUrl);
   if (!context) {
     console.log("Repository is not paired. Run `amistio pair` first.");
@@ -4527,6 +5158,16 @@ runnerService.command("remove").description("Remove the startup service for this
 });
 async function runWatchIteration({ command, context, options, runnerId }) {
   try {
+    if (options.watch && !options.dryRun) {
+      await runAutoSyncCycle({
+        context,
+        maxFileKb: 256,
+        quiet: true,
+        quietDisabled: true,
+        root: options.root,
+        runnerId
+      });
+    }
     return await runNextWorkItem({
       apiClient: context.client,
       projectId: context.metadata.amistioProjectId,
@@ -4537,6 +5178,10 @@ async function runWatchIteration({ command, context, options, runnerId }) {
       ...command.getOptionValueSource("tool") === "cli" && options.tool ? { explicitTool: options.tool } : {},
       ...command.getOptionValueSource("invocationChannel") === "cli" && options.invocationChannel ? { explicitInvocationChannel: options.invocationChannel } : {},
       ...command.getOptionValueSource("model") === "cli" && options.model ? { explicitModel: options.model } : {},
+      ...command.getOptionValueSource("provider") === "cli" && options.provider ? { explicitProviderId: options.provider } : {},
+      ...command.getOptionValueSource("modelId") === "cli" && options.modelId ? { explicitModelId: options.modelId } : {},
+      ...command.getOptionValueSource("modelVariant") === "cli" && options.modelVariant ? { explicitModelVariant: options.modelVariant } : {},
+      ...command.getOptionValueSource("reasoningEffort") === "cli" && options.reasoningEffort ? { explicitReasoningEffort: options.reasoningEffort } : {},
       ...options.toolCommand ? { toolCommand: options.toolCommand } : {},
       dryRun: Boolean(options.dryRun),
       stream: options.stream,
@@ -4550,6 +5195,8 @@ async function runWatchIteration({ command, context, options, runnerId }) {
         runnerId
       },
       suppressIdleOutput: Boolean(options.watch),
+      maxPreflightAttempts: options.maxPreflightAttempts,
+      toolTimeoutMs: options.toolTimeoutSeconds * 1e3,
       verbose: Boolean(options.verbose)
     });
   } catch (error) {
@@ -4564,7 +5211,7 @@ ${detail}`);
     } else {
       console.error(`${message} Run with --verbose for details.`);
     }
-    await Promise.allSettled([
+    const settlements = await Promise.allSettled([
       context.client.sendRunnerHeartbeat(context.metadata.amistioProjectId, runnerId, context.metadata.repositoryLinkId, "blocked", { ...runnerHeartbeatMetadata(), preferenceMessage: message }),
       context.client.recordRunnerLog(context.metadata.amistioProjectId, {
         runnerId,
@@ -4575,9 +5222,68 @@ ${detail}`);
         machineId: runnerMachineId()
       })
     ]);
+    logRejectedSettlements("record watch error", settlements);
     return { status: "failed", exitCode: 1, message };
   }
 }
+async function runAutoSyncCycle({ context, maxFileKb, quiet, quietDisabled, root, runnerId }) {
+  const projectId = context.metadata.amistioProjectId;
+  const repositoryLinkId = context.metadata.repositoryLinkId;
+  const heartbeatBase = runnerHeartbeatMetadata(void 0);
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const { repositoryLinks } = await context.client.listRepositoryLinks(projectId);
+    const repositoryLink = repositoryLinks.find((link) => link.repositoryLinkId === repositoryLinkId && link.status !== "revoked");
+    if (!repositoryLink) {
+      const message2 = "Repository link is not active for auto-sync.";
+      await context.client.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "blocked", { ...heartbeatBase, autoSyncStatus: "blocked", autoSyncMessage: message2, autoSyncLastFailureAt: startedAt }).catch(() => void 0);
+      return { status: "blocked", message: message2, pushedCount: 0, skippedCount: 0, conflictCount: 0 };
+    }
+    if (!repositoryLink.autoSyncEnabled) {
+      const message2 = "Repository brain auto-sync is disabled.";
+      if (!quietDisabled) {
+        await context.client.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", { ...heartbeatBase, autoSyncStatus: "disabled", autoSyncMessage: message2 }).catch(() => void 0);
+      }
+      return { status: "disabled", message: message2, pushedCount: 0, skippedCount: 0, conflictCount: 0 };
+    }
+    await context.client.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", { ...heartbeatBase, autoSyncStatus: "active", autoSyncMessage: "Scanning repository brain folders.", autoSyncLastStartedAt: startedAt }).catch(() => void 0);
+    const { documents: existingDocuments } = await context.client.listBrainDocuments(projectId);
+    const collection = await collectAutoSyncDocumentsForPush(root, context.metadata, existingDocuments, { maxFileKb, syncedAt: startedAt });
+    if (!collection.documents.length) {
+      const skippedCount2 = collection.skipped.length;
+      const message2 = skippedCount2 ? `No local brain changes pushed; ${skippedCount2} file${skippedCount2 === 1 ? "" : "s"} skipped or unchanged.` : "No local brain changes found.";
+      await context.client.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", { ...heartbeatBase, autoSyncStatus: "synced", autoSyncMessage: message2, autoSyncLastSuccessAt: startedAt, autoSyncPushedCount: 0, autoSyncSkippedCount: skippedCount2, autoSyncConflictCount: 0 }).catch(() => void 0);
+      return { status: "synced", message: message2, pushedCount: 0, skippedCount: skippedCount2, conflictCount: 0, collection };
+    }
+    const { documents } = await context.client.pushBrainDocuments(projectId, collection.documents);
+    const conflictedDocuments = documents.filter((document) => document.syncState === "conflicted" || document.status === "conflicted");
+    const managedDocumentIds = new Set(collection.managedDocumentIds);
+    const managedDocuments = documents.filter((document) => managedDocumentIds.has(document.documentId) && document.syncState !== "conflicted" && document.status !== "conflicted");
+    if (managedDocuments.length) {
+      await materializeBrainDocuments(root, managedDocuments, { allowDirtyOverwrite: true });
+    }
+    const conflictCount = conflictedDocuments.length;
+    const skippedCount = collection.skipped.length;
+    const pushedCount = documents.length - conflictCount;
+    const status = conflictCount ? "conflicted" : "synced";
+    const message = conflictCount ? `Auto-sync found ${conflictCount} conflict${conflictCount === 1 ? "" : "s"}.` : `Auto-sync pushed ${pushedCount} brain document${pushedCount === 1 ? "" : "s"}.`;
+    await context.client.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", { ...heartbeatBase, autoSyncStatus: status, autoSyncMessage: message, ...conflictCount ? { autoSyncLastFailureAt: startedAt } : { autoSyncLastSuccessAt: startedAt }, autoSyncPushedCount: pushedCount, autoSyncSkippedCount: skippedCount, autoSyncConflictCount: conflictCount }).catch(() => void 0);
+    if (!quiet && conflictCount) {
+      for (const document of conflictedDocuments) {
+        console.log(`conflicted: ${document.repoPath} - web and repository revisions both changed`);
+      }
+    }
+    return { status, message, pushedCount, skippedCount, conflictCount, collection };
+  } catch (error) {
+    const message = `Auto-sync failed: ${errorMessage3(error)}`;
+    await context.client.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "blocked", { ...heartbeatBase, autoSyncStatus: "failed", autoSyncMessage: message, autoSyncLastFailureAt: startedAt }).catch(() => void 0);
+    return { status: "failed", message, pushedCount: 0, skippedCount: 0, conflictCount: 0 };
+  }
+}
+function formatAutoSyncCycleResult(result) {
+  const details = [`pushed ${result.pushedCount}`, `skipped ${result.skippedCount}`, `conflicts ${result.conflictCount}`];
+  return `${result.message} (${details.join("; ")})`;
+}
 async function runNextWorkItem({
   apiClient,
   dryRun,
@@ -4588,11 +5294,17 @@ async function runNextWorkItem({
   sessionPolicy,
   stream,
   explicitModel,
+  explicitModelId,
+  explicitModelVariant,
+  explicitProviderId,
+  explicitReasoningEffort,
   explicitInvocationChannel,
   explicitTool,
+  maxPreflightAttempts,
   toolCommand,
   commandContext,
   suppressIdleOutput,
+  toolTimeoutMs,
   verbose
 }) {
   const toolConfig = await resolveRunnerToolConfig({
@@ -4600,6 +5312,10 @@ async function runNextWorkItem({
     projectId,
     ...explicitInvocationChannel ? { explicitInvocationChannel } : {},
     ...explicitModel ? { explicitModel } : {},
+    ...explicitProviderId ? { explicitProviderId } : {},
+    ...explicitModelId ? { explicitModelId } : {},
+    ...explicitModelVariant ? { explicitModelVariant } : {},
+    ...explicitReasoningEffort ? { explicitReasoningEffort } : {},
     ...explicitTool ? { explicitTool } : {},
     ...toolCommand ? { toolCommand } : {}
   });
@@ -4615,7 +5331,7 @@ async function runNextWorkItem({
     console.log(toolConfig.message);
     return { status: "blocked", exitCode: 1 };
   }
-  const result = await apiClient.claimWork(projectId, runnerId, repositoryLinkId, 300, runnerIsolationCapabilityMetadata());
+  const result = await apiClient.claimWork(projectId, runnerId, repositoryLinkId, RUNNER_WORK_LEASE_SECONDS, runnerIsolationCapabilityMetadata());
   if (!result.workItem) {
     const nextAction = await loadProjectNextAction(apiClient, projectId, repositoryLinkId, root);
     const message = formatProjectNextAction(nextAction);
@@ -4625,14 +5341,20 @@ async function runNextWorkItem({
     return { status: "idle", exitCode: 0, nextAction, message };
   }
   const prompt = await createRunnerWorkPrompt(apiClient, projectId, result.workItem);
+  await recordRunnerMilestone(apiClient, projectId, result.workItem, runnerId, repositoryLinkId, {
+    status: "running",
+    summary: "Prepared local runner execution prompt.",
+    idempotencyKey: `runner_milestone_prompt_${result.workItem.workItemId}_${result.workItem.attempt}`,
+    metadata: { workKind: result.workItem.workKind ?? "implementation", attempt: result.workItem.attempt }
+  });
   if (dryRun || toolConfig.tool === "none") {
     console.log(prompt);
     await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig));
     return { status: "preview", exitCode: 0 };
   }
-  const worktreeIsolation = await prepareWorktreeForClaimedItem({ apiClient, projectId, repositoryLinkId, root, runnerId, toolConfig, workItem: result.workItem });
-  if (worktreeIsolation.status === "blocked") {
-    return { status: "blocked", exitCode: 1, message: worktreeIsolation.message };
+  const worktreeIsolation = await prepareWorktreeForClaimedItem({ apiClient, maxPreflightAttempts, projectId, repositoryLinkId, root, runnerId, toolConfig, workItem: result.workItem });
+  if (worktreeIsolation.status !== "ready") {
+    return { status: worktreeIsolation.status === "failed" ? "failed" : "blocked", exitCode: 1, message: worktreeIsolation.message };
   }
   const executionRoot = worktreeIsolation.isolation?.worktreePath ?? root;
   const isolationTelemetry = workItemIsolationTelemetry(result.workItem, worktreeIsolation.isolation);
@@ -4643,7 +5365,8 @@ async function runNextWorkItem({
     ...isolationTelemetry.executionWorktreeKey ? { currentWorktreeKey: isolationTelemetry.executionWorktreeKey } : {},
     ...isolationTelemetry.executionBranch ? { currentBranch: isolationTelemetry.executionBranch } : {}
   });
-  const preview = await createToolRunPreview({ rootDir: executionRoot, prompt, tool: toolConfig.tool, invocationChannel: toolConfig.requestedInvocationChannel ?? "auto", ...toolCommand ? { toolCommand } : {}, ...toolConfig.model ? { model: toolConfig.model } : {} });
+  const resolvedModelConfig = toolConfigModelOptions(toolConfig);
+  const preview = await createToolRunPreview({ rootDir: executionRoot, prompt, tool: toolConfig.tool, invocationChannel: toolConfig.requestedInvocationChannel ?? "auto", ...toolCommand ? { toolCommand } : {}, ...resolvedModelConfig });
   const sessionContext = await prepareToolSession({
     apiClient,
     projectId,
@@ -4669,6 +5392,7 @@ async function runNextWorkItem({
   const providerSessionStore = new LocalToolSessionStore();
   const providerSessionId = sessionContext.toolSession ? await providerSessionStore.getProviderSessionId(sessionContext.toolSession.toolSessionId, preview.toolName) : void 0;
   let toolResult;
+  const stopLeaseRenewal = startWorkLeaseRenewal({ apiClient, projectId, repositoryLinkId, runnerId, toolConfig, workItem: result.workItem, telemetry: isolationTelemetry });
   try {
     toolResult = await runLocalTool({
       rootDir: executionRoot,
@@ -4676,8 +5400,9 @@ async function runNextWorkItem({
       tool: toolConfig.tool,
       invocationChannel: toolConfig.requestedInvocationChannel ?? "auto",
       ...toolCommand ? { toolCommand } : {},
-      ...toolConfig.model ? { model: toolConfig.model } : {},
+      ...resolvedModelConfig,
       streamOutput: stream,
+      timeoutMs: toolTimeoutMs,
       ...sessionContext.toolSession ? {
         session: {
           toolSessionId: sessionContext.toolSession.toolSessionId,
@@ -4688,10 +5413,11 @@ async function runNextWorkItem({
       } : {}
     });
   } catch (error) {
+    stopLeaseRenewal();
     const detail = truncateLogExcerpt(errorDetail(error));
     const durationMs2 = Date.now() - startedAt;
     const message = `${preview.toolName} failed before returning a result.`;
-    await Promise.allSettled([
+    const settlements = await Promise.allSettled([
       apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig)),
       markToolSessionBlocked(apiClient, projectId, sessionContext.toolSession, errorMessage3(error)),
       apiClient.updateWorkStatus(projectId, result.workItem.workItemId, "failed", `run_failed_${result.workItem.workItemId}_${result.workItem.attempt}_${runnerId}`, runnerId, {
@@ -4713,11 +5439,13 @@ async function runNextWorkItem({
         metadata: { tool: preview.toolName, error: detail }
       })
     ]);
+    logRejectedSettlements("record local tool failure", settlements);
     if (verbose || !stream) {
       console.error(detail);
     }
     return { status: "failed", exitCode: 1, message };
   }
+  stopLeaseRenewal();
   if (sessionContext.toolSession && toolResult.providerSessionId) {
     await providerSessionStore.setProviderSessionId(sessionContext.toolSession.toolSessionId, preview.toolName, toolResult.providerSessionId);
   }
@@ -4728,47 +5456,59 @@ async function runNextWorkItem({
     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
-    });
+    try {
+      return await finalizeBrainGenerationWork({
+        apiClient,
+        durationMs: Date.now() - startedAt,
+        projectId,
+        repositoryLinkId,
+        runnerId,
+        sessionContext,
+        toolConfig,
+        toolName: preview.toolName,
+        toolResult,
+        workItem: result.workItem
+      });
+    } catch (error) {
+      return recordFinalizationFailure({ apiClient, error, isolationTelemetry, projectId, repositoryLinkId, runnerId, sessionContext, toolConfig, toolName: preview.toolName, workItem: result.workItem, durationMs: Date.now() - startedAt });
+    }
   }
   if (result.workItem.workKind === "assistantQuestion") {
-    return finalizeAssistantQuestionWork({
-      apiClient,
-      durationMs: Date.now() - startedAt,
-      projectId,
-      repositoryLinkId,
-      runnerId,
-      sessionContext,
-      toolConfig,
-      toolName: preview.toolName,
-      toolResult,
-      workItem: result.workItem
-    });
+    try {
+      return await finalizeAssistantQuestionWork({
+        apiClient,
+        durationMs: Date.now() - startedAt,
+        projectId,
+        repositoryLinkId,
+        runnerId,
+        sessionContext,
+        toolConfig,
+        toolName: preview.toolName,
+        toolResult,
+        workItem: result.workItem
+      });
+    } catch (error) {
+      return recordFinalizationFailure({ apiClient, error, isolationTelemetry, projectId, repositoryLinkId, runnerId, sessionContext, toolConfig, toolName: preview.toolName, workItem: result.workItem, durationMs: Date.now() - startedAt });
+    }
   }
   if (result.workItem.workKind === "impactPreview") {
-    return finalizeImpactPreviewWork({
-      apiClient,
-      durationMs: Date.now() - startedAt,
-      projectId,
-      repositoryLinkId,
-      root,
-      runnerId,
-      sessionContext,
-      toolConfig,
-      toolName: preview.toolName,
-      toolResult,
-      workItem: result.workItem
-    });
+    try {
+      return await finalizeImpactPreviewWork({
+        apiClient,
+        durationMs: Date.now() - startedAt,
+        projectId,
+        repositoryLinkId,
+        root,
+        runnerId,
+        sessionContext,
+        toolConfig,
+        toolName: preview.toolName,
+        toolResult,
+        workItem: result.workItem
+      });
+    } catch (error) {
+      return recordFinalizationFailure({ apiClient, error, isolationTelemetry, projectId, repositoryLinkId, runnerId, sessionContext, toolConfig, toolName: preview.toolName, workItem: result.workItem, durationMs: Date.now() - startedAt });
+    }
   }
   const finalStatus = toolResult.exitCode === 0 ? "completed" : "failed";
   const durationMs = Date.now() - startedAt;
@@ -4820,11 +5560,17 @@ async function runNextWorkItem({
   console.log(`Marked ${statusResult.workItem.workItemId} ${statusResult.workItem.status} after ${durationSeconds}s.`);
   return { status: finalStatus, exitCode: toolResult.exitCode };
 }
-async function prepareWorktreeForClaimedItem({ apiClient, projectId, repositoryLinkId, root, runnerId, toolConfig, workItem }) {
+async function prepareWorktreeForClaimedItem({ apiClient, maxPreflightAttempts, projectId, repositoryLinkId, root, runnerId, toolConfig, workItem }) {
   if (!needsGitWorktreeIsolation(workItem)) {
     return { status: "ready" };
   }
   const identity = resolveWorktreeIdentity(workItem);
+  await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
+    status: "running",
+    summary: `Checking Git worktree isolation for attempt ${workItem.attempt}/${maxPreflightAttempts}.`,
+    idempotencyKey: `runner_milestone_worktree_preflight_${workItem.workItemId}_${workItem.attempt}`,
+    metadata: { executionWorktreeKey: identity.worktreeKey, executionBranch: identity.branch, implementationScopeId: identity.implementationScopeId, attempt: workItem.attempt, maxAttempts: maxPreflightAttempts }
+  });
   try {
     const isolation = await prepareGitWorktreeIsolation(root, workItem);
     await recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
@@ -4837,29 +5583,111 @@ async function prepareWorktreeForClaimedItem({ apiClient, projectId, repositoryL
   } catch (error) {
     const message = errorMessage3(error);
     const telemetry = workItemIsolationTelemetry(workItem, { ...identity, baseRevision: workItem.baseRevision ?? "unknown", worktreePath: "" });
-    const statusResult = await apiClient.updateWorkStatus(projectId, workItem.workItemId, "blocked", `worktree_${workItem.workItemId}_${randomUUID()}`, runnerId, {
+    const finalAttempt = workItem.attempt >= maxPreflightAttempts;
+    const statusMessage = finalAttempt ? `Git worktree preflight failed after ${workItem.attempt}/${maxPreflightAttempts} attempts. ${message}` : `Git worktree preflight attempt ${workItem.attempt}/${maxPreflightAttempts} failed. Requeueing for retry. ${message}`;
+    const statusResult = await apiClient.updateWorkStatus(projectId, workItem.workItemId, finalAttempt ? "failed" : "approved", `worktree_${finalAttempt ? "failed" : "retry"}_${workItem.workItemId}_${workItem.attempt}_${randomUUID()}`, runnerId, {
       ...telemetry,
-      message,
-      blockerReason: message,
+      message: statusMessage,
+      ...finalAttempt ? { blockerReason: message } : { releaseClaim: true },
       error: message
     });
     await recordRunnerMilestone(apiClient, projectId, statusResult.workItem, runnerId, repositoryLinkId, {
-      status: "blocked",
-      summary: message,
-      idempotencyKey: `runner_milestone_worktree_blocked_${workItem.workItemId}_${statusResult.workItem.idempotencyKey}`,
-      metadata: { executionWorktreeKey: telemetry.executionWorktreeKey ?? "", executionBranch: telemetry.executionBranch ?? "", implementationScopeId: telemetry.implementationScopeId ?? "" }
+      status: finalAttempt ? "failed" : "warning",
+      summary: statusMessage,
+      idempotencyKey: `runner_milestone_worktree_${finalAttempt ? "failed" : "retry"}_${workItem.workItemId}_${statusResult.workItem.idempotencyKey}`,
+      metadata: { executionWorktreeKey: telemetry.executionWorktreeKey ?? "", executionBranch: telemetry.executionBranch ?? "", implementationScopeId: telemetry.implementationScopeId ?? "", attempt: workItem.attempt, maxAttempts: maxPreflightAttempts, error: message }
     });
-    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "blocked", {
+    await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", {
       ...runnerHeartbeatMetadata(toolConfig),
-      currentWorkItemId: workItem.workItemId,
-      ...telemetry.implementationScopeId ? { currentImplementationScopeId: telemetry.implementationScopeId } : {},
-      ...telemetry.executionWorktreeKey ? { currentWorktreeKey: telemetry.executionWorktreeKey } : {},
-      ...telemetry.executionBranch ? { currentBranch: telemetry.executionBranch } : {}
+      preferenceMessage: statusMessage
     });
-    console.error(message);
-    return { status: "blocked", message };
+    console.error(statusMessage);
+    return { status: finalAttempt ? "failed" : "retrying", message: statusMessage };
   }
 }
+function startWorkLeaseRenewal({ apiClient, projectId, repositoryLinkId, runnerId, toolConfig, workItem, telemetry }) {
+  let stopped = false;
+  const renew = async () => {
+    if (stopped) return;
+    const leaseExpiresAt = new Date(Date.now() + RUNNER_WORK_LEASE_SECONDS * 1e3).toISOString();
+    try {
+      await apiClient.updateWorkStatus(projectId, workItem.workItemId, "running", `lease_renewal_${workItem.workItemId}_${workItem.attempt}_${Date.now()}`, runnerId, {
+        ...telemetry,
+        leaseExpiresAt
+      });
+      await apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "running", {
+        ...runnerHeartbeatMetadata(toolConfig),
+        currentWorkItemId: workItem.workItemId,
+        ...telemetry.implementationScopeId ? { currentImplementationScopeId: telemetry.implementationScopeId } : {},
+        ...telemetry.executionWorktreeKey ? { currentWorktreeKey: telemetry.executionWorktreeKey } : {},
+        ...telemetry.executionBranch ? { currentBranch: telemetry.executionBranch } : {}
+      });
+    } catch (error) {
+      const detail = truncateLogExcerpt(errorDetail(error));
+      console.error(`Could not renew Amistio work lease for ${workItem.workItemId}: ${detail}`);
+      await apiClient.recordRunnerLog(projectId, {
+        runnerId,
+        repositoryLinkId,
+        status: "failed",
+        workItemId: workItem.workItemId,
+        workTitle: workItem.title,
+        ...workItem.workKind ? { workKind: workItem.workKind } : {},
+        message: "Runner could not renew the active work lease.",
+        error: detail,
+        machineId: runnerMachineId()
+      }).catch(() => void 0);
+    }
+  };
+  const timer = setInterval(() => {
+    void renew();
+  }, RUNNER_WORK_LEASE_RENEWAL_MS);
+  timer.unref?.();
+  return () => {
+    stopped = true;
+    clearInterval(timer);
+  };
+}
+async function recordFinalizationFailure({ apiClient, durationMs, error, isolationTelemetry, projectId, repositoryLinkId, runnerId, sessionContext, toolConfig, toolName, workItem }) {
+  const detail = truncateLogExcerpt(errorDetail(error));
+  const message = `${toolName} completed, but Amistio could not finalize the result.`;
+  const settlements = await Promise.allSettled([
+    apiClient.sendRunnerHeartbeat(projectId, runnerId, repositoryLinkId, "online", runnerHeartbeatMetadata(toolConfig)),
+    markToolSessionBlocked(apiClient, projectId, sessionContext.toolSession, errorMessage3(error)),
+    apiClient.updateWorkStatus(projectId, workItem.workItemId, "failed", `finalize_failed_${workItem.workItemId}_${workItem.attempt}_${randomUUID()}`, runnerId, {
+      ...isolationTelemetry,
+      tool: toolName,
+      durationMs,
+      message,
+      error: detail,
+      ...sessionContext.toolSession ? { toolSessionId: sessionContext.toolSession.toolSessionId } : {},
+      sessionPolicy: sessionContext.policy,
+      sessionDecision: sessionContext.decision,
+      sessionDecisionReason: sessionContext.reason
+    }),
+    apiClient.recordRunnerLog(projectId, {
+      runnerId,
+      repositoryLinkId,
+      status: "failed",
+      workItemId: workItem.workItemId,
+      workTitle: workItem.title,
+      ...workItem.workKind ? { workKind: workItem.workKind } : {},
+      tool: toolName,
+      durationMs,
+      message,
+      error: detail,
+      machineId: runnerMachineId()
+    }),
+    recordRunnerMilestone(apiClient, projectId, workItem, runnerId, repositoryLinkId, {
+      status: "failed",
+      summary: message,
+      idempotencyKey: `runner_milestone_finalization_failed_${workItem.workItemId}_${workItem.attempt}`,
+      metadata: { tool: toolName, durationMs, error: detail }
+    })
+  ]);
+  logRejectedSettlements("record finalization failure", settlements);
+  console.error(detail);
+  return { status: "failed", exitCode: 1, message };
+}
 function workItemIsolationTelemetry(workItem, isolation) {
   const implementationScopeId = isolation?.implementationScopeId ?? workItem.implementationScopeId;
   const executionBranch = isolation?.branch ?? workItem.executionBranch;
@@ -4888,6 +5716,13 @@ async function recordRunnerMilestone(apiClient, projectId, workItem, runnerId, r
     ...input
   }).catch(() => void 0);
 }
+function logRejectedSettlements(action, settlements) {
+  for (const settlement of settlements) {
+    if (settlement.status === "rejected") {
+      console.error(`${action} failed: ${errorMessage3(settlement.reason)}`);
+    }
+  }
+}
 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];
@@ -5453,11 +6288,17 @@ function parseInvocationChannel(value) {
   }
   throw new Error(`Expected invocation channel auto, sdk, or command; received ${value}.`);
 }
+function parseReasoningEffort(value) {
+  if (value === "auto" || value === "low" || value === "medium" || value === "high" || value === "xhigh") {
+    return value;
+  }
+  throw new Error(`Expected reasoning effort auto, low, medium, high, or xhigh; received ${value}.`);
+}
 function inferRepoName(root) {
   return path13.basename(path13.resolve(root)) || "repository";
 }
 function createRepoFingerprint(accountId, projectId, repositoryLinkId) {
-  return createHash6("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");
+  return createHash7("sha256").update(`${accountId}:${projectId}:${repositoryLinkId}`).digest("hex");
 }
 function defaultApiUrl() {
   const envApiUrl = process.env[AMISTIO_API_URL_ENV]?.trim();
@@ -5472,9 +6313,10 @@ function formatApiUrlFlag(apiUrl) {
 function formatShellArg(value) {
   return /^[A-Za-z0-9_./:@-]+$/.test(value) ? value : `'${value.replace(/'/g, "'\\''")}'`;
 }
-async function resolveRunnerToolConfig({ apiClient, explicitInvocationChannel, explicitModel, explicitTool, projectId, toolCommand }) {
+async function resolveRunnerToolConfig({ apiClient, explicitInvocationChannel, explicitModel, explicitModelId, explicitModelVariant, explicitProviderId, explicitReasoningEffort, explicitTool, projectId, toolCommand }) {
   const capabilities = toRunnerToolCapabilities(await detectLocalTools());
   if (toolCommand) {
+    const modelConfig2 = normalizeModelConfig({ model: explicitModel, providerId: explicitProviderId, modelId: explicitModelId, modelVariant: explicitModelVariant, reasoningEffort: explicitReasoningEffort });
     return {
       ready: true,
       tool: explicitTool ?? "auto",
@@ -5485,33 +6327,42 @@ async function resolveRunnerToolConfig({ apiClient, explicitInvocationChannel, e
       requestedInvocationChannel: explicitInvocationChannel ?? "command",
       effectiveInvocationChannel: "command",
       ...explicitTool && explicitTool !== "none" && explicitTool !== "auto" && isLocalToolName(explicitTool) ? { requestedTool: explicitTool } : explicitTool === "auto" ? { requestedTool: "auto" } : {},
-      ...explicitModel ? { model: explicitModel } : {},
+      ...modelConfig2,
       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", requestedInvocationChannel: explicitInvocationChannel ?? "auto", model: explicitModel });
+    const modelConfig2 = normalizeModelConfig({ model: explicitModel, providerId: explicitProviderId, modelId: explicitModelId, modelVariant: explicitModelVariant, reasoningEffort: explicitReasoningEffort });
+    if (hasModelConfig(modelConfig2)) {
+      return unavailableToolConfig({ capabilities, source: "cli", status: "modelUnsupported", message: "Model configuration cannot be used with --tool none.", tool: "none", requestedInvocationChannel: explicitInvocationChannel ?? "auto", ...modelConfig2 });
     }
     return { ready: true, tool: "none", capabilities, source: "cli", status: "none", requestedInvocationChannel: explicitInvocationChannel ?? "auto", 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, requestedInvocationChannel: explicitInvocationChannel ?? "auto", ...explicitModel ? { model: explicitModel } : {} });
+    const modelConfig2 = normalizeModelConfig({ model: explicitModel, providerId: explicitProviderId, modelId: explicitModelId, modelVariant: explicitModelVariant, reasoningEffort: explicitReasoningEffort });
+    return unavailableToolConfig({ capabilities, source: "cli", status: "unavailable", message: `Unsupported local tool: ${explicitTool}.`, tool: explicitTool, requestedInvocationChannel: explicitInvocationChannel ?? "auto", ...modelConfig2 });
   }
   const remotePreference = await apiClient.getRunnerPreferences(projectId).then((response) => response.effective).catch(() => void 0);
   const requestedTool = explicitTool ?? remotePreference?.tool ?? "auto";
   const requestedInvocationChannel = explicitInvocationChannel ?? remotePreference?.invocationChannel ?? "auto";
-  const model = explicitModel ?? remotePreference?.model;
-  const source = explicitTool || explicitInvocationChannel || explicitModel ? "cli" : remotePreference?.source ?? "default";
-  return resolveRequestedTool({ capabilities, requestedInvocationChannel, requestedTool, source, ...model ? { model } : {} });
+  const modelConfig = normalizeModelConfig({
+    model: explicitModel ?? remotePreference?.model,
+    providerId: explicitProviderId ?? remotePreference?.providerId,
+    modelId: explicitModelId ?? remotePreference?.modelId,
+    modelVariant: explicitModelVariant ?? remotePreference?.modelVariant,
+    reasoningEffort: explicitReasoningEffort ?? remotePreference?.reasoningEffort
+  });
+  const source = explicitTool || explicitInvocationChannel || hasExplicitModelConfig({ model: explicitModel, providerId: explicitProviderId, modelId: explicitModelId, modelVariant: explicitModelVariant, reasoningEffort: explicitReasoningEffort }) ? "cli" : remotePreference?.source ?? "default";
+  return resolveRequestedTool({ capabilities, modelConfig, requestedInvocationChannel, requestedTool, source });
 }
-function resolveRequestedTool({ capabilities, model, requestedInvocationChannel, requestedTool, source }) {
+function resolveRequestedTool({ capabilities, modelConfig, requestedInvocationChannel, requestedTool, source }) {
+  const needsModelSelection = hasModelConfig(modelConfig);
   if (requestedTool === "auto") {
-    const candidate = capabilities.find((capability2) => capability2.available && capabilitySupportsInvocationChannel(capability2, requestedInvocationChannel) && (!model || capability2.supportsModelSelection));
+    const candidate = capabilities.find((capability2) => capability2.available && capabilitySupportsInvocationChannel(capability2, requestedInvocationChannel) && (!needsModelSelection || capability2.supportsModelSelection));
     if (!candidate) {
       const anyAvailable = capabilities.some((capability2) => capability2.available);
       const anyChannelAvailable = capabilities.some((capability2) => capability2.available && capabilitySupportsInvocationChannel(capability2, requestedInvocationChannel));
-      const status = !anyAvailable ? "unavailable" : requestedInvocationChannel !== "auto" && !anyChannelAvailable ? "channelUnsupported" : model ? "modelUnsupported" : "unavailable";
+      const status = !anyAvailable ? "unavailable" : requestedInvocationChannel !== "auto" && !anyChannelAvailable ? "channelUnsupported" : needsModelSelection ? "modelUnsupported" : "unavailable";
       return unavailableToolConfig({
         capabilities,
         source,
@@ -5519,23 +6370,31 @@ function resolveRequestedTool({ capabilities, model, requestedInvocationChannel,
         requestedTool,
         requestedInvocationChannel,
         tool: "auto",
-        ...model ? { model } : {},
-        message: status === "channelUnsupported" ? `No installed local AI tool can honor ${requestedInvocationChannel} invocation.` : model ? "No installed local tool can honor the selected model." : "No supported local AI tool is installed."
+        ...modelConfig,
+        message: status === "channelUnsupported" ? `No installed local AI tool can honor ${requestedInvocationChannel} invocation.` : needsModelSelection ? "No installed local tool can honor the selected provider/model configuration." : "No supported local AI tool is installed."
       });
     }
-    return { ready: true, tool: "auto", capabilities, source, status: "resolved", requestedTool, requestedInvocationChannel, effectiveTool: candidate.name, effectiveInvocationChannel: effectiveInvocationChannel(candidate, requestedInvocationChannel), ...model ? { model } : {} };
+    const modelResolution2 = resolveProviderModelConfig(candidate, modelConfig);
+    if (!modelResolution2.ready) {
+      return unavailableToolConfig({ capabilities, source, status: modelResolution2.status, requestedTool, requestedInvocationChannel, effectiveTool: candidate.name, effectiveInvocationChannel: effectiveInvocationChannel(candidate, requestedInvocationChannel), tool: "auto", ...modelConfig, message: modelResolution2.message });
+    }
+    return { ready: true, tool: "auto", capabilities, source, status: "resolved", requestedTool, requestedInvocationChannel, effectiveTool: candidate.name, effectiveInvocationChannel: effectiveInvocationChannel(candidate, requestedInvocationChannel), ...modelResolution2.config };
   }
   const capability = capabilities.find((candidate) => candidate.name === requestedTool);
   if (!capability?.available) {
-    return unavailableToolConfig({ capabilities, source, status: "unavailable", requestedTool, requestedInvocationChannel, tool: requestedTool, ...model ? { model } : {}, message: `${requestedTool} is selected but is not available on this runner.` });
+    return unavailableToolConfig({ capabilities, source, status: "unavailable", requestedTool, requestedInvocationChannel, tool: requestedTool, ...modelConfig, message: `${requestedTool} is selected but is not available on this runner.` });
   }
   if (!capabilitySupportsInvocationChannel(capability, requestedInvocationChannel)) {
-    return unavailableToolConfig({ capabilities, source, status: "channelUnsupported", requestedTool, requestedInvocationChannel, effectiveTool: requestedTool, tool: requestedTool, ...model ? { model } : {}, message: `${requestedTool} is available but does not support ${requestedInvocationChannel} invocation on this runner.` });
+    return unavailableToolConfig({ capabilities, source, status: "channelUnsupported", requestedTool, requestedInvocationChannel, effectiveTool: requestedTool, tool: requestedTool, ...modelConfig, message: `${requestedTool} is available but does not support ${requestedInvocationChannel} invocation on this runner.` });
   }
-  if (model && !capability.supportsModelSelection) {
-    return unavailableToolConfig({ capabilities, source, status: "modelUnsupported", requestedTool, requestedInvocationChannel, effectiveTool: requestedTool, effectiveInvocationChannel: effectiveInvocationChannel(capability, requestedInvocationChannel), tool: requestedTool, model, message: `${requestedTool} is available but does not support Amistio model selection yet.` });
+  if (needsModelSelection && !capability.supportsModelSelection) {
+    return unavailableToolConfig({ capabilities, source, status: "modelUnsupported", requestedTool, requestedInvocationChannel, effectiveTool: requestedTool, effectiveInvocationChannel: effectiveInvocationChannel(capability, requestedInvocationChannel), tool: requestedTool, ...modelConfig, message: `${requestedTool} is available but does not support Amistio model selection yet.` });
   }
-  return { ready: true, tool: requestedTool, capabilities, source, status: "resolved", requestedTool, requestedInvocationChannel, effectiveTool: requestedTool, effectiveInvocationChannel: effectiveInvocationChannel(capability, requestedInvocationChannel), ...model ? { model } : {} };
+  const modelResolution = resolveProviderModelConfig(capability, modelConfig);
+  if (!modelResolution.ready) {
+    return unavailableToolConfig({ capabilities, source, status: modelResolution.status, requestedTool, requestedInvocationChannel, effectiveTool: requestedTool, effectiveInvocationChannel: effectiveInvocationChannel(capability, requestedInvocationChannel), tool: requestedTool, ...modelConfig, message: modelResolution.message });
+  }
+  return { ready: true, tool: requestedTool, capabilities, source, status: "resolved", requestedTool, requestedInvocationChannel, effectiveTool: requestedTool, effectiveInvocationChannel: effectiveInvocationChannel(capability, requestedInvocationChannel), ...modelResolution.config };
 }
 function unavailableToolConfig(input) {
   return {
@@ -5549,9 +6408,116 @@ function unavailableToolConfig(input) {
     ...input.requestedInvocationChannel ? { requestedInvocationChannel: input.requestedInvocationChannel } : {},
     ...input.effectiveTool ? { effectiveTool: input.effectiveTool } : {},
     ...input.effectiveInvocationChannel ? { effectiveInvocationChannel: input.effectiveInvocationChannel } : {},
-    ...input.model ? { model: input.model } : {}
+    ...normalizeModelConfig(input)
   };
 }
+function resolveProviderModelConfig(capability, modelConfig) {
+  const normalized = normalizeModelConfig(modelConfig);
+  if (!hasModelConfig(normalized)) {
+    return { ready: true, config: {} };
+  }
+  if (!capability.supportsModelSelection) {
+    return { ready: false, status: "modelUnsupported", message: `${capability.name} does not support Amistio model selection yet.` };
+  }
+  if (!normalized.providerId && !normalized.modelId && !normalized.modelVariant && (!normalized.reasoningEffort || normalized.reasoningEffort === "auto")) {
+    return { ready: true, config: normalized };
+  }
+  const catalog = capability.providerCatalog;
+  if (!catalog) {
+    return { ready: false, status: "modelUnsupported", message: `${capability.name} does not report a provider model catalog yet.` };
+  }
+  const providerId = normalized.providerId ?? inferProviderIdForModel(catalog, normalized.modelId ?? normalized.model);
+  if (!providerId) {
+    return { ready: false, status: "modelUnsupported", message: "Select a provider id with the provider-backed model preference." };
+  }
+  const provider = catalog[providerId];
+  if (!provider) {
+    return { ready: false, status: "modelUnsupported", message: `${providerId} is not available in ${capability.name}'s provider catalog.` };
+  }
+  const modelId = normalized.modelId ?? inferModelId(provider.models, normalized.model);
+  if (!modelId) {
+    return { ready: false, status: "modelUnsupported", message: "Select a model id with the provider-backed model preference." };
+  }
+  const model = provider.models[modelId];
+  if (!model) {
+    return { ready: false, status: "modelUnsupported", message: `${providerId}/${modelId} is not available in ${capability.name}'s provider catalog.` };
+  }
+  if (normalized.modelVariant) {
+    const variant = model.variants?.[normalized.modelVariant];
+    if (!variant || variant.disabled) {
+      return { ready: false, status: "variantUnsupported", message: `${providerId}/${modelId} does not support variant ${normalized.modelVariant}.` };
+    }
+  }
+  if (normalized.reasoningEffort && normalized.reasoningEffort !== "auto") {
+    const supportedEfforts = model.supportedReasoningEfforts ?? (model.reasoning ? ["auto", "low", "medium", "high", "xhigh"] : []);
+    if (!supportedEfforts.includes(normalized.reasoningEffort)) {
+      return { ready: false, status: "reasoningUnsupported", message: `${providerId}/${modelId} does not support ${normalized.reasoningEffort} reasoning effort.` };
+    }
+  }
+  return {
+    ready: true,
+    config: {
+      model: normalized.model ?? `${providerId}/${modelId}`,
+      providerId,
+      modelId,
+      ...normalized.modelVariant ? { modelVariant: normalized.modelVariant } : {},
+      ...normalized.reasoningEffort ? { reasoningEffort: normalized.reasoningEffort } : {}
+    }
+  };
+}
+function normalizeModelConfig(config) {
+  const model = cleanPreferenceText(config.model);
+  const providerId = cleanPreferenceText(config.providerId);
+  const modelId = cleanPreferenceText(config.modelId);
+  const modelVariant = cleanPreferenceText(config.modelVariant);
+  return {
+    ...model ? { model } : {},
+    ...providerId ? { providerId } : {},
+    ...modelId ? { modelId } : {},
+    ...modelVariant ? { modelVariant } : {},
+    ...config.reasoningEffort ? { reasoningEffort: config.reasoningEffort } : {}
+  };
+}
+function hasExplicitModelConfig(config) {
+  return hasModelConfig(normalizeModelConfig(config));
+}
+function hasModelConfig(config) {
+  return Boolean(config.model || config.providerId || config.modelId || config.modelVariant || config.reasoningEffort);
+}
+function cleanPreferenceText(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function inferProviderIdForModel(catalog, model) {
+  if (!model) return void 0;
+  if (model.includes("/")) {
+    const [providerId, modelId] = model.split("/", 2);
+    if (providerId && modelId && catalog[providerId]?.models[modelId]) return providerId;
+  }
+  return Object.entries(catalog).find(([, provider]) => Boolean(provider.models[model]))?.[0];
+}
+function inferModelId(models, model) {
+  if (!model) return void 0;
+  if (models[model]) return model;
+  const slashIndex = model.indexOf("/");
+  if (slashIndex !== -1) {
+    const modelId = model.slice(slashIndex + 1);
+    if (models[modelId]) return modelId;
+  }
+  return void 0;
+}
+function toolConfigModelOptions(toolConfig) {
+  return normalizeModelConfig(toolConfig);
+}
+function localModelConfigOptions(options) {
+  return normalizeModelConfig({
+    model: options.model,
+    providerId: options.providerId ?? options.provider,
+    modelId: options.modelId,
+    modelVariant: options.modelVariant,
+    reasoningEffort: options.reasoningEffort
+  });
+}
 function capabilitySupportsInvocationChannel(capability, channel) {
   if (channel === "auto") return capability.available;
   if (channel === "sdk") return capability.sdkAvailable;
@@ -5584,6 +6550,8 @@ function runnerIsolationCapabilityMetadata() {
   };
 }
 function runnerHeartbeatMetadata(toolConfig, mode = currentRunnerMode()) {
+  const modelConfig = toolConfig ? toolConfigModelOptions(toolConfig) : {};
+  const effectiveModelConfig = toolConfig?.ready ? modelConfig : {};
   return {
     version: CLI_VERSION,
     mode,
@@ -5593,16 +6561,24 @@ function runnerHeartbeatMetadata(toolConfig, mode = currentRunnerMode()) {
     ...toolConfig?.capabilities ? { capabilities: toolConfig.capabilities } : {},
     ...toolConfig?.requestedTool ? { requestedTool: toolConfig.requestedTool } : {},
     ...toolConfig?.requestedInvocationChannel ? { requestedInvocationChannel: toolConfig.requestedInvocationChannel } : {},
+    ...modelConfig.providerId ? { requestedProviderId: modelConfig.providerId } : {},
+    ...modelConfig.modelId ? { requestedModelId: modelConfig.modelId } : {},
+    ...modelConfig.modelVariant ? { requestedModelVariant: modelConfig.modelVariant } : {},
+    ...modelConfig.reasoningEffort ? { requestedReasoningEffort: modelConfig.reasoningEffort } : {},
     ...toolConfig?.effectiveTool ? { effectiveTool: toolConfig.effectiveTool } : {},
     ...toolConfig?.effectiveInvocationChannel ? { effectiveInvocationChannel: toolConfig.effectiveInvocationChannel } : {},
-    ...toolConfig?.model ? { effectiveModel: toolConfig.model } : {},
+    ...effectiveModelConfig.model ? { effectiveModel: effectiveModelConfig.model } : {},
+    ...effectiveModelConfig.providerId ? { effectiveProviderId: effectiveModelConfig.providerId } : {},
+    ...effectiveModelConfig.modelId ? { effectiveModelId: effectiveModelConfig.modelId } : {},
+    ...effectiveModelConfig.modelVariant ? { effectiveModelVariant: effectiveModelConfig.modelVariant } : {},
+    ...effectiveModelConfig.reasoningEffort ? { effectiveReasoningEffort: effectiveModelConfig.reasoningEffort } : {},
     ...toolConfig?.source ? { preferenceSource: toolConfig.source } : {},
     ...toolConfig?.status ? { preferenceStatus: toolConfig.status } : {},
     ...toolConfig?.message ? { preferenceMessage: toolConfig.message } : {}
   };
 }
 function runnerMachineId() {
-  return createHash6("sha256").update(`${os7.hostname()}:${os7.platform()}:${os7.arch()}`).digest("hex").slice(0, 20);
+  return createHash7("sha256").update(`${os7.hostname()}:${os7.platform()}:${os7.arch()}`).digest("hex").slice(0, 20);
 }
 async function delay(milliseconds) {
   await new Promise((resolve) => setTimeout(resolve, milliseconds));