open-walnut 0.4.1 → 0.4.3

package/dist/web/server.js

@@ -2018,10 +2018,155 @@ var init_model_catalog = __esm({
   }
 });
 
-// src/core/ssh-config-scanner.ts
-import fs3 from "fs/promises";
-import path3 from "path";
+// src/core/claude-cli-detect.ts
+var claude_cli_detect_exports = {};
+__export(claude_cli_detect_exports, {
+  _CLAUDE_CREDENTIALS_HOME: () => _CLAUDE_CREDENTIALS_HOME,
+  describeClaudeCliAuth: () => describeClaudeCliAuth,
+  detectClaudeCli: () => detectClaudeCli,
+  hasClaudeSubscriptionAuth: () => hasClaudeSubscriptionAuth,
+  isClaudeCliInstalled: () => isClaudeCliInstalled,
+  resolveClaudeCliExecutable: () => resolveClaudeCliExecutable
+});
+import { execFileSync } from "child_process";
+import fs3 from "fs";
 import os2 from "os";
+import path3 from "path";
+function resolveClaudeCliExecutable(env3 = process.env) {
+  const home = env3.HOME || os2.homedir();
+  const pathDirs = (env3.PATH ?? "").split(path3.delimiter).filter(Boolean);
+  const fallbackDirs = [
+    path3.join(home, ".toolbox", "bin"),
+    path3.join(home, ".local", "bin"),
+    path3.join(home, ".npm-global", "bin"),
+    path3.join(home, ".bun", "bin"),
+    "/usr/local/bin",
+    "/opt/homebrew/bin",
+    "/usr/bin",
+    "/bin"
+  ];
+  for (const dir2 of [.../* @__PURE__ */ new Set([...pathDirs, ...fallbackDirs])]) {
+    const candidate = path3.join(dir2, "claude");
+    try {
+      fs3.accessSync(candidate, fs3.constants.X_OK);
+      return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function isClaudeCliInstalled() {
+  return resolveClaudeCliExecutable() !== null;
+}
+function hasClaudeSubscriptionAuth() {
+  if (process.platform === "darwin") {
+    try {
+      execFileSync("security", ["find-generic-password", "-s", KEYCHAIN_OAUTH_SERVICE], {
+        stdio: "ignore"
+      });
+      return true;
+    } catch {
+    }
+  }
+  return fileCredentialExists();
+}
+function fileCredentialExists() {
+  try {
+    return fs3.existsSync(CLAUDE_CREDENTIALS_FILE);
+  } catch {
+    return false;
+  }
+}
+function detectClaudeCli() {
+  const installed2 = isClaudeCliInstalled();
+  const subscriptionAuth = installed2 && hasClaudeSubscriptionAuth();
+  return {
+    installed: installed2,
+    subscriptionAuth,
+    subscriptionReady: installed2 && subscriptionAuth,
+    ready: installed2,
+    auth: installed2 ? describeClaudeCliAuth() : { mode: "unknown", label: "not installed" }
+  };
+}
+function describeClaudeCliAuth(env3 = process.env, settingsEnv = readClaudeSettingsEnv()) {
+  const merged = { ...env3, ...settingsEnv };
+  const truthy = (v3) => !!v3 && v3 !== "0" && v3.toLowerCase() !== "false";
+  if (truthy(merged.CLAUDE_CODE_USE_BEDROCK)) {
+    const region = merged.AWS_REGION || merged.AWS_DEFAULT_REGION;
+    return { mode: "bedrock", label: region ? `Bedrock (${region})` : "Bedrock" };
+  }
+  if (truthy(merged.CLAUDE_CODE_USE_VERTEX)) return { mode: "vertex", label: "Vertex AI" };
+  if (merged.ANTHROPIC_API_KEY || merged.ANTHROPIC_AUTH_TOKEN) return { mode: "api-key", label: "an Anthropic API key" };
+  if (hasClaudeSubscriptionAuth()) return { mode: "subscription", label: "your Claude subscription" };
+  return { mode: "unknown", label: "its own login" };
+}
+function readClaudeSettingsEnv() {
+  try {
+    const raw = fs3.readFileSync(path3.join(os2.homedir(), ".claude", "settings.json"), "utf8");
+    const env3 = JSON.parse(raw).env ?? {};
+    return Object.fromEntries(Object.entries(env3).filter(([, v3]) => typeof v3 === "string"));
+  } catch {
+    return {};
+  }
+}
+var KEYCHAIN_OAUTH_SERVICE, _CLAUDE_CREDENTIALS_HOME;
+var init_claude_cli_detect = __esm({
+  "src/core/claude-cli-detect.ts"() {
+    "use strict";
+    init_constants();
+    KEYCHAIN_OAUTH_SERVICE = "Claude Code-credentials";
+    _CLAUDE_CREDENTIALS_HOME = os2.homedir();
+  }
+});
+
+// src/agent/providers/default-provider.ts
+var default_provider_exports = {};
+__export(default_provider_exports, {
+  CLAUDE_CLI_PROVIDER: () => CLAUDE_CLI_PROVIDER,
+  LEGACY_DEFAULT_PROVIDER: () => LEGACY_DEFAULT_PROVIDER,
+  _resetDefaultProviderCacheForTesting: () => _resetDefaultProviderCacheForTesting,
+  hasExplicitBedrockConfig: () => hasExplicitBedrockConfig,
+  mainProviderIsImplicit: () => mainProviderIsImplicit,
+  resolveMainProviderName: () => resolveMainProviderName
+});
+function claudeCliInstalledCached() {
+  const now = Date.now();
+  if (!cliProbe || now - cliProbe.at > CLI_PROBE_TTL_MS) {
+    cliProbe = { at: now, installed: isClaudeCliInstalled() };
+  }
+  return cliProbe.installed;
+}
+function _resetDefaultProviderCacheForTesting() {
+  cliProbe = void 0;
+}
+function hasExplicitBedrockConfig(config) {
+  const b8 = config.providers?.bedrock;
+  if (b8 && (b8.bearer_token || b8.aws_access_key_id || b8.aws_profile || b8.aws_credential_export)) return true;
+  return !!config.provider?.bedrock_bearer_token;
+}
+function resolveMainProviderName(config, claudeInstalled = claudeCliInstalledCached()) {
+  if (config.agent?.main_provider) return config.agent.main_provider;
+  if (claudeInstalled) return CLAUDE_CLI_PROVIDER;
+  return LEGACY_DEFAULT_PROVIDER;
+}
+function mainProviderIsImplicit(config) {
+  return !config.agent?.main_provider;
+}
+var LEGACY_DEFAULT_PROVIDER, CLAUDE_CLI_PROVIDER, CLI_PROBE_TTL_MS, cliProbe;
+var init_default_provider = __esm({
+  "src/agent/providers/default-provider.ts"() {
+    "use strict";
+    init_claude_cli_detect();
+    LEGACY_DEFAULT_PROVIDER = "bedrock";
+    CLAUDE_CLI_PROVIDER = "claude_cli";
+    CLI_PROBE_TTL_MS = 6e4;
+  }
+});
+
+// src/core/ssh-config-scanner.ts
+import fs4 from "fs/promises";
+import path4 from "path";
+import os3 from "os";
 function isGitServerHost(h8) {
   if (h8.user === "git") return true;
   const gitPrefix = /^(git|github|gitlab|bitbucket|codecommit|ssh\.github)\./i;
@@ -2037,10 +2182,10 @@ function shortLabelForFqdn(hostname) {
   return `${first.slice(0, 12)}\u2026${first.slice(-8)}`;
 }
 async function scanSshConfig(configPath) {
-  const sshConfigPath = configPath ?? path3.join(os2.homedir(), ".ssh", "config");
+  const sshConfigPath = configPath ?? path4.join(os3.homedir(), ".ssh", "config");
   let mtimeMs2;
   try {
-    mtimeMs2 = (await fs3.stat(sshConfigPath)).mtimeMs;
+    mtimeMs2 = (await fs4.stat(sshConfigPath)).mtimeMs;
   } catch {
     return /* @__PURE__ */ new Map();
   }
@@ -2053,7 +2198,7 @@ async function scanSshConfig(configPath) {
 async function parseSshConfigFile(sshConfigPath) {
   const discovered = /* @__PURE__ */ new Map();
   try {
-    const content = await fs3.readFile(sshConfigPath, "utf-8");
+    const content = await fs4.readFile(sshConfigPath, "utf-8");
     const lines = content.split("\n");
     let currentHost = null;
     for (const rawLine of lines) {
@@ -2154,23 +2299,24 @@ __export(config_manager_exports, {
   updatePushTokens: () => updatePushTokens,
   writeFileAtomic: () => writeFileAtomic
 });
-import fs4 from "fs/promises";
+import fs5 from "fs/promises";
 import yaml from "js-yaml";
-function resolveAgentEngineProvider(config) {
+function resolveAgentEngineProvider(config, claudeInstalled) {
   if (CLOUD_MODE) return "walnut-agent";
   const raw = config.agent?.provider;
   if (typeof raw === "string" && VALID_AGENT_ENGINE_PROVIDERS.has(raw)) {
     return raw;
   }
-  if (raw !== void 0) {
-    log.session.warn("config-manager: agent.provider is not a known engine \u2014 using the default", {
-      value: typeof raw === "string" ? raw : `<${typeof raw}>`,
-      using: FALLBACK_AGENT_ENGINE_PROVIDER,
-      valid: [...VALID_AGENT_ENGINE_PROVIDERS].join(", ")
-    });
-    return FALLBACK_AGENT_ENGINE_PROVIDER;
+  if (raw === void 0) {
+    const main = claudeInstalled === void 0 ? resolveMainProviderName(config) : resolveMainProviderName(config, claudeInstalled);
+    return main === CLAUDE_CLI_PROVIDER ? "claude-code" : "walnut-agent";
   }
-  return DEFAULT_AGENT_ENGINE_PROVIDER;
+  log.session.warn("config-manager: agent.provider is not a known engine \u2014 using the fallback", {
+    value: typeof raw === "string" ? raw : `<${typeof raw}>`,
+    using: FALLBACK_AGENT_ENGINE_PROVIDER,
+    valid: [...VALID_AGENT_ENGINE_PROVIDERS].join(", ")
+  });
+  return FALLBACK_AGENT_ENGINE_PROVIDER;
 }
 function migrateConfigToProjectOnly(config) {
   let changed = false;
@@ -2243,13 +2389,13 @@ function migrateConfigToProjectOnly(config) {
 }
 async function readRawConfigContent() {
   try {
-    const primary = await fs4.readFile(CONFIG_FILE, "utf-8");
+    const primary = await fs5.readFile(CONFIG_FILE, "utf-8");
     if (primary.trim()) return primary;
     throw new Error("config.yaml is empty");
   } catch (primaryErr) {
     let backup;
     try {
-      backup = await fs4.readFile(CONFIG_BACKUP_FILE, "utf-8");
+      backup = await fs5.readFile(CONFIG_BACKUP_FILE, "utf-8");
     } catch {
       return null;
     }
@@ -2259,7 +2405,7 @@ async function readRawConfigContent() {
       backup: CONFIG_BACKUP_FILE
     });
     try {
-      await fs4.writeFile(CONFIG_FILE, backup, "utf-8");
+      await fs5.writeFile(CONFIG_FILE, backup, "utf-8");
     } catch {
     }
     return backup;
@@ -2268,10 +2414,10 @@ async function readRawConfigContent() {
 async function writeFileAtomic(filePath, content) {
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now().toString(36)}`;
   try {
-    await fs4.writeFile(tmp, content, "utf-8");
-    await fs4.rename(tmp, filePath);
+    await fs5.writeFile(tmp, content, "utf-8");
+    await fs5.rename(tmp, filePath);
   } catch (err2) {
-    await fs4.rm(tmp, { force: true }).catch(() => {
+    await fs5.rm(tmp, { force: true }).catch(() => {
     });
     throw err2;
   }
@@ -2469,7 +2615,7 @@ async function seedConfigDefaults() {
   const config = await getConfig();
   let needsWrite = false;
   try {
-    const raw = await fs4.readFile(CONFIG_FILE, "utf-8");
+    const raw = await fs5.readFile(CONFIG_FILE, "utf-8");
     if (!raw.includes("available_models")) {
       needsWrite = true;
     }
@@ -2497,6 +2643,7 @@ var init_config_manager = __esm({
     init_constants();
     init_types();
     init_model_catalog();
+    init_default_provider();
     init_ssh_config_scanner();
     DEFAULT_CONFIG = {
       version: 1,
@@ -2508,12 +2655,12 @@ var init_config_manager = __esm({
       // so this never re-routes an established setup.
       defaults: { priority: "none", platform: "local" },
       provider: { type: "claude-code" },
-      // Which ENGINE answers a Personal AI chat turn. 'walnut-agent' = today's in-process
-      // agent loop; 'claude-code' routes the turn into a lane-bound `claude` session.
-      // NOTE: getConfig() spreads the parsed file OVER these defaults at the TOP
-      // level, so a config.yaml with any `agent:` section replaces this whole object
-      // — resolveAgentEngineProvider() (below) is what actually applies the default.
-      agent: { provider: DEFAULT_AGENT_ENGINE_PROVIDER }
+      // Which ENGINE answers a Personal AI chat turn is NOT defaulted here: it follows
+      // the AI provider (Settings → AI Provider) — see resolveAgentEngineProvider().
+      // getConfig() spreads the parsed file OVER these defaults at the TOP level, so
+      // anything put in this object is dropped by any config.yaml with an `agent:`
+      // section; the resolver is what actually applies the rule.
+      agent: {}
     };
     CONFIG_BACKUP_FILE = `${CONFIG_FILE}.bak`;
     writeLock = Promise.resolve();
@@ -2521,14 +2668,14 @@ var init_config_manager = __esm({
 });
 
 // src/utils/file-lock.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import fsp2 from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 function lockDir(filePath) {
   return filePath + ".lock";
 }
 function pidFile(lock) {
-  return path4.join(lock, "pid");
+  return path5.join(lock, "pid");
 }
 function isPidAlive(pid) {
   try {
@@ -2541,7 +2688,7 @@ function isPidAlive(pid) {
 async function withFileLock(filePath, fn) {
   const lock = lockDir(filePath);
   const deadline4 = Date.now() + TIMEOUT_MS;
-  await fsp2.mkdir(path4.dirname(lock), { recursive: true });
+  await fsp2.mkdir(path5.dirname(lock), { recursive: true });
   while (true) {
     try {
       await fsp2.mkdir(lock);
@@ -2616,10 +2763,10 @@ __export(device_auth_exports, {
   verifyDeviceToken: () => verifyDeviceToken
 });
 import crypto2 from "crypto";
-import fs6 from "fs/promises";
-import path5 from "path";
+import fs7 from "fs/promises";
+import path6 from "path";
 function authFilePath() {
-  return path5.join(WALNUT_HOME, "auth.json");
+  return path6.join(WALNUT_HOME, "auth.json");
 }
 function sha256Hex(input) {
   return crypto2.createHash("sha256").update(input, "utf-8").digest("hex");
@@ -2634,7 +2781,7 @@ async function loadAuth() {
   const file = authFilePath();
   let raw;
   try {
-    raw = await fs6.readFile(file, "utf-8");
+    raw = await fs7.readFile(file, "utf-8");
   } catch {
     const recovered = await readAuthBackup();
     if (recovered) {
@@ -2667,7 +2814,7 @@ function authBackupPath() {
 }
 async function readAuthBackup() {
   try {
-    const raw = await fs6.readFile(authBackupPath(), "utf-8");
+    const raw = await fs7.readFile(authBackupPath(), "utf-8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed.devices)) return null;
     const devices = parsed.devices.filter((d8) => d8 && typeof d8.name === "string" && typeof d8.tokenHash === "string");
@@ -2678,14 +2825,14 @@ async function readAuthBackup() {
 }
 async function saveAuth(auth) {
   const file = authFilePath();
-  await fs6.mkdir(path5.dirname(file), { recursive: true });
+  await fs7.mkdir(path6.dirname(file), { recursive: true });
   const tmp = `${file}.tmp-${process.pid}`;
-  await fs6.writeFile(tmp, JSON.stringify(auth, null, 2) + "\n", { mode: 384 });
-  await fs6.rename(tmp, file);
+  await fs7.writeFile(tmp, JSON.stringify(auth, null, 2) + "\n", { mode: 384 });
+  await fs7.rename(tmp, file);
   try {
     const btmp = `${authBackupPath()}.tmp-${process.pid}`;
-    await fs6.writeFile(btmp, JSON.stringify(auth, null, 2) + "\n", { mode: 384 });
-    await fs6.rename(btmp, authBackupPath());
+    await fs7.writeFile(btmp, JSON.stringify(auth, null, 2) + "\n", { mode: 384 });
+    await fs7.rename(btmp, authBackupPath());
   } catch (err2) {
     log.web.warn("failed to update auth.json.bak", { error: err2 instanceof Error ? err2.message : String(err2) });
   }
@@ -2813,7 +2960,7 @@ async function readProvisionedSetupToken() {
     if (file) {
       source = "file";
       try {
-        candidate = await fs6.readFile(file, "utf-8");
+        candidate = await fs7.readFile(file, "utf-8");
       } catch (err2) {
         const code = err2.code;
         if (code !== "ENOENT") {
@@ -2904,7 +3051,7 @@ async function claimInstance(candidateToken, deviceName) {
   const tokenFile = process.env.WALNUT_SETUP_TOKEN_FILE;
   if (tokenFile) {
     try {
-      await fs6.unlink(tokenFile);
+      await fs7.unlink(tokenFile);
     } catch {
     }
   }
@@ -4893,8 +5040,8 @@ var init_format = __esm({
 
 // src/utils/json-conflict-recovery.ts
 import fsp3 from "fs/promises";
-import path6 from "path";
-import os3 from "os";
+import path7 from "path";
+import os4 from "os";
 import crypto5 from "crypto";
 import { execFile } from "child_process";
 import { promisify } from "util";
@@ -4974,12 +5121,12 @@ function jsonCandidatesFromPorcelain(lines) {
   return [...out];
 }
 function resolveWalnutDataDir() {
-  return process.env.OPEN_WALNUT_HOME || path6.join(os3.homedir(), ".open-walnut");
+  return process.env.OPEN_WALNUT_HOME || path7.join(os4.homedir(), ".open-walnut");
 }
 function isInsideWalnutDataDir(filePath) {
-  const dataDir2 = path6.resolve(resolveWalnutDataDir());
-  const abs = path6.resolve(filePath);
-  return abs === dataDir2 || abs.startsWith(dataDir2 + path6.sep);
+  const dataDir2 = path7.resolve(resolveWalnutDataDir());
+  const abs = path7.resolve(filePath);
+  return abs === dataDir2 || abs.startsWith(dataDir2 + path7.sep);
 }
 async function gitRead(repoDir, args) {
   try {
@@ -5014,17 +5161,17 @@ async function findLastValidJsonVersion(repoDir, relPath, depth = HISTORY_DEPTH)
   return null;
 }
 async function findRepoRootUpward(startDir, boundaryDir) {
-  const boundary = path6.resolve(boundaryDir);
-  let dir2 = path6.resolve(startDir);
-  if (dir2 !== boundary && !dir2.startsWith(boundary + path6.sep)) return null;
+  const boundary = path7.resolve(boundaryDir);
+  let dir2 = path7.resolve(startDir);
+  if (dir2 !== boundary && !dir2.startsWith(boundary + path7.sep)) return null;
   for (; ; ) {
     try {
-      await fsp3.stat(path6.join(dir2, ".git"));
+      await fsp3.stat(path7.join(dir2, ".git"));
       return dir2;
     } catch {
     }
     if (dir2 === boundary) return null;
-    const parent = path6.dirname(dir2);
+    const parent = path7.dirname(dir2);
     if (parent === dir2) return null;
     dir2 = parent;
   }
@@ -5055,8 +5202,8 @@ function sidecarPath(filePath, label) {
   return `${filePath}.${label}-${stamp}`;
 }
 async function writeFileAtomic2(filePath, content) {
-  const dir2 = path6.dirname(filePath);
-  const tmp = path6.join(dir2, `.open-walnut-${crypto5.randomBytes(8).toString("hex")}.tmp`);
+  const dir2 = path7.dirname(filePath);
+  const tmp = path7.join(dir2, `.open-walnut-${crypto5.randomBytes(8).toString("hex")}.tmp`);
   try {
     await fsp3.writeFile(tmp, content, "utf-8");
     await fsp3.rename(tmp, filePath);
@@ -5067,7 +5214,7 @@ async function writeFileAtomic2(filePath, content) {
   }
 }
 async function healJsonFileFromHistory(opts) {
-  const relPath = (opts.relPath ?? path6.relative(opts.repoDir, opts.filePath)).split(path6.sep).join("/");
+  const relPath = (opts.relPath ?? path7.relative(opts.repoDir, opts.filePath)).split(path7.sep).join("/");
   if (relPath.startsWith("..")) return { action: "skipped", error: "file is outside repoDir" };
   const valid = await findLastValidJsonVersion(opts.repoDir, relPath, opts.depth);
   const parked = sidecarPath(opts.filePath, opts.label);
@@ -5094,7 +5241,7 @@ async function healJsonFileFromHistory(opts) {
   return { action: "restored", restoredFrom: valid.rev, movedTo, content: valid.content };
 }
 async function selfHealDataDirJson(filePath) {
-  const abs = path6.resolve(filePath);
+  const abs = path7.resolve(filePath);
   if (!isInsideWalnutDataDir(abs)) return null;
   const failedAt = selfHealFailedAt.get(abs);
   if (failedAt !== void 0 && Date.now() - failedAt < SELF_HEAL_FAILURE_MEMO_MS) return null;
@@ -5102,7 +5249,7 @@ async function selfHealDataDirJson(filePath) {
   if (existing) return existing;
   const work = (async () => {
     const dataDir2 = resolveWalnutDataDir();
-    const repoRoot = await findRepoRootUpward(path6.dirname(abs), dataDir2);
+    const repoRoot = await findRepoRootUpward(path7.dirname(abs), dataDir2);
     if (!repoRoot) return null;
     const result = await healJsonFileFromHistory({
       repoDir: repoRoot,
@@ -5145,25 +5292,25 @@ var init_json_conflict_recovery = __esm({
 });
 
 // src/utils/fs.ts
-import fs7 from "fs/promises";
-import path7 from "path";
+import fs8 from "fs/promises";
+import path8 from "path";
 import crypto6 from "crypto";
 async function writeJsonFile(filePath, data, options = {}) {
-  const dir2 = path7.dirname(filePath);
-  await fs7.mkdir(dir2, { recursive: true });
-  const tmpFile = path7.join(
+  const dir2 = path8.dirname(filePath);
+  await fs8.mkdir(dir2, { recursive: true });
+  const tmpFile = path8.join(
     dir2,
     `.open-walnut-${crypto6.randomBytes(8).toString("hex")}.tmp`
   );
   try {
-    await fs7.writeFile(tmpFile, JSON.stringify(data, null, 2) + "\n", {
+    await fs8.writeFile(tmpFile, JSON.stringify(data, null, 2) + "\n", {
       encoding: "utf-8",
       ...options.mode === void 0 ? {} : { mode: options.mode }
     });
-    await fs7.rename(tmpFile, filePath);
-    if (options.mode !== void 0) await fs7.chmod(filePath, options.mode);
+    await fs8.rename(tmpFile, filePath);
+    if (options.mode !== void 0) await fs8.chmod(filePath, options.mode);
   } catch (err2) {
-    await fs7.rm(tmpFile, { force: true }).catch(() => {
+    await fs8.rm(tmpFile, { force: true }).catch(() => {
     });
     throw err2;
   }
@@ -5171,7 +5318,7 @@ async function writeJsonFile(filePath, data, options = {}) {
 async function readJsonFile(filePath, fallback) {
   let content;
   try {
-    content = await fs7.readFile(filePath, "utf-8");
+    content = await fs8.readFile(filePath, "utf-8");
   } catch (err2) {
     if (err2 && typeof err2 === "object" && "code" in err2 && err2.code === "ENOENT") {
       return fallback;
@@ -5213,7 +5360,7 @@ async function updateJsonFile(filePath, fallback, mutate2, options = {}) {
   });
 }
 async function ensureDir(dirPath) {
-  await fs7.mkdir(dirPath, { recursive: true });
+  await fs8.mkdir(dirPath, { recursive: true });
 }
 var init_fs = __esm({
   "src/utils/fs.ts"() {
@@ -5238,7 +5385,7 @@ __export(file_ops_exports, {
 });
 import crypto7 from "crypto";
 import fsp4 from "fs/promises";
-import path8 from "path";
+import path9 from "path";
 function computeContentHash(content) {
   return crypto7.createHash("sha256").update(content).digest("hex").slice(0, 12);
 }
@@ -5314,7 +5461,7 @@ async function editFileContent(filePath, oldContent, newContent, opts) {
   });
 }
 async function writeFileChecked(filePath, content, opts) {
-  await fsp4.mkdir(path8.dirname(filePath), { recursive: true });
+  await fsp4.mkdir(path9.dirname(filePath), { recursive: true });
   return withFileLock(filePath, async () => {
     if (opts?.expectedHash != null) {
       let raw;
@@ -5386,16 +5533,16 @@ __export(memory_file_exports, {
   getMemoryFile: () => getMemoryFile,
   updateMemoryFile: () => updateMemoryFile
 });
-import fs8 from "fs";
-import path9 from "path";
+import fs9 from "fs";
+import path10 from "path";
 function resolveMemoryPath(agentId) {
   if (!agentId || agentId === "general") return MEMORY_FILE;
-  return path9.join(agentMemoryDir(agentId), "MEMORY.md");
+  return path10.join(agentMemoryDir(agentId), "MEMORY.md");
 }
 function getMemoryFile(agentId) {
   const filePath = resolveMemoryPath(agentId);
   try {
-    const content = fs8.readFileSync(filePath, "utf-8");
+    const content = fs9.readFileSync(filePath, "utf-8");
     return { content, contentHash: computeContentHash(content) };
   } catch (err2) {
     log.memory.debug("memory-file: MEMORY.md not found or unreadable", {
@@ -5406,7 +5553,7 @@ function getMemoryFile(agentId) {
 }
 async function updateMemoryFile(content, expectedHash, agentId) {
   const filePath = resolveMemoryPath(agentId);
-  fs8.mkdirSync(path9.dirname(filePath), { recursive: true });
+  fs9.mkdirSync(path10.dirname(filePath), { recursive: true });
   const result = await writeFileChecked(filePath, content, {
     expectedHash
   });
@@ -5421,9 +5568,9 @@ async function editMemoryFile(oldContent, newContent, expectedHash, replaceAll,
 }
 function ensureMemoryFile(agentId) {
   const filePath = resolveMemoryPath(agentId);
-  if (fs8.existsSync(filePath)) return;
-  fs8.mkdirSync(path9.dirname(filePath), { recursive: true });
-  fs8.writeFileSync(filePath, DEFAULT_TEMPLATE, "utf-8");
+  if (fs9.existsSync(filePath)) return;
+  fs9.mkdirSync(path10.dirname(filePath), { recursive: true });
+  fs9.writeFileSync(filePath, DEFAULT_TEMPLATE, "utf-8");
 }
 var DEFAULT_TEMPLATE;
 var init_memory_file = __esm({
@@ -5443,15 +5590,15 @@ description: >
 
 // src/core/tmp-sweep.ts
 import fsp5 from "fs/promises";
-import path10 from "path";
+import path11 from "path";
 function sweepDirs() {
   return [
     WALNUT_HOME,
     SYNC_DIR,
-    path10.join(WALNUT_HOME, "sessions"),
-    path10.join(WALNUT_HOME, "sessions", "transcripts"),
+    path11.join(WALNUT_HOME, "sessions"),
+    path11.join(WALNUT_HOME, "sessions", "transcripts"),
     TASKS_DIR,
-    path10.join(TASKS_DIR, "outbox"),
+    path11.join(TASKS_DIR, "outbox"),
     CONVERSATIONS_DIR,
     MEMORY_DIR,
     DAILY_DIR,
@@ -5472,7 +5619,7 @@ async function sweepOrphanAtomicTmpFiles() {
       const entries = await fsp5.readdir(dir2, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isFile() || !ORPHAN_RE.test(entry.name)) continue;
-        const full = path10.join(dir2, entry.name);
+        const full = path11.join(dir2, entry.name);
         try {
           const st = await fsp5.stat(full);
           if (st.mtimeMs > cutoff) continue;
@@ -5509,10 +5656,10 @@ __export(init_exports, {
   initDirectories: () => initDirectories
 });
 import fsp6 from "fs/promises";
-import fs9 from "fs";
+import fs10 from "fs";
 async function migrateLegacyMemoryFile() {
   try {
-    if (fs9.existsSync(LEGACY_MEMORY_FILE) && !fs9.existsSync(MEMORY_FILE)) {
+    if (fs10.existsSync(LEGACY_MEMORY_FILE) && !fs10.existsSync(MEMORY_FILE)) {
       await fsp6.rename(LEGACY_MEMORY_FILE, MEMORY_FILE);
       log.memory.info("Migrated MEMORY.md into memory/ folder", { from: LEGACY_MEMORY_FILE, to: MEMORY_FILE });
     }
@@ -6057,15 +6204,15 @@ __export(task_db_exports, {
   transaction: () => transaction
 });
 import Database from "better-sqlite3";
-import fs10 from "fs";
-import path11 from "path";
+import fs11 from "fs";
+import path12 from "path";
 import yaml2 from "js-yaml";
 function getDb() {
   if (db) return db;
   if (initAttempted) throw initError;
   initAttempted = true;
   try {
-    fs10.mkdirSync(path11.dirname(TASK_DB_PATH), { recursive: true });
+    fs11.mkdirSync(path12.dirname(TASK_DB_PATH), { recursive: true });
     const handle2 = new Database(TASK_DB_PATH);
     handle2.pragma("journal_mode = WAL");
     handle2.pragma("busy_timeout = 5000");
@@ -6295,8 +6442,8 @@ function migrateToProjectOnly(handle2) {
   }
   try {
     handle2.pragma("wal_checkpoint(TRUNCATE)");
-    if (!fs10.existsSync(TASK_DB_PRE_V5_BACKUP_PATH)) {
-      fs10.copyFileSync(TASK_DB_PATH, TASK_DB_PRE_V5_BACKUP_PATH);
+    if (!fs11.existsSync(TASK_DB_PRE_V5_BACKUP_PATH)) {
+      fs11.copyFileSync(TASK_DB_PATH, TASK_DB_PRE_V5_BACKUP_PATH);
       log.task.info("task-db v5: wrote pre-migration backup", { path: TASK_DB_PRE_V5_BACKUP_PATH });
     }
   } catch (err2) {
@@ -6806,7 +6953,7 @@ var init_task_db = __esm({
     init_constants();
     init_logging();
     init_phase2();
-    TASK_DB_PATH = path11.join(TASKS_DIR, "tasks.sqlite");
+    TASK_DB_PATH = path12.join(TASKS_DIR, "tasks.sqlite");
     EXPLICIT_TASK_COLUMNS = [
       "id",
       "title",
@@ -6969,8 +7116,8 @@ var init_task_db = __esm({
 });
 
 // src/core/task-db-migration.ts
-import fs11 from "fs";
-import path12 from "path";
+import fs12 from "fs";
+import path13 from "path";
 import yaml3 from "js-yaml";
 async function runMigrationIfNeeded() {
   const db5 = getDb();
@@ -6981,7 +7128,7 @@ async function runMigrationIfNeeded() {
   if (existing.n > 0) {
     return { migrated: false, count: existing.n };
   }
-  if (!fs11.existsSync(TASKS_FILE)) {
+  if (!fs12.existsSync(TASKS_FILE)) {
     return { migrated: false, count: 0 };
   }
   const store3 = await readJsonFile(TASKS_FILE, { version: 1, tasks: [] });
@@ -7138,9 +7285,9 @@ async function runMigrationIfNeeded() {
   }
   const after = db5.prepare("SELECT COUNT(*) AS n FROM tasks").get();
   const count2 = after.n;
-  const backupPath = path12.join(path12.dirname(TASKS_FILE), "tasks.json.migrated-from-json.backup");
+  const backupPath = path13.join(path13.dirname(TASKS_FILE), "tasks.json.migrated-from-json.backup");
   try {
-    fs11.copyFileSync(TASKS_FILE, backupPath);
+    fs12.copyFileSync(TASKS_FILE, backupPath);
   } catch (err2) {
     log.task.warn("task-db migration: backup copy failed (non-fatal)", {
       path: backupPath,
@@ -7164,9 +7311,9 @@ var init_task_db_migration = __esm({
 });
 
 // src/core/memory-dir-migration.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import fsp7 from "fs/promises";
-import path13 from "path";
+import path14 from "path";
 function bodyOf(content) {
   const fm = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/);
   return fm ? content.slice(fm[0].length) : content;
@@ -7184,7 +7331,7 @@ ${legacyBody}
 }
 function mtimeMs(file) {
   try {
-    return fs12.statSync(file).mtimeMs;
+    return fs13.statSync(file).mtimeMs;
   } catch {
     return 0;
   }
@@ -7193,24 +7340,24 @@ function findCandidates(root6) {
   const out = [];
   let level1;
   try {
-    level1 = fs12.readdirSync(root6, { withFileTypes: true });
+    level1 = fs13.readdirSync(root6, { withFileTypes: true });
   } catch {
     return out;
   }
   for (const cat of level1) {
     if (!cat.isDirectory()) continue;
-    const catDir = path13.join(root6, cat.name);
-    if (fs12.existsSync(path13.join(catDir, MEMORY_FILE_NAME))) continue;
+    const catDir = path14.join(root6, cat.name);
+    if (fs13.existsSync(path14.join(catDir, MEMORY_FILE_NAME))) continue;
     let level2;
     try {
-      level2 = fs12.readdirSync(catDir, { withFileTypes: true });
+      level2 = fs13.readdirSync(catDir, { withFileTypes: true });
     } catch {
       continue;
     }
     for (const proj of level2) {
       if (!proj.isDirectory()) continue;
-      const sourceDir = path13.join(catDir, proj.name);
-      if (!fs12.existsSync(path13.join(sourceDir, MEMORY_FILE_NAME))) continue;
+      const sourceDir = path14.join(catDir, proj.name);
+      if (!fs13.existsSync(path14.join(sourceDir, MEMORY_FILE_NAME))) continue;
       out.push({ category: cat.name, project: proj.name, sourceDir });
     }
   }
@@ -7224,11 +7371,11 @@ async function drainDir(from, to) {
     return;
   }
   for (const name of entries) {
-    const target = path13.join(to, name);
-    if (fs12.existsSync(target)) continue;
-    await fsp7.rename(path13.join(from, name), target).catch((err2) => {
+    const target = path14.join(to, name);
+    if (fs13.existsSync(target)) continue;
+    await fsp7.rename(path14.join(from, name), target).catch((err2) => {
       log.memory.warn("memory-dir migration: entry move failed", {
-        from: path13.join(from, name),
+        from: path14.join(from, name),
         to: target,
         error: String(err2)
       });
@@ -7240,23 +7387,23 @@ async function drainDir(from, to) {
 async function migrateProjectMemoryDirs() {
   const result = { ran: false, moved: 0, merged: 0 };
   try {
-    if (!fs12.existsSync(PROJECTS_MEMORY_DIR)) return result;
-    if (fs12.existsSync(MEMORY_DIR_MIGRATION_MARKER)) return result;
+    if (!fs13.existsSync(PROJECTS_MEMORY_DIR)) return result;
+    if (fs13.existsSync(MEMORY_DIR_MIGRATION_MARKER)) return result;
     result.ran = true;
     const candidates = findCandidates(PROJECTS_MEMORY_DIR);
     const touchedCategories = new Set(candidates.map((c8) => c8.category));
     for (const c8 of candidates) {
-      const targetDir = path13.join(PROJECTS_MEMORY_DIR, c8.project);
+      const targetDir = path14.join(PROJECTS_MEMORY_DIR, c8.project);
       const label = `${c8.category}/${c8.project}`;
       try {
-        if (!fs12.existsSync(targetDir)) {
+        if (!fs13.existsSync(targetDir)) {
           await fsp7.rename(c8.sourceDir, targetDir);
           result.moved += 1;
           continue;
         }
-        const sourceMem = path13.join(c8.sourceDir, MEMORY_FILE_NAME);
-        const targetMem = path13.join(targetDir, MEMORY_FILE_NAME);
-        if (!fs12.existsSync(targetMem)) {
+        const sourceMem = path14.join(c8.sourceDir, MEMORY_FILE_NAME);
+        const targetMem = path14.join(targetDir, MEMORY_FILE_NAME);
+        if (!fs13.existsSync(targetMem)) {
           await fsp7.rename(sourceMem, targetMem);
           await drainDir(c8.sourceDir, targetDir);
           result.moved += 1;
@@ -7278,7 +7425,7 @@ async function migrateProjectMemoryDirs() {
       }
     }
     for (const cat of touchedCategories) {
-      await fsp7.rmdir(path13.join(PROJECTS_MEMORY_DIR, cat)).catch(() => {
+      await fsp7.rmdir(path14.join(PROJECTS_MEMORY_DIR, cat)).catch(() => {
       });
     }
     await fsp7.writeFile(
@@ -7306,7 +7453,7 @@ var init_memory_dir_migration = __esm({
     "use strict";
     init_constants();
     init_logging();
-    MEMORY_DIR_MIGRATION_MARKER = path13.join(PROJECTS_MEMORY_DIR, ".migrated-project-only");
+    MEMORY_DIR_MIGRATION_MARKER = path14.join(PROJECTS_MEMORY_DIR, ".migrated-project-only");
     MEMORY_FILE_NAME = "MEMORY.md";
   }
 });
@@ -7522,7 +7669,7 @@ __export(microsoft_todo_exports, {
 });
 import * as msal from "@azure/msal-node";
 import https from "https";
-import path14 from "path";
+import path15 from "path";
 function getMsTodoConfig(config) {
   return config.plugins?.["ms-todo"];
 }
@@ -8741,8 +8888,8 @@ var init_microsoft_todo = __esm({
     init_format();
     init_task_manager();
     init_task_remote_links();
-    TOKENS_FILE = path14.join(SYNC_DIR, "ms-todo-tokens.json");
-    DELTA_FILE = path14.join(SYNC_DIR, "ms-todo-delta.json");
+    TOKENS_FILE = path15.join(SYNC_DIR, "ms-todo-tokens.json");
+    DELTA_FILE = path15.join(SYNC_DIR, "ms-todo-delta.json");
     GRAPH_BASE = "https://graph.microsoft.com/v1.0";
     SCOPES = ["Tasks.ReadWrite"];
     PRIORITY_TO_IMPORTANCE = {
@@ -8860,8 +9007,8 @@ var init_daemon_capabilities = __esm({
 
 // src/providers/daemon-version-check.ts
 import { createHash } from "crypto";
-import fs13 from "fs";
-import path15 from "path";
+import fs14 from "fs";
+import path16 from "path";
 import { spawnSync } from "child_process";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function computeExpectedDaemonVersion() {
@@ -8870,11 +9017,11 @@ function computeExpectedDaemonVersion() {
   const hash = createHash("sha256");
   const NUL = Buffer.from([0]);
   for (const rel of DAEMON_SOURCE_FILES) {
-    const abs = path15.join(repoRoot, rel);
+    const abs = path16.join(repoRoot, rel);
     try {
       hash.update(Buffer.from(rel));
       hash.update(NUL);
-      hash.update(fs13.readFileSync(abs));
+      hash.update(fs14.readFileSync(abs));
       hash.update(NUL);
     } catch {
       return null;
@@ -8883,12 +9030,12 @@ function computeExpectedDaemonVersion() {
   return "walnut-daemon-" + hash.digest("hex").slice(0, 12);
 }
 function findRepoRoot() {
-  let dir2 = path15.dirname(fileURLToPath2(import.meta.url));
+  let dir2 = path16.dirname(fileURLToPath2(import.meta.url));
   for (let i8 = 0; i8 < 10; i8++) {
-    if (fs13.existsSync(path15.join(dir2, "package.json")) && fs13.existsSync(path15.join(dir2, "src", "providers", "daemon-standalone.ts"))) {
+    if (fs14.existsSync(path16.join(dir2, "package.json")) && fs14.existsSync(path16.join(dir2, "src", "providers", "daemon-standalone.ts"))) {
       return dir2;
     }
-    const parent = path15.dirname(dir2);
+    const parent = path16.dirname(dir2);
     if (parent === dir2) break;
     dir2 = parent;
   }
@@ -9233,12 +9380,12 @@ var init_daemon_fold = __esm({
 });
 
 // src/providers/daemon-source.ts
-import fs14 from "fs";
-import path16 from "path";
+import fs15 from "fs";
+import path17 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function resolveDaemonSourceVersion() {
   const here = fileURLToPath3(import.meta.url);
-  const bundled = here.split(path16.sep).includes("dist");
+  const bundled = here.split(path17.sep).includes("dist");
   if (bundled) {
     const sidecar = readSidecarDaemonVersion(here);
     if (sidecar) return sidecar;
@@ -9246,32 +9393,32 @@ function resolveDaemonSourceVersion() {
   const computed = computeExpectedDaemonVersion();
   if (computed) return computed;
   if (process.env.DAEMON_VERSION) return process.env.DAEMON_VERSION;
-  let dir2 = path16.dirname(fileURLToPath3(import.meta.url));
+  let dir2 = path17.dirname(fileURLToPath3(import.meta.url));
   for (let i8 = 0; i8 < 10; i8++) {
     try {
-      const pkg = JSON.parse(fs14.readFileSync(path16.join(dir2, "package.json"), "utf-8"));
+      const pkg = JSON.parse(fs15.readFileSync(path17.join(dir2, "package.json"), "utf-8"));
       if (pkg.name === "open-walnut" && pkg.version) return `walnut-daemon-pkg-${pkg.version}`;
     } catch {
     }
-    const parent = path16.dirname(dir2);
+    const parent = path17.dirname(dir2);
     if (parent === dir2) break;
     dir2 = parent;
   }
   return "dev-source";
 }
 function readSidecarDaemonVersion(fromPath) {
-  let dir2 = path16.dirname(fromPath);
+  let dir2 = path17.dirname(fromPath);
   for (let i8 = 0; i8 < 5; i8++) {
-    const binDir = path16.join(dir2, "daemon-binaries");
+    const binDir = path17.join(dir2, "daemon-binaries");
     try {
-      for (const name of fs14.readdirSync(binDir)) {
+      for (const name of fs15.readdirSync(binDir)) {
         if (!name.endsWith(".version")) continue;
-        const v3 = fs14.readFileSync(path16.join(binDir, name), "utf-8").trim();
+        const v3 = fs15.readFileSync(path17.join(binDir, name), "utf-8").trim();
         if (v3) return v3;
       }
     } catch {
     }
-    const parent = path16.dirname(dir2);
+    const parent = path17.dirname(dir2);
     if (parent === dir2) break;
     dir2 = parent;
   }
@@ -10199,24 +10346,25 @@ function reapSession(sid, code, reason) {
   let jsonlAgeMs = null;
   try { jsonlAgeMs = Date.now() - fs.statSync(session.jsonlPath).mtimeMs; } catch {}
   const cleanExit = isTurnCompleteExit(session.jsonlPath);
-  // An INTENTIONAL daemon-initiated reclamation is not a failure, and the JSONL
-  // tail cannot tell us it happened. The idle scanner stamps idleReclaimAt
-  // before it signals; the death then lands here through whichever path notices
-  // it (usually orphan-poll ESRCH \u2192 code -1). Verified production case: the last
-  // line was a control_response (the reply to a Walnut-issued control request \u2014
-  // a routine shape), so isTurnCompleteExit said false, exitCode stayed -1, and
-  // the projection painted a red "Error" over a healthy, fully resumable session
-  // we reclaimed on purpose. Checked FIRST and unconditionally: the flag carries
-  // information the tail does not contain, which is why isTurnCompleteExit is
-  // left alone. Keep in sync with daemon-core.ts reapSession.
-  const intentionalReclaim = session.idleReclaimAt != null;
-  if (intentionalReclaim && code !== 0) {
-    logMsg('info', 'reapSession: intentional idle reclamation, normalizing exit code', {
+  // A DELIBERATE stop is not a failure, and the JSONL tail cannot tell us it
+  // happened. Both writers (our idle scanner, and any stop RPC via cmdStop)
+  // stamp intentionalStopAt before signalling; the death then lands here through
+  // whichever path notices it (usually orphan-poll ESRCH \u2192 code -1). Verified
+  // production case: the last line was a control_response (the reply to a
+  // Walnut-issued control request \u2014 a routine shape), so isTurnCompleteExit said
+  // false, exitCode stayed -1, and the projection painted a red "Error" over a
+  // healthy, fully resumable session that was stopped on purpose. Checked FIRST
+  // and unconditionally: the flag carries information the tail does not contain,
+  // which is why isTurnCompleteExit is left alone.
+  // Keep in sync with daemon-core.ts reapSession.
+  const intentionalStop = session.intentionalStopAt != null;
+  if (intentionalStop && code !== 0) {
+    logMsg('info', 'reapSession: intentional stop, normalizing exit code', {
       sid, pid: session.pid, originalCode: code, originalReason: reason,
-      jsonlAgeMs, cleanExit, idleReclaimAt: session.idleReclaimAt,
+      jsonlAgeMs, cleanExit, intentionalStopAt: session.intentionalStopAt,
     });
     code = 0;
-    reason = reason + '+intentional-idle-reclaim';
+    reason = reason + '+intentional-stop';
   } else if (code !== 0 && cleanExit) {
     logMsg('info', 'reapSession: turn-complete detected, normalizing exit code', {
       sid, pid: session.pid, originalCode: code, originalReason: reason, jsonlAgeMs,
@@ -13870,6 +14018,15 @@ function cmdStop(ws, id, cmd) {
   const pid = session.pid;
   logMsg('info', 'cmdStop: stopping session (process group kill)', { sid, pid });
 
+  // Nobody sends stop by accident, so record the intent BEFORE the first signal:
+  // the death lands asynchronously (orphan poll \u2192 ESRCH \u2192 code -1) and by then
+  // nothing remembers this was asked for. This path is how the SERVER's idle
+  // reaper kills (mgr.kill() \u2192 stop RPC), not the daemon's own scan, so it needs
+  // its own stamp: a LOCAL session auto-stopped after 2h idle surfaced as
+  // "Session ended unexpectedly and no cause was recorded" (2026-09-03).
+  // Keep in sync with daemon-standalone.ts cmdStop.
+  session.intentionalStopAt = Date.now();
+
   // An explicit stop is a human decision \u2014 never undone by a pending auto-retry
   // respawning the CLI minutes later. Cancel the timer AND clear the streak so
   // an in-flight result line can't re-arm one either.
@@ -13906,7 +14063,7 @@ function cmdStop(ws, id, cmd) {
 
 // \u2500\u2500 Status \u2500\u2500
 function cmdStatus(ws, id, cmd) {
-  const { sid } = cmd;
+  const { sid, includeArgs } = cmd;
   if (!sid) return sendError(ws, id, 'status: missing sid');
 
   const session = sessions.get(sid);
@@ -13937,6 +14094,11 @@ function cmdStatus(ws, id, cmd) {
     exitCode: session.exitCode,
     exitReason: session.exitReason,
     pendingCtrl: session.pendingCtrl,
+    // Opt-in: the argv the live process was launched with (a fork copies it to
+    // reproduce the parent's prompt-cache prefix). Off by default because the
+    // health monitor polls status for every session and the argv carries the
+    // multi-KB --append-system-prompt.
+    ...(includeArgs && session.args && session.args.length > 0 ? { args: session.args } : {}),
   });
 }
 
@@ -15989,7 +16151,7 @@ function scanIdleSessions() {
       // end" for any session whose last line isn't a type:result \u2014 and the
       // projection then shows a red Error for our own routine reclamation.
       // Keep in sync with daemon-standalone.ts scanIdleSessions.
-      session.idleReclaimAt = now;
+      session.intentionalStopAt = now;
       killSessionProcessGroup(pid, sid);
     }
   }
@@ -16370,7 +16532,7 @@ if (action === '--start') {
 });
 
 // src/core/jsonl-tailer.ts
-import fs15 from "fs";
+import fs16 from "fs";
 var init_jsonl_tailer = __esm({
   "src/core/jsonl-tailer.ts"() {
     "use strict";
@@ -16379,10 +16541,10 @@ var init_jsonl_tailer = __esm({
 });
 
 // src/providers/session-io.ts
-import fs16 from "fs";
+import fs17 from "fs";
 import fsp8 from "fs/promises";
-import path17 from "path";
-import { execFileSync } from "child_process";
+import path18 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
 function shellQuote(s4) {
   return "'" + s4.replace(/'/g, "'\\''") + "'";
 }
@@ -16427,7 +16589,7 @@ function findRelativeImageNames(text, opts) {
 function findLocalImagePaths(text) {
   return findImagePaths(text).filter((p6) => {
     try {
-      return fs16.statSync(p6).isFile();
+      return fs17.statSync(p6).isFile();
     } catch {
       return false;
     }
@@ -16673,19 +16835,19 @@ function createDaemonCore(deps) {
       jsonlAgeMs = clock() - fs114.statSync(session2.jsonlPath).mtimeMs;
     } catch {
     }
-    const intentionalReclaim = session2.idleReclaimAt != null;
-    if (intentionalReclaim && code !== 0) {
-      logger2("info", "reapSession: intentional idle reclamation, normalizing exit code", {
+    const intentionalStop = session2.intentionalStopAt != null;
+    if (intentionalStop && code !== 0) {
+      logger2("info", "reapSession: intentional stop, normalizing exit code", {
         sid,
         pid: session2.pid,
         originalCode: code,
         originalReason: reason,
         jsonlAgeMs,
         cleanExit,
-        idleReclaimAt: session2.idleReclaimAt
+        intentionalStopAt: session2.intentionalStopAt
       });
       code = 0;
-      reason = reason + "+intentional-idle-reclaim";
+      reason = reason + "+intentional-stop";
     } else if (cleanExit && code !== 0) {
       logger2("info", "reapSession: turn-complete detected, normalizing exit code", {
         sid,
@@ -17472,83 +17634,6 @@ var init_daemon_core = __esm({
   }
 });
 
-// src/core/claude-cli-detect.ts
-var claude_cli_detect_exports = {};
-__export(claude_cli_detect_exports, {
-  _CLAUDE_CREDENTIALS_HOME: () => _CLAUDE_CREDENTIALS_HOME,
-  detectClaudeCli: () => detectClaudeCli,
-  hasClaudeSubscriptionAuth: () => hasClaudeSubscriptionAuth,
-  isClaudeCliInstalled: () => isClaudeCliInstalled,
-  resolveClaudeCliExecutable: () => resolveClaudeCliExecutable
-});
-import { execFileSync as execFileSync2 } from "child_process";
-import fs17 from "fs";
-import os4 from "os";
-import path18 from "path";
-function resolveClaudeCliExecutable(env3 = process.env) {
-  const home = env3.HOME || os4.homedir();
-  const pathDirs = (env3.PATH ?? "").split(path18.delimiter).filter(Boolean);
-  const fallbackDirs = [
-    path18.join(home, ".toolbox", "bin"),
-    path18.join(home, ".local", "bin"),
-    path18.join(home, ".npm-global", "bin"),
-    path18.join(home, ".bun", "bin"),
-    "/usr/local/bin",
-    "/opt/homebrew/bin",
-    "/usr/bin",
-    "/bin"
-  ];
-  for (const dir2 of [.../* @__PURE__ */ new Set([...pathDirs, ...fallbackDirs])]) {
-    const candidate = path18.join(dir2, "claude");
-    try {
-      fs17.accessSync(candidate, fs17.constants.X_OK);
-      return candidate;
-    } catch {
-    }
-  }
-  return null;
-}
-function isClaudeCliInstalled() {
-  return resolveClaudeCliExecutable() !== null;
-}
-function hasClaudeSubscriptionAuth() {
-  if (process.platform === "darwin") {
-    try {
-      execFileSync2("security", ["find-generic-password", "-s", KEYCHAIN_OAUTH_SERVICE], {
-        stdio: "ignore"
-      });
-      return true;
-    } catch {
-    }
-  }
-  return fileCredentialExists();
-}
-function fileCredentialExists() {
-  try {
-    return fs17.existsSync(CLAUDE_CREDENTIALS_FILE);
-  } catch {
-    return false;
-  }
-}
-function detectClaudeCli() {
-  const installed2 = isClaudeCliInstalled();
-  const subscriptionAuth = installed2 && hasClaudeSubscriptionAuth();
-  return {
-    installed: installed2,
-    subscriptionAuth,
-    subscriptionReady: installed2 && subscriptionAuth
-  };
-}
-var KEYCHAIN_OAUTH_SERVICE, _CLAUDE_CREDENTIALS_HOME;
-var init_claude_cli_detect = __esm({
-  "src/core/claude-cli-detect.ts"() {
-    "use strict";
-    init_constants();
-    KEYCHAIN_OAUTH_SERVICE = "Claude Code-credentials";
-    _CLAUDE_CREDENTIALS_HOME = os4.homedir();
-  }
-});
-
 // src/providers/daemon-ownership.ts
 import fs18 from "fs";
 import os5 from "os";
@@ -24728,7 +24813,7 @@ __export(credential_resolver_exports, {
   DEFAULT_REGION: () => DEFAULT_REGION,
   hasResolvableCredential: () => hasResolvableCredential,
   readClaudeCredentialExport: () => readClaudeCredentialExport,
-  readClaudeSettingsEnv: () => readClaudeSettingsEnv,
+  readClaudeSettingsEnv: () => readClaudeSettingsEnv2,
   resolveCredentialFrom: () => resolveCredentialFrom,
   resolveCredentials: () => resolveCredentials,
   traceCredentialResolution: () => traceCredentialResolution
@@ -24883,7 +24968,7 @@ function traceCredentialResolution(inputs) {
     region: { value: winner.region ?? DEFAULT_REGION, source: regionSource }
   };
 }
-function readClaudeSettingsEnv(settingsFile = CLAUDE_SETTINGS_FILE) {
+function readClaudeSettingsEnv2(settingsFile = CLAUDE_SETTINGS_FILE) {
   try {
     const raw = fs31.readFileSync(settingsFile, "utf-8");
     const parsed = JSON.parse(raw);
@@ -24923,7 +25008,7 @@ function probeAwsFiles() {
 function resolveCredentials(config) {
   const result = resolveCredentialFrom({
     config,
-    claudeEnv: readClaudeSettingsEnv(),
+    claudeEnv: readClaudeSettingsEnv2(),
     processEnv: process.env,
     awsFiles: probeAwsFiles(),
     claudeCredentialExport: readClaudeCredentialExport()
@@ -67705,10 +67790,9 @@ function buildArgs(opts) {
     // Input stays default (text): we write the whole prompt to stdin and close.
     // (stream-json INPUT would force us into a JSON envelope for no gain here.)
     "--tools",
-    "",
+    ""
     // disable ALL built-in tools (deny-all)
-    "--settings",
-    FORCE_SUBSCRIPTION_SETTINGS
+    // No --settings override: the user's settings.json (and so their auth) applies as-is.
   ];
   let systemText = systemToText(opts.system).trim();
   if (opts.tools && opts.tools.length > 0) {
@@ -67737,7 +67821,7 @@ function systemToText(system) {
 }
 function buildSpawnEnv(base = process.env) {
   const env3 = { ...base };
-  for (const key2 of AUTH_ENV_TO_STRIP) {
+  for (const key2 of ENV_TO_STRIP) {
     delete env3[key2];
   }
   env3.CLAUDE_CODE_ENTRYPOINT = WALNUT_UTILITY_ENTRYPOINT;
@@ -67799,7 +67883,7 @@ function normalizeCliModel(model) {
   }
   return void 0;
 }
-var AUTH_ENV_TO_STRIP, FORCE_SUBSCRIPTION_SETTINGS, CLI_TURN_TIMEOUT_MS, SESSION_REUSE_TTL_MS, MAX_TRACKED_SESSIONS, ClaudeCliAdapter;
+var ENV_TO_STRIP, MAX_CONCURRENT_CLI, CLI_TURN_TIMEOUT_MS, SESSION_REUSE_TTL_MS, MAX_TRACKED_SESSIONS, ClaudeCliAdapter;
 var init_adapter_claude_cli = __esm({
   "src/agent/providers/adapter-claude-cli.ts"() {
     "use strict";
@@ -67809,24 +67893,11 @@ var init_adapter_claude_cli = __esm({
     init_logging();
     init_claude_cli_detect();
     init_claude_cli_protocol();
-    AUTH_ENV_TO_STRIP = [
-      "ANTHROPIC_API_KEY",
-      "ANTHROPIC_AUTH_TOKEN",
-      "ANTHROPIC_BASE_URL",
-      "AWS_BEARER_TOKEN_BEDROCK",
-      "AWS_ACCESS_KEY_ID",
-      "AWS_SECRET_ACCESS_KEY",
-      "AWS_SESSION_TOKEN",
-      "AWS_PROFILE",
-      "CLAUDE_CODE_USE_BEDROCK",
-      "CLAUDE_CODE_USE_VERTEX",
-      // Nested-session marker — inline-subagent strips this too so the child doesn't
-      // think it's running inside another Claude session.
-      "CLAUDECODE"
-    ];
-    FORCE_SUBSCRIPTION_SETTINGS = JSON.stringify({
-      env: { CLAUDE_CODE_USE_BEDROCK: "", CLAUDE_CODE_USE_VERTEX: "" }
-    });
+    ENV_TO_STRIP = ["CLAUDECODE"];
+    MAX_CONCURRENT_CLI = (() => {
+      const n6 = Number(process.env.WALNUT_CLAUDE_CLI_CONCURRENCY);
+      return Number.isFinite(n6) && n6 > 0 ? Math.floor(n6) : 3;
+    })();
     CLI_TURN_TIMEOUT_MS = 12e4;
     SESSION_REUSE_TTL_MS = 30 * 60 * 1e3;
     MAX_TRACKED_SESSIONS = 50;
@@ -67834,6 +67905,25 @@ var init_adapter_claude_cli = __esm({
       protocol = "claude-cli";
       /** conversationKey → CLI session for --resume chaining. In-process only. */
       sessions = /* @__PURE__ */ new Map();
+      /** Process gate: MAX_CONCURRENT_CLI turns at once, the rest queue in order. */
+      inFlight = 0;
+      waiters = [];
+      async withSlot(fn) {
+        if (this.inFlight >= MAX_CONCURRENT_CLI) {
+          await new Promise((resolve) => this.waiters.push(resolve));
+        }
+        this.inFlight++;
+        try {
+          return await fn();
+        } finally {
+          this.inFlight--;
+          this.waiters.shift()?.();
+        }
+      }
+      /** Test hook: how many turns are running / waiting right now. */
+      _gateStateForTesting() {
+        return { inFlight: this.inFlight, waiting: this.waiters.length };
+      }
       resetClient() {
         this.sessions.clear();
       }
@@ -67911,7 +68001,7 @@ User: ${overridePrompt}` : "");
         }
         if (!prompt.trim()) prompt = "(continue)";
         const args = [...buildArgs(opts), session2.flag, session2.id];
-        return this.execCli(command6, args, env3, prompt, opts.signal, onTextDelta).then((result) => {
+        return this.withSlot(() => this.execCli(command6, args, env3, prompt, opts.signal, onTextDelta)).then((result) => {
           this.sessions.set(key2, {
             sessionId: session2.id,
             seenMessages: opts.messages.length,
@@ -67930,7 +68020,7 @@ User: ${overridePrompt}` : "");
 User: ${overridePrompt}` : "");
             const freshId = randomUUID3();
             const freshArgs = [...buildArgs(opts), "--session-id", freshId];
-            return this.execCli(command6, freshArgs, env3, freshPrompt || "(continue)", opts.signal, onTextDelta).then((result) => {
+            return this.withSlot(() => this.execCli(command6, freshArgs, env3, freshPrompt || "(continue)", opts.signal, onTextDelta)).then((result) => {
               this.sessions.set(key2, {
                 sessionId: freshId,
                 seenMessages: opts.messages.length,
@@ -68014,7 +68104,7 @@ User: ${overridePrompt}` : "");
               }
               const resultText = finalResult?.result || accumulatedText;
               if (resultText && resultText.length < 300 && /^\s*failed to authenticate|^\s*api error: 4\d\d/i.test(resultText)) {
-                reject(new Error(`claude-cli subscription auth failed \u2014 run \`claude login\` to re-authenticate. CLI said: ${resultText.slice(0, 200)}`));
+                reject(new Error(`claude-cli could not authenticate \u2014 run \`claude\` once in a terminal to sign in (or check its Bedrock settings). CLI said: ${resultText.slice(0, 200)}`));
                 return;
               }
               if (code !== 0 && !accumulatedText && !finalResult) {
@@ -68248,7 +68338,7 @@ function getContextThreshold(model, percent) {
 }
 async function resolveForCall(config) {
   const fullConfig = await getConfig();
-  const providerName = config?.provider ?? fullConfig.agent?.main_provider ?? "bedrock";
+  const providerName = config?.provider ?? resolveMainProviderName(fullConfig);
   const hasExplicitProviders = fullConfig.providers && Object.keys(fullConfig.providers).length > 0;
   let providers = hasExplicitProviders ? buildProviderMap(fullConfig.providers, fullConfig) : synthesizeFromLegacy(fullConfig);
   const resolved = resolveProvider(providerName, providers);
@@ -68318,6 +68408,7 @@ var init_model = __esm({
     "use strict";
     init_config_manager();
     init_registry();
+    init_default_provider();
     init_defaults();
     init_model_catalog();
   }
@@ -69758,7 +69849,7 @@ __export(cheap_model_exports, {
 });
 function fastModelFor(config) {
   if (config.agent?.fast_model) return config.agent.fast_model;
-  const providerName = config.agent?.main_provider ?? "bedrock";
+  const providerName = resolveMainProviderName(config);
   return MODEL_CATALOG[providerName]?.find(
     (model) => model.id.toLowerCase().includes("haiku")
   )?.id;
@@ -69770,6 +69861,7 @@ var init_cheap_model = __esm({
   "src/core/cheap-model.ts"() {
     "use strict";
     init_model_catalog();
+    init_default_provider();
   }
 });
 
@@ -71589,7 +71681,20 @@ async function applySnapshot(sessionId, snapshot2, source) {
   if (projected !== "error") {
     updates.errorMessage = void 0;
     updates.errorKind = void 0;
-    clearSuppressedErrorReason(sessionId);
+    const stashedStop = projected === "stopped" ? takeSuppressedErrorReason(sessionId) : null;
+    if (stashedStop?.message) {
+      updates.errorMessage = stashedStop.message;
+      if (stashedStop.kind) updates.errorKind = stashedStop.kind;
+      log.session.info("snapshot projection adopted suppressed stop reason", {
+        sessionId,
+        suppressedReason: stashedStop.reason,
+        kind: stashedStop.kind ?? null,
+        projected,
+        source
+      });
+    } else {
+      clearSuppressedErrorReason(sessionId);
+    }
   } else {
     let droppedDisproven = false;
     if (assertsHostUnreachable(record)) {
@@ -75663,6 +75768,26 @@ var init_transcript_chain = __esm({
   }
 });
 
+// src/core/sessions/side-thread-warmup.ts
+function isCacheWarmupText(text) {
+  return text.startsWith(CACHE_WARMUP_TAG);
+}
+function markWarmupTurnPending(sessionId) {
+  pendingWarmupTurns.add(sessionId);
+}
+function consumeWarmupTurn(sessionId) {
+  return pendingWarmupTurns.delete(sessionId);
+}
+var CACHE_WARMUP_TAG, CACHE_WARMUP_MESSAGE, pendingWarmupTurns;
+var init_side_thread_warmup = __esm({
+  "src/core/sessions/side-thread-warmup.ts"() {
+    "use strict";
+    CACHE_WARMUP_TAG = "<walnut-cache-warmup>";
+    CACHE_WARMUP_MESSAGE = `${CACHE_WARMUP_TAG}This is a cache warm-up from the tool hosting this side thread, not a user message. Reply with exactly one word: Ready. Use no tools and add nothing else.</walnut-cache-warmup>`;
+    pendingWarmupTurns = /* @__PURE__ */ new Set();
+  }
+});
+
 // src/core/history-disk-cache.ts
 var history_disk_cache_exports = {};
 __export(history_disk_cache_exports, {
@@ -77823,6 +77948,7 @@ __export(session_lifecycle_exports, {
   retrySession: () => retrySession,
   terminateSession: () => terminateSession
 });
+import { randomUUID as randomUUID4 } from "crypto";
 async function readProviderSessionHistory(sessionId, record, nativeHost, skipSubagents = true, opts) {
   if (record && engineCaps(record.engine).historySource === "acp-journal") {
     const { readAcpSessionHistoryState: readAcpSessionHistoryState2 } = await Promise.resolve().then(() => (init_acp_session_history(), acp_session_history_exports));
@@ -77933,6 +78059,33 @@ async function changeSessionMode(existingRecord, sessionId, mode, updates = {})
   });
   return updated;
 }
+function normalizePinQuote(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new SessionControlError("pinned_messages[].quote must be an object", 400);
+  }
+  const quote = value;
+  const exact = quote.exact;
+  if (typeof exact !== "string" || !exact.trim() || exact.length > MAX_PIN_QUOTE_CHARS) {
+    throw new SessionControlError(
+      `pinned_messages[].quote.exact must be a non-empty string (max ${MAX_PIN_QUOTE_CHARS} chars)`,
+      400
+    );
+  }
+  for (const side of ["prefix", "suffix"]) {
+    const context = quote[side];
+    if (context !== void 0 && context !== null && (typeof context !== "string" || context.length > MAX_PIN_QUOTE_CONTEXT_CHARS)) {
+      throw new SessionControlError(
+        `pinned_messages[].quote.${side} must be a string (max ${MAX_PIN_QUOTE_CONTEXT_CHARS} chars)`,
+        400
+      );
+    }
+  }
+  return {
+    exact,
+    ...typeof quote.prefix === "string" && quote.prefix ? { prefix: quote.prefix } : {},
+    ...typeof quote.suffix === "string" && quote.suffix ? { suffix: quote.suffix } : {}
+  };
+}
 function normalizePinnedMessages(value) {
   if (!Array.isArray(value)) {
     throw new SessionControlError("pinned_messages must be an array", 400);
@@ -77941,7 +78094,9 @@ function normalizePinnedMessages(value) {
     throw new SessionControlError(`pinned_messages holds at most ${MAX_PINNED_MESSAGES} entries`, 400);
   }
   const out = [];
-  const seen = /* @__PURE__ */ new Set();
+  const seenWholeMessage = /* @__PURE__ */ new Set();
+  const seenQuoteId = /* @__PURE__ */ new Set();
+  const seenQuoteShape = /* @__PURE__ */ new Set();
   for (const raw of value) {
     if (!raw || typeof raw !== "object") {
       throw new SessionControlError("each pinned_messages entry must be an object", 400);
@@ -77951,13 +78106,40 @@ function normalizePinnedMessages(value) {
     if (typeof msgId !== "string" || !msgId.trim() || msgId.length > MAX_PIN_ID_CHARS) {
       throw new SessionControlError("pinned_messages[].msgId must be a non-empty string", 400);
     }
-    if (seen.has(msgId)) continue;
-    seen.add(msgId);
+    const rawId = entry.id;
+    if (rawId !== void 0 && rawId !== null && (typeof rawId !== "string" || !rawId.trim() || rawId.length > MAX_PIN_ENTRY_ID_CHARS)) {
+      throw new SessionControlError(
+        `pinned_messages[].id must be a non-empty string (max ${MAX_PIN_ENTRY_ID_CHARS} chars)`,
+        400
+      );
+    }
+    const id = typeof rawId === "string" ? rawId : void 0;
+    const quote = entry.quote === void 0 || entry.quote === null ? void 0 : normalizePinQuote(entry.quote);
+    let pinId = id;
+    if (quote) {
+      if (id && seenQuoteId.has(id)) continue;
+      const shape = [msgId, quote.exact, quote.prefix ?? "", quote.suffix ?? ""].join("\0");
+      if (seenQuoteShape.has(shape)) continue;
+      pinId = id ?? randomUUID4();
+      seenQuoteId.add(pinId);
+      seenQuoteShape.add(shape);
+    } else {
+      if (seenWholeMessage.has(msgId)) continue;
+      seenWholeMessage.add(msgId);
+    }
     const role = entry.role === "user" || entry.role === "assistant" || entry.role === "system" ? entry.role : "assistant";
     const label = typeof entry.label === "string" ? entry.label.trim().slice(0, MAX_PIN_LABEL_CHARS) : "";
     const timestamp = typeof entry.timestamp === "string" ? entry.timestamp : void 0;
     const pinnedAt = typeof entry.pinnedAt === "string" ? entry.pinnedAt : (/* @__PURE__ */ new Date()).toISOString();
-    out.push({ msgId, label, role, ...timestamp ? { timestamp } : {}, pinnedAt });
+    out.push({
+      msgId,
+      label,
+      role,
+      ...timestamp ? { timestamp } : {},
+      pinnedAt,
+      ...pinId ? { id: pinId } : {},
+      ...quote ? { quote } : {}
+    });
   }
   return out;
 }
@@ -78616,7 +78798,7 @@ async function readSessionRichHistory(sessionId, tail) {
     ...historyWindowed ? { windowed: true } : {}
   };
 }
-var CLAUDE_SESSION_MODES, MAX_PINNED_MESSAGES, MAX_PIN_LABEL_CHARS, MAX_PIN_ID_CHARS, RECHECK_RPC_TIMEOUT_MS, RECHECK_TIMED_OUT, GIT_BASES, MAX_FORK_DEPTH, HISTORY_STARTUP_GRACE_MS;
+var CLAUDE_SESSION_MODES, MAX_PINNED_MESSAGES, MAX_PIN_LABEL_CHARS, MAX_PIN_ID_CHARS, MAX_PIN_ENTRY_ID_CHARS, MAX_PIN_QUOTE_CHARS, MAX_PIN_QUOTE_CONTEXT_CHARS, RECHECK_RPC_TIMEOUT_MS, RECHECK_TIMED_OUT, GIT_BASES, MAX_FORK_DEPTH, HISTORY_STARTUP_GRACE_MS;
 var init_session_lifecycle = __esm({
   "src/core/sessions/session-lifecycle.ts"() {
     "use strict";
@@ -78630,6 +78812,9 @@ var init_session_lifecycle = __esm({
     MAX_PINNED_MESSAGES = 200;
     MAX_PIN_LABEL_CHARS = 300;
     MAX_PIN_ID_CHARS = 200;
+    MAX_PIN_ENTRY_ID_CHARS = 64;
+    MAX_PIN_QUOTE_CHARS = 2e3;
+    MAX_PIN_QUOTE_CONTEXT_CHARS = 64;
     RECHECK_RPC_TIMEOUT_MS = 5e3;
     RECHECK_TIMED_OUT = /* @__PURE__ */ Symbol("recheck-timeout");
     GIT_BASES = /* @__PURE__ */ new Set(["uncommitted", "previous", "remote"]);
@@ -78932,7 +79117,7 @@ __export(compact_inject_exports, {
   extractSessionMeta: () => extractSessionMeta,
   injectCompactBoundary: () => injectCompactBoundary
 });
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import fsp26 from "fs/promises";
 async function extractSessionMeta(jsonlPath) {
   const content = await fsp26.readFile(jsonlPath, "utf-8");
@@ -78984,8 +79169,8 @@ async function injectCompactBoundary(jsonlPath, summary, meta) {
     log.session.error("Could not find last message UUID in JSONL", { jsonlPath });
     return null;
   }
-  const boundaryUuid = randomUUID4();
-  const summaryUuid = randomUUID4();
+  const boundaryUuid = randomUUID5();
+  const summaryUuid = randomUUID5();
   const now = /* @__PURE__ */ new Date();
   const boundaryTs = now.toISOString();
   const summaryTs = new Date(now.getTime() + 1e3).toISOString();
@@ -89769,6 +89954,82 @@ var init_task = __esm({
   }
 });
 
+// src/core/sessions/spawn-prefix.ts
+var spawn_prefix_exports = {};
+__export(spawn_prefix_exports, {
+  MAX_SPAWN_PROMPT_BYTES: () => MAX_SPAWN_PROMPT_BYTES,
+  parseSpawnPrefixFromArgs: () => parseSpawnPrefixFromArgs,
+  readParentSpawnPrefix: () => readParentSpawnPrefix,
+  spawnPrefixFromRecord: () => spawnPrefixFromRecord
+});
+function flagValue(args, flag) {
+  const i8 = args.indexOf(flag);
+  if (i8 < 0 || i8 + 1 >= args.length) return void 0;
+  const v3 = args[i8 + 1];
+  return v3 !== void 0 && !v3.startsWith("--") ? v3 : void 0;
+}
+function parseSpawnPrefixFromArgs(args) {
+  const prompt = flagValue(args, "--append-system-prompt");
+  return {
+    appendSystemPrompt: prompt !== void 0 && Buffer.byteLength(prompt, "utf8") <= MAX_SPAWN_PROMPT_BYTES ? prompt : null,
+    ...flagValue(args, "--model") ? { model: flagValue(args, "--model") } : {},
+    ...EFFORTS.includes(flagValue(args, "--effort") ?? "") ? { effort: flagValue(args, "--effort") } : {},
+    ...flagValue(args, "--permission-mode") ? { permissionMode: flagValue(args, "--permission-mode") } : {},
+    source: "live-process"
+  };
+}
+function spawnPrefixFromRecord(record) {
+  const stored = record.appliedAppendSystemPrompt;
+  if (stored === void 0 || stored === null) return { appendSystemPrompt: null, source: "unknown" };
+  const usable = stored.length > 0 && Buffer.byteLength(stored, "utf8") <= MAX_SPAWN_PROMPT_BYTES;
+  return { appendSystemPrompt: usable ? stored : null, source: "record" };
+}
+async function defaultLiveArgsReader(hostKey2, sessionId) {
+  const { probeDaemonSessionArgs: probeDaemonSessionArgs2 } = await Promise.resolve().then(() => (init_daemon_connection(), daemon_connection_exports));
+  return probeDaemonSessionArgs2(hostKey2, sessionId);
+}
+async function readParentSpawnPrefix(parent, deps = {}) {
+  const readLiveArgs = deps.readLiveArgs ?? defaultLiveArgsReader;
+  const hostKey2 = parent.host || "__local__";
+  let live = null;
+  try {
+    live = await readLiveArgs(hostKey2, parent.claudeSessionId);
+  } catch (err2) {
+    log.session.debug("spawn prefix: live argv read threw", {
+      sessionId: parent.claudeSessionId,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+  }
+  if (live && live.length > 0) {
+    const prefix = parseSpawnPrefixFromArgs(live);
+    const remembered = parent.appliedAppendSystemPrompt ?? void 0;
+    const actual = prefix.appendSystemPrompt ?? "";
+    if (remembered !== actual) {
+      const persist4 = deps.persist ?? (async (sid, prompt) => {
+        const { updateSessionRecord: updateSessionRecord2 } = await Promise.resolve().then(() => (init_session_tracker(), session_tracker_exports));
+        return updateSessionRecord2(sid, { appliedAppendSystemPrompt: prompt });
+      });
+      void persist4(parent.claudeSessionId, actual).catch((err2) => {
+        log.session.warn("spawn prefix: backfill of applied prompt failed", {
+          sessionId: parent.claudeSessionId,
+          error: err2 instanceof Error ? err2.message : String(err2)
+        });
+      });
+    }
+    return prefix;
+  }
+  return spawnPrefixFromRecord(parent);
+}
+var EFFORTS, MAX_SPAWN_PROMPT_BYTES;
+var init_spawn_prefix = __esm({
+  "src/core/sessions/spawn-prefix.ts"() {
+    "use strict";
+    init_logging();
+    EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+    MAX_SPAWN_PROMPT_BYTES = 65536;
+  }
+});
+
 // src/core/sessions/side-thread-fork.ts
 var side_thread_fork_exports = {};
 __export(side_thread_fork_exports, {
@@ -89825,6 +90086,10 @@ async function forkSideThreadSession(parentSid, threadId, opts) {
   const sessionId = crypto18.randomUUID();
   const lane = sideThreadLaneKey(parentSid, threadId);
   const mode = parent.mode !== "default" ? parent.mode : void 0;
+  const { readParentSpawnPrefix: readParentSpawnPrefix2 } = await Promise.resolve().then(() => (init_spawn_prefix(), spawn_prefix_exports));
+  const prefix = await readParentSpawnPrefix2(parent);
+  const cliModel = prefix.model ?? parent.cliModel;
+  const effort = prefix.effort ?? parent.effort;
   await createSessionRecord(sessionId, "", parent.project ?? "", parent.cwd, {
     title,
     ...mode ? { mode } : {},
@@ -89832,8 +90097,10 @@ async function forkSideThreadSession(parentSid, threadId, opts) {
     // The thread inherits the parent's launch bundle verbatim, re-applied from
     // the record on every cold resume.
     ...parent.profile ? { profile: parent.profile } : {},
-    ...parent.effort ? { effort: parent.effort } : {},
-    ...parent.cliModel ? { cliModel: parent.cliModel } : {},
+    ...effort ? { effort } : {},
+    ...cliModel ? { cliModel } : {},
+    // '' = the parent runs without an append prompt, and so does the thread.
+    appliedAppendSystemPrompt: prefix.appendSystemPrompt ?? "",
     lane,
     forkedFromSessionId: resumeFrom,
     initialProcessStatus: "idle",
@@ -89849,11 +90116,12 @@ async function forkSideThreadSession(parentSid, threadId, opts) {
     ...mode ? { mode } : {},
     ...parent.host ? { host: parent.host } : {},
     ...parent.profile ? { profile: parent.profile } : {},
-    ...parent.effort ? { effort: parent.effort } : {},
+    ...effort ? { effort } : {},
     // Must be `cliModel` (the parent's verbatim --model arg, [1m] marker
     // included): the CLI does NOT inherit a model across --fork-session, and
     // the reported `model` has lost the marker.
-    ...parent.cliModel ? { model: parent.cliModel } : {},
+    ...cliModel ? { model: cliModel } : {},
+    appendSystemPromptExact: prefix.appendSystemPrompt,
     lane,
     forkedFromSessionId: resumeFrom
   }, ["session-runner"], { source: "side-thread-fork" });
@@ -89862,7 +90130,9 @@ async function forkSideThreadSession(parentSid, threadId, opts) {
     threadId,
     sessionId,
     resumeFrom,
-    initOnly: !opts?.message
+    initOnly: !opts?.message,
+    prefixSource: prefix.source,
+    prefixPromptLength: prefix.appendSystemPrompt?.length ?? 0
   });
   return { sessionId, resumeFromSessionId: resumeFrom };
 }
@@ -115734,11 +116004,12 @@ __export(session_controls_exports, {
   applySessionModelChange: () => applySessionModelChange,
   computeModelOptions: () => computeModelOptions,
   controlErrorKind: () => controlErrorKind,
+  createForkSiblingTask: () => createForkSiblingTask,
   forkSessionToTask: () => forkSessionToTask,
   handleSessionControlRelay: () => handleSessionControlRelay,
   modelReadBackMatches: () => modelReadBackMatches
 });
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 function controlErrorKind(status2) {
   if (status2 === 404) return "not_found";
   if (status2 === 405) return "method_not_allowed";
@@ -115911,6 +116182,124 @@ async function computeModelOptions(sessionId) {
     currentEffort: liveEffort ?? record.effectiveEffort ?? record.effort ?? null
   };
 }
+async function createForkSiblingTask(sourceTaskId, opts) {
+  const {
+    getTask: getTask2,
+    addTask: addTask2,
+    updateTask: updateTask2,
+    groupTasks: groupTasks2,
+    addToGroup: addToGroup2,
+    renameGroup: renameGroup2
+  } = await Promise.resolve().then(() => (init_task_manager(), task_manager_exports));
+  let sourceTask;
+  try {
+    sourceTask = await getTask2(sourceTaskId);
+  } catch {
+    throw new SessionControlError(`Source task "${sourceTaskId}" not found`, 404);
+  }
+  const sourceBaseTitle = sourceTask.title.replace(/^Fork of\s+/i, "").replace(/\s+-\s+fork of\s+.*$/i, "").trim() || sourceTask.title;
+  const explicitTitle = opts.childTitle || (opts.titlePrefix ? `${opts.titlePrefix} - fork of ${sourceBaseTitle}` : void 0);
+  const autoTitle = !explicitTitle;
+  const newTitle = explicitTitle || `Fork of ${sourceBaseTitle}`;
+  let inheritedTier;
+  if (sourceTask.pinned && sourceTask.focus_tier) {
+    const { getCustomTiers: getCustomTiers2 } = await Promise.resolve().then(() => (init_task_manager(), task_manager_exports));
+    const known = ["focus", "backlog", "wait"].includes(sourceTask.focus_tier) || (await getCustomTiers2()).some((t3) => t3.id === sourceTask.focus_tier);
+    if (known) inheritedTier = sourceTask.focus_tier;
+    else {
+      log.session.warn("fork: source tier is not registered, filing the fork in Satellite", {
+        sourceTaskId: sourceTask.id,
+        tier: sourceTask.focus_tier
+      });
+    }
+  }
+  const { task: newFork } = await addTask2({
+    title: newTitle,
+    project: sourceTask.project || "",
+    source: sourceTask.source,
+    ...opts.description ? { description: opts.description } : {},
+    // A fork is a person splitting off live work, so it joins the board like
+    // any other hand-made task (Satellite = pinned, no stored tier).
+    pinned: true,
+    ...inheritedTier ? { focus_tier: inheritedTier } : {},
+    // Forking an Ask Walnut conversation yields another Ask Walnut
+    // conversation: without the flag the fork loses the amber marker AND the
+    // persona drift repair (both key on task.walnut_agent, never on project).
+    ...sourceTask.walnut_agent ? { walnut_agent: true } : {}
+  });
+  let forkGroupId;
+  try {
+    if (sourceTask.group_id) {
+      const r8 = await addToGroup2(sourceTask.group_id, [newFork.id]);
+      forkGroupId = r8.group_id;
+    } else {
+      const r8 = await groupTasks2([sourceTask.id, newFork.id], sourceTask.title);
+      forkGroupId = r8.group_id;
+    }
+  } catch (err2) {
+    log.session.warn("fork: failed to group source + fork", {
+      sourceTaskId: sourceTask.id,
+      forkTaskId: newFork.id,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+  }
+  let task;
+  try {
+    task = await getTask2(newFork.id);
+  } catch {
+    task = newFork;
+  }
+  bus.emit(EventNames.TASK_CREATED, { task }, ["web-ui", "main-agent"], { source: opts.source });
+  if (autoTitle && opts.prompt?.trim()) {
+    const forkId = newFork.id;
+    const sourceTitle = sourceBaseTitle;
+    const placeholderTitle = newTitle;
+    const prompt = opts.prompt;
+    const titleSource = `${opts.source}-title`;
+    void (async () => {
+      try {
+        const { summarizeForkPrompt: summarizeForkPrompt2 } = await Promise.resolve().then(() => (init_fork_title(), fork_title_exports));
+        const label = await summarizeForkPrompt2(prompt);
+        if (!label) return;
+        const current5 = await getTask2(forkId);
+        if (current5.title !== placeholderTitle) {
+          log.session.info("fork title refine skipped \u2014 title changed since fork", { taskId: forkId });
+          return;
+        }
+        const refinedTitle = `${label} - fork of ${sourceTitle}`;
+        const { task: updated } = await updateTask2(forkId, { title: refinedTitle }, { source: titleSource });
+        bus.emit(EventNames.TASK_UPDATED, { task: updated }, ["web-ui", "main-agent"], { source: titleSource });
+        log.session.info("fork title refined", { taskId: forkId, title: refinedTitle });
+      } catch (err2) {
+        log.session.warn("fork title refine failed", {
+          taskId: forkId,
+          error: err2 instanceof Error ? err2.message : String(err2)
+        });
+      }
+    })();
+  }
+  if (forkGroupId && !sourceTask.group_id) {
+    const gid = forkGroupId;
+    const seedTitles = [sourceTask.title, newTitle];
+    const groupSource = opts.source;
+    void (async () => {
+      try {
+        const { summarizeGroupLabel: summarizeGroupLabel2 } = await Promise.resolve().then(() => (init_fork_title(), fork_title_exports));
+        const label = await summarizeGroupLabel2(seedTitles);
+        if (!label) return;
+        await renameGroup2(gid, label);
+        bus.emit(EventNames.TASK_GROUPS_CHANGED, { group_id: gid, label }, ["web-ui", "main-agent"], { source: groupSource });
+        log.session.info("fork group label refined", { groupId: gid, label });
+      } catch (err2) {
+        log.session.warn("fork group label refine failed", {
+          groupId: gid,
+          error: err2 instanceof Error ? err2.message : String(err2)
+        });
+      }
+    })();
+  }
+  return { task, ...forkGroupId ? { groupId: forkGroupId } : {} };
+}
 async function forkSessionToTask(sourceSessionId, input, source = "web-api") {
   const { task_id, create_child_task, child_title, message, title, model, imageContext } = input;
   if (!task_id && !create_child_task) {
@@ -115920,14 +116309,7 @@ async function forkSessionToTask(sourceSessionId, input, source = "web-api") {
     throw new SessionControlError("task_id and create_child_task are mutually exclusive", 400);
   }
   const { getSessionByClaudeId: getSessionByClaudeId2, getSessionsForTask: getSessionsForTask2, createSessionRecord: createSessionRecord2 } = await Promise.resolve().then(() => (init_session_tracker(), session_tracker_exports));
-  const {
-    getTask: getTask2,
-    addTask: addTask2,
-    updateTask: updateTask2,
-    groupTasks: groupTasks2,
-    addToGroup: addToGroup2,
-    renameGroup: renameGroup2
-  } = await Promise.resolve().then(() => (init_task_manager(), task_manager_exports));
+  const { getTask: getTask2 } = await Promise.resolve().then(() => (init_task_manager(), task_manager_exports));
   const sourceRecord = await getSessionByClaudeId2(sourceSessionId);
   if (!sourceRecord) throw new SessionControlError("Source session not found", 404);
   if (!engineCaps(sourceRecord.engine).fork) {
@@ -115944,108 +116326,13 @@ async function forkSessionToTask(sourceSessionId, input, source = "web-api") {
     if (!sourceRecord.taskId) {
       throw new SessionControlError("Source session has no task \u2014 cannot create fork task", 400);
     }
-    let sourceTask;
-    try {
-      sourceTask = await getTask2(sourceRecord.taskId);
-    } catch {
-      throw new SessionControlError(`Source task "${sourceRecord.taskId}" not found`, 404);
-    }
-    const sourceBaseTitle = sourceTask.title.replace(/^Fork of\s+/i, "").replace(/\s+-\s+fork of\s+.*$/i, "").trim() || sourceTask.title;
-    const autoTitle = !child_title;
-    const newTitle = child_title || `Fork of ${sourceBaseTitle}`;
-    let inheritedTier;
-    if (sourceTask.pinned && sourceTask.focus_tier) {
-      const { getCustomTiers: getCustomTiers2 } = await Promise.resolve().then(() => (init_task_manager(), task_manager_exports));
-      const known = ["focus", "backlog", "wait"].includes(sourceTask.focus_tier) || (await getCustomTiers2()).some((t3) => t3.id === sourceTask.focus_tier);
-      if (known) inheritedTier = sourceTask.focus_tier;
-      else {
-        log.session.warn("fork: source tier is not registered, filing the fork in Satellite", {
-          sourceTaskId: sourceTask.id,
-          tier: sourceTask.focus_tier
-        });
-      }
-    }
-    const { task: newFork } = await addTask2({
-      title: newTitle,
-      project: sourceTask.project || "",
-      source: sourceTask.source,
-      // A fork is a person splitting off live work, so it joins the board like
-      // any other hand-made task (Satellite = pinned, no stored tier).
-      pinned: true,
-      ...inheritedTier ? { focus_tier: inheritedTier } : {},
-      // Forking an Ask Walnut conversation yields another Ask Walnut
-      // conversation: without the flag the fork loses the amber marker AND the
-      // persona drift repair (both key on task.walnut_agent, never on project).
-      ...sourceTask.walnut_agent ? { walnut_agent: true } : {}
-    });
-    let forkGroupId;
-    try {
-      if (sourceTask.group_id) {
-        const r8 = await addToGroup2(sourceTask.group_id, [newFork.id]);
-        forkGroupId = r8.group_id;
-      } else {
-        const r8 = await groupTasks2([sourceTask.id, newFork.id], sourceTask.title);
-        forkGroupId = r8.group_id;
-      }
-    } catch (err2) {
-      log.session.warn("fork: failed to group source + fork", {
-        sourceTaskId: sourceTask.id,
-        forkTaskId: newFork.id,
-        error: err2 instanceof Error ? err2.message : String(err2)
-      });
-    }
-    try {
-      task = await getTask2(newFork.id);
-    } catch {
-      task = newFork;
-    }
-    bus.emit(EventNames.TASK_CREATED, { task }, ["web-ui", "main-agent"], { source: "fork" });
+    const created = await createForkSiblingTask(sourceRecord.taskId, {
+      childTitle: child_title,
+      prompt: message,
+      source: "fork"
+    });
+    task = created.task;
     childTaskCreated = true;
-    if (autoTitle && message?.trim()) {
-      const forkId = newFork.id;
-      const sourceTitle = sourceBaseTitle;
-      const placeholderTitle = newTitle;
-      void (async () => {
-        try {
-          const { summarizeForkPrompt: summarizeForkPrompt2 } = await Promise.resolve().then(() => (init_fork_title(), fork_title_exports));
-          const label = await summarizeForkPrompt2(message);
-          if (!label) return;
-          const current5 = await getTask2(forkId);
-          if (current5.title !== placeholderTitle) {
-            log.session.info("fork title refine skipped \u2014 title changed since fork", { taskId: forkId });
-            return;
-          }
-          const refinedTitle = `${label} - fork of ${sourceTitle}`;
-          const { task: updated } = await updateTask2(forkId, { title: refinedTitle }, { source: "fork-title" });
-          bus.emit(EventNames.TASK_UPDATED, { task: updated }, ["web-ui", "main-agent"], { source: "fork-title" });
-          log.session.info("fork title refined", { taskId: forkId, title: refinedTitle });
-        } catch (err2) {
-          log.session.warn("fork title refine failed", {
-            taskId: forkId,
-            error: err2 instanceof Error ? err2.message : String(err2)
-          });
-        }
-      })();
-    }
-    if (forkGroupId && !sourceTask.group_id) {
-      const gid = forkGroupId;
-      const seedTitles = [sourceTask.title, newTitle];
-      void (async () => {
-        try {
-          const { summarizeGroupLabel: summarizeGroupLabel2 } = await Promise.resolve().then(() => (init_fork_title(), fork_title_exports));
-          const label = await summarizeGroupLabel2(seedTitles);
-          if (!label) return;
-          await renameGroup2(gid, label);
-          bus.emit(EventNames.TASK_GROUPS_CHANGED, { group_id: gid, label }, ["web-ui", "main-agent"], { source: "fork" });
-          log.session.info("fork group label refined", { groupId: gid, label });
-        } catch (err2) {
-          log.session.warn("fork group label refine failed", {
-            groupId: gid,
-            error: err2 instanceof Error ? err2.message : String(err2)
-          });
-        }
-      })();
-    }
   } else {
     try {
       task = await getTask2(task_id);
@@ -116067,7 +116354,7 @@ async function forkSessionToTask(sourceSessionId, input, source = "web-api") {
   const FORK_FOCUS_PREFIX = "This is a forked session. Focus on the NEW request below \u2014 treat it as your primary task. Do not resume or continue the parent session's previous work unless the user explicitly asks you to.\n\n";
   const forkMessage = `${FORK_FOCUS_PREFIX}${imageContext ?? ""}New request:
 ${userRequest}`;
-  const forkSessionId = randomUUID5();
+  const forkSessionId = randomUUID6();
   const forkTitle = title ?? `Fork of ${sourceRecord.title ?? sourceSessionId.slice(0, 16)}`;
   try {
     await createSessionRecord2(forkSessionId, task.id, task.project ?? "", sourceRecord.cwd, {
@@ -116790,7 +117077,7 @@ __export(session_rewind_exports, {
   probeRewindViaDaemon: () => probeRewindViaDaemon,
   rewindSessionToMessage: () => rewindSessionToMessage
 });
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 function cutAncestorHistoryAtRewindPoint(ancestorMessages, rewoundAtMessageUuid) {
   if (!rewoundAtMessageUuid) {
     return { messages: ancestorMessages, found: false, dropped: 0 };
@@ -116991,7 +117278,7 @@ async function rewindSessionToMessage(sessionId, input, source = "web-api") {
       error: err2 instanceof Error ? err2.message : String(err2)
     });
   }
-  const rewoundId = randomUUID6();
+  const rewoundId = randomUUID7();
   const baseTitle = (record.title ?? sessionId.slice(0, 16)).replace(/\s*\(rewound\)$/i, "");
   const title = `${baseTitle} (rewound)`.slice(0, 200);
   const { createSessionRecord: createSessionRecord2 } = await Promise.resolve().then(() => (init_session_tracker(), session_tracker_exports));
@@ -117711,6 +117998,7 @@ function parseSessionMessages(content, opts) {
     }
   }
   let lastPlanContent = null;
+  let dropWarmupReply = false;
   const resultParentIds = [];
   const result = [];
   for (const [mapMsgId, msg] of messageMap) {
@@ -117788,10 +118076,18 @@ ${imgPath}` : imgPath;
     let text = textParts.join("\n").trim();
     if (!text && tools2.length === 0 && !thinking) continue;
     if (msg.role === "user" && text.startsWith("<")) {
+      if (isCacheWarmupText(text)) {
+        dropWarmupReply = true;
+        continue;
+      }
       const transformed = transformInjectedUserText(text);
       if (transformed === null) continue;
       if (transformed !== void 0) text = transformed;
     }
+    if (msg.role === "assistant" && dropWarmupReply) {
+      dropWarmupReply = false;
+      if (tools2.length === 0) continue;
+    }
     if (msg.role === "user") text = stripOutputModeWrappers(text);
     if (msg.role === "assistant" && !text && tools2.length === 0) continue;
     result.push({
@@ -118742,6 +119038,7 @@ var init_session_history = __esm({
     init_session_io();
     init_constants();
     init_remote_image_mirror();
+    init_side_thread_warmup();
     init_session_file_reader();
     LOCAL_HOME = os19.homedir();
     TAIL_SEGMENT_ROLL_BYTES = 4 * 1024 * 1024;
@@ -119034,7 +119331,7 @@ var init_context_window = __esm({
 });
 
 // src/providers/turn-ledger.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 function openTurn(sessionId) {
   const existing = openTurns.get(sessionId);
   if (existing && !existing.settled) {
@@ -119044,7 +119341,7 @@ function openTurn(sessionId) {
     });
     return { turnId: existing.turnId, promise: existing.promise };
   }
-  const turnId = randomUUID7();
+  const turnId = randomUUID8();
   let resolve;
   let reject;
   const promise = new Promise((res, rej) => {
@@ -127038,11 +127335,39 @@ var init_claude_code_session = __esm({
         session2.pendingDescription = message.slice(0, 500);
         let appendSystemPrompt;
         const isFork = !!data.forkedFromSessionId;
-        if (data.appendSystemPrompt && !isFork) {
-          appendSystemPrompt = data.appendSystemPrompt;
-          log.session.info("using caller-provided system prompt", { taskId: taskId2, promptLength: data.appendSystemPrompt.length });
-        }
-        {
+        const { parseSideLaneKey: parseSideLaneKey2 } = await Promise.resolve().then(() => (init_side_thread_fork(), side_thread_fork_exports));
+        const sideIds = parseSideLaneKey2(data.lane);
+        if (sideIds) {
+          let exact = data.appendSystemPromptExact;
+          let source = "live-or-record";
+          if (exact === void 0) {
+            try {
+              const { getSessionByClaudeId: getSessionByClaudeId2 } = await Promise.resolve().then(() => (init_session_tracker(), session_tracker_exports));
+              const { spawnPrefixFromRecord: spawnPrefixFromRecord2 } = await Promise.resolve().then(() => (init_spawn_prefix(), spawn_prefix_exports));
+              const parentRecord = await getSessionByClaudeId2(sideIds.parentSid);
+              const prefix = parentRecord ? spawnPrefixFromRecord2(parentRecord) : null;
+              exact = prefix?.appendSystemPrompt ?? null;
+              source = prefix?.source ?? "no-parent-record";
+            } catch (err2) {
+              exact = null;
+              source = "lookup-failed";
+              log.session.warn("side thread: parent prompt lookup failed \u2014 spawning without an append prompt", {
+                parentSid: sideIds.parentSid,
+                error: err2 instanceof Error ? err2.message : String(err2)
+              });
+            }
+          }
+          appendSystemPrompt = exact ?? void 0;
+          log.session.info("side thread: prefix prompt resolved", {
+            parentSid: sideIds.parentSid,
+            source,
+            promptLength: appendSystemPrompt?.length ?? 0
+          });
+        } else {
+          if (data.appendSystemPrompt && !isFork) {
+            appendSystemPrompt = data.appendSystemPrompt;
+            log.session.info("using caller-provided system prompt", { taskId: taskId2, promptLength: data.appendSystemPrompt.length });
+          }
           try {
             const { buildSessionContext: buildSessionContext2 } = await Promise.resolve().then(() => (init_session_context(), session_context_exports));
             const ctx = await buildSessionContext2(taskId2 ?? "", cwd, data.host);
@@ -127060,32 +127385,6 @@ ${ctx.systemPrompt}` : ctx.systemPrompt;
             log.session.warn("failed to build session context", { taskId: taskId2, error: err2 instanceof Error ? err2.message : String(err2) });
           }
         }
-        {
-          const { parseSideLaneKey: parseSideLaneKey2 } = await Promise.resolve().then(() => (init_side_thread_fork(), side_thread_fork_exports));
-          const sideIds = parseSideLaneKey2(data.lane);
-          if (sideIds) {
-            try {
-              const { getSessionByClaudeId: getSessionByClaudeId2 } = await Promise.resolve().then(() => (init_session_tracker(), session_tracker_exports));
-              const parentRecord = await getSessionByClaudeId2(sideIds.parentSid);
-              const inherited = parentRecord?.appliedAppendSystemPrompt;
-              if (inherited && Buffer.byteLength(inherited, "utf8") <= 65536) {
-                appendSystemPrompt = inherited;
-                log.session.info("side thread: inherited parent system prompt verbatim", {
-                  parentSid: sideIds.parentSid,
-                  promptLength: appendSystemPrompt.length
-                });
-              } else {
-                log.session.info("side thread: parent has no stored system prompt \u2014 fresh build (cache prefix will diverge)", {
-                  parentSid: sideIds.parentSid
-                });
-              }
-            } catch (err2) {
-              log.session.warn("side thread: parent prompt lookup failed \u2014 fresh build", {
-                error: err2 instanceof Error ? err2.message : String(err2)
-              });
-            }
-          }
-        }
         if (data.preassignedSessionId && appendSystemPrompt && Buffer.byteLength(appendSystemPrompt, "utf8") <= 65536) {
           const promptToStore = appendSystemPrompt;
           const sidToStore = data.preassignedSessionId;
@@ -128285,7 +128584,7 @@ __export(session_requests_exports, {
   settleNotified: () => settleNotified,
   settleReplied: () => settleReplied
 });
-import { createHash as createHash14, randomUUID as randomUUID8 } from "crypto";
+import { createHash as createHash14, randomUUID as randomUUID9 } from "crypto";
 import path119 from "path";
 function oneLine2(text, max = 160) {
   const flat = text.replace(/\s+/g, " ").trim();
@@ -128309,7 +128608,7 @@ function clampReplyTimeoutSecs(secs) {
 }
 async function createSessionRequest(input) {
   const request2 = {
-    id: `rq-${randomUUID8().replace(/-/g, "").slice(0, 12)}`,
+    id: `rq-${randomUUID9().replace(/-/g, "").slice(0, 12)}`,
     fromSessionId: input.fromSessionId,
     ...input.toSessionId ? { toSessionId: input.toSessionId } : {},
     ...input.toTaskId ? { toTaskId: input.toTaskId } : {},
@@ -137268,7 +137567,7 @@ __export(mobile_launch_exports, {
   performMobileLaunch: () => performMobileLaunch,
   validateMobileLaunchBody: () => validateMobileLaunchBody
 });
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 function launchErrorCode(status2) {
   if (status2 === 404) return "not_found";
   if (status2 === 409) return "conflict";
@@ -137390,7 +137689,7 @@ async function performMobileLaunch(input, source) {
       );
     }
   }
-  const preassignedSessionId = engineCaps(input.engine).idProvisioning === "provider-issued" ? void 0 : randomUUID9();
+  const preassignedSessionId = engineCaps(input.engine).idProvisioning === "provider-issued" ? void 0 : randomUUID10();
   const task = await quickStartSession({
     message: input.message,
     cwd: input.cwd,
@@ -138189,6 +138488,7 @@ __export(daemon_connection_exports, {
   isDaemonConnected: () => isDaemonConnected,
   isPooledConnection: () => isPooledConnection,
   probeDaemonSession: () => probeDaemonSession,
+  probeDaemonSessionArgs: () => probeDaemonSessionArgs,
   pushDaemonHooksToAllHosts: () => pushDaemonHooksToAllHosts,
   setOnDaemonHostConnected: () => setOnDaemonHostConnected,
   setOnDaemonStatusChange: () => setOnDaemonStatusChange,
@@ -138365,6 +138665,28 @@ async function probeDaemonSession(hostKey2, sessionId) {
     return null;
   }
 }
+async function probeDaemonSessionArgs(hostKey2, sessionId, deadlineMs = 2e3) {
+  const conn = getConnectedDaemonConnection(hostKey2);
+  if (!conn) return null;
+  try {
+    const result = await Promise.race([
+      conn.send("status", { sid: sessionId, includeArgs: true }),
+      new Promise((_, reject) => setTimeout(
+        () => reject(new Error(`status probe exceeded ${deadlineMs}ms`)),
+        deadlineMs
+      ).unref?.())
+    ]);
+    if (!result.ok || !result.alive || !Array.isArray(result.args)) return null;
+    return result.args.filter((a8) => typeof a8 === "string");
+  } catch (err2) {
+    log.session.debug("probeDaemonSessionArgs: status probe failed", {
+      hostKey: hostKey2,
+      sessionId,
+      error: err2 instanceof Error ? err2.message : String(err2)
+    });
+    return null;
+  }
+}
 var execFileAsync11, MOBILE_ENQUEUE_LEDGER_MAX, recentMobileEnqueues, DaemonConnection, onPoolStatusChange, onHostConnected, hostConnectedListeners, connectionPool, connectingPromises, failureCache, FAILURE_CACHE_TTL_MS;
 var init_daemon_connection = __esm({
   "src/providers/daemon-connection.ts"() {
@@ -143710,6 +144032,7 @@ async function createSessionRecord(claudeSessionId, taskId2, project, cwd, extra
         ...extra?.effort ? { effort: extra.effort } : {},
         ...extra?.profile ? { profile: extra.profile } : {},
         ...extra?.lane ? { lane: extra.lane } : {},
+        ...extra?.appliedAppendSystemPrompt !== void 0 ? { appliedAppendSystemPrompt: extra.appliedAppendSystemPrompt } : {},
         ...extra?.engine ? { engine: extra.engine } : {},
         ...extra?.acpRuntimeId ? { acpRuntimeId: extra.acpRuntimeId } : {},
         ...extra?.acpJournalPath ? { acpJournalPath: extra.acpJournalPath } : {},
@@ -143864,7 +144187,7 @@ function applyUpdateToSession(session2, updates, logLabel) {
       };
       if (count2 === 1) log.session.info("legacy status write suppressed", payload);
       else log.session.debug("legacy status write suppressed", payload);
-      if (updates.process_status === "error") {
+      if (updates.process_status === "error" || updates.process_status === "stopped") {
         noteSuppressedErrorReason(session2.claudeSessionId, {
           reason: typeof reason === "string" ? reason : "unknown",
           message: typeof updates.errorMessage === "string" ? updates.errorMessage : void 0,
@@ -151813,14 +152136,16 @@ function isLive(r8) {
 function isRevivable(r8) {
   return !!r8.outputFile || r8.consumedOffset !== void 0;
 }
-var STANDBY_TTL_MS, MAX_LIVE_THREADS, IDLE_SWEEP_INTERVAL_MS, THREAD_IDLE_MS, SideThreadManager, sideThreadManager;
+var STANDBY_TTL_MS, WARMED_STANDBY_TTL_MS, MAX_LIVE_THREADS, IDLE_SWEEP_INTERVAL_MS, THREAD_IDLE_MS, SideThreadManager, sideThreadManager;
 var init_side_thread_manager = __esm({
   "src/core/sessions/side-thread-manager.ts"() {
     "use strict";
     init_logging();
     init_side_thread_fork();
     init_session_controls();
+    init_side_thread_warmup();
     STANDBY_TTL_MS = 12e4;
+    WARMED_STANDBY_TTL_MS = 15 * 6e4;
     MAX_LIVE_THREADS = 3;
     IDLE_SWEEP_INTERVAL_MS = 5 * 6e4;
     THREAD_IDLE_MS = 30 * 6e4;
@@ -151831,6 +152156,8 @@ var init_side_thread_manager = __esm({
        *  In-memory only: a server restart loses it, but the boot sweep archives
        *  every standby anyway, so a record can never outlive its map entry. */
       standbyParentOffsets = /* @__PURE__ */ new Map();
+      /** parentSid → standby sid that already ran its cache warm-up turn. */
+      warmedStandbys = /* @__PURE__ */ new Map();
       /** One in-flight standby/create op per parent — two concurrent asks must not
        *  both consume the same standby (they would collide on its lane rename). */
       inFlight = /* @__PURE__ */ new Map();
@@ -151862,6 +152189,7 @@ var init_side_thread_manager = __esm({
         for (const timer3 of this.standbyTimers.values()) clearTimeout(timer3);
         this.standbyTimers.clear();
         this.standbyParentOffsets.clear();
+        this.warmedStandbys.clear();
         this.inFlight.clear();
       }
       // ── Standby ────────────────────────────────────────────────────────────────
@@ -151877,10 +152205,12 @@ var init_side_thread_manager = __esm({
           const existing = await this.findStandby(parentSid);
           if (existing) {
             if (await this.isStandbyUsable(parentSid, existing)) {
-              this.armStandbyTtl(parentSid, existing.claudeSessionId);
+              const warmed = this.warmedStandbys.get(parentSid) === existing.claudeSessionId;
+              this.armStandbyTtl(parentSid, existing.claudeSessionId, warmed ? WARMED_STANDBY_TTL_MS : STANDBY_TTL_MS);
               return existing.claudeSessionId;
             }
             void this.retireSession(existing.claudeSessionId, "side_thread_standby_stale");
+            this.warmedStandbys.delete(parentSid);
           }
           const parentOffset = parent.consumedOffset;
           const { sessionId } = await forkSideThreadSession(parentSid, STANDBY_THREAD_ID);
@@ -151906,7 +152236,7 @@ var init_side_thread_manager = __esm({
         if (!parent) return false;
         return parent.consumedOffset === this.standbyParentOffsets.get(parentSid);
       }
-      armStandbyTtl(parentSid, sessionId) {
+      armStandbyTtl(parentSid, sessionId, ttlMs = STANDBY_TTL_MS) {
         const prev = this.standbyTimers.get(parentSid);
         if (prev) clearTimeout(prev);
         const timer3 = setTimeout(() => {
@@ -151916,13 +152246,41 @@ var init_side_thread_manager = __esm({
             const record = await getSessionByClaudeId2(sessionId).catch(() => null);
             if (!record || parseSideLaneKey(record.lane)?.threadId !== STANDBY_THREAD_ID) return;
             this.standbyParentOffsets.delete(parentSid);
+            this.warmedStandbys.delete(parentSid);
             await this.retireSession(sessionId, "side_thread_standby_ttl");
           }).catch(() => {
           });
-        }, STANDBY_TTL_MS);
+        }, ttlMs);
         timer3.unref?.();
         this.standbyTimers.set(parentSid, timer3);
       }
+      /**
+       * Run the standby's cache warm-up turn (see side-thread-warmup.ts). Called
+       * when the user starts TYPING a new question: the fork's first API call pays
+       * the full prefix write no matter what, so paying it while they type turns
+       * the actual question into a cached follow-up. Idempotent per standby; a
+       * missing or stale standby is a no-op (the ask path will fork fresh anyway).
+       */
+      async warmStandby(parentSid) {
+        return this.serialize(parentSid, async () => {
+          const standby = await this.findStandby(parentSid);
+          if (!standby) return { warmed: false, reason: "no_standby" };
+          if (!await this.isStandbyUsable(parentSid, standby)) return { warmed: false, reason: "stale" };
+          if (this.warmedStandbys.get(parentSid) === standby.claudeSessionId) {
+            return { warmed: true, reason: "already_warm" };
+          }
+          const { sendMessageToSession: sendMessageToSession2 } = await Promise.resolve().then(() => (init_session_message_queue(), session_message_queue_exports));
+          markWarmupTurnPending(standby.claudeSessionId);
+          await sendMessageToSession2(standby.claudeSessionId, CACHE_WARMUP_MESSAGE, { source: "side-thread-warmup" });
+          this.warmedStandbys.set(parentSid, standby.claudeSessionId);
+          this.armStandbyTtl(parentSid, standby.claudeSessionId, WARMED_STANDBY_TTL_MS);
+          log.session.info("side thread: standby cache warm-up sent", {
+            parentSid,
+            standbySid: standby.claudeSessionId
+          });
+          return { warmed: true };
+        });
+      }
       // ── Threads ────────────────────────────────────────────────────────────────
       /**
        * Open a side thread on `parentSid` and ask `question` in it.
@@ -151933,6 +152291,10 @@ var init_side_thread_manager = __esm({
        * question as its spawn's first turn instead — a send issued right after
        * SESSION_START can lose that race and cold-`--resume` an id the CLI has never
        * seen (see personal-ai-lane.ts LaneSession.created).
+       *
+       * `imageContext` (attachment paths for the CLI to Read) rides the MESSAGE only.
+       * The stored entry keeps the plain question, so the chip label, the injected
+       * transcript and a promoted task never carry the machine preamble.
        */
       async createThread(parentSid, input) {
         const question = input.question?.trim();
@@ -151940,8 +152302,11 @@ var init_side_thread_manager = __esm({
         return this.serialize(parentSid, async () => {
           const threadId = mintSideThreadId();
           const title = input.title?.trim() || void 0;
+          const message = input.imageContext ? `${input.imageContext}
+
+${question}` : question;
           const consumed = await this.consumeStandby(parentSid, threadId, title);
-          const threadSessionId = consumed ?? (await forkSideThreadSession(parentSid, threadId, { message: question, ...title ? { title } : {} })).sessionId;
+          const threadSessionId = consumed ?? (await forkSideThreadSession(parentSid, threadId, { message, ...title ? { title } : {} })).sessionId;
           let entry;
           try {
             const { addSideThread: addSideThread2 } = await Promise.resolve().then(() => (init_side_questions(), side_questions_exports));
@@ -151953,7 +152318,7 @@ var init_side_thread_manager = __esm({
             });
             if (consumed) {
               const { sendMessageToSession: sendMessageToSession2 } = await Promise.resolve().then(() => (init_session_message_queue(), session_message_queue_exports));
-              await sendMessageToSession2(threadSessionId, question, { source: "side-thread" });
+              await sendMessageToSession2(threadSessionId, message, { source: "side-thread" });
             }
           } catch (err2) {
             void this.retireSession(threadSessionId, "side_thread_create_failed");
@@ -151988,6 +152353,7 @@ var init_side_thread_manager = __esm({
         if (!await this.isStandbyUsable(parentSid, standby)) {
           void this.retireSession(standby.claudeSessionId, "side_thread_standby_stale");
           this.standbyParentOffsets.delete(parentSid);
+          this.warmedStandbys.delete(parentSid);
           return null;
         }
         const timer3 = this.standbyTimers.get(parentSid);
@@ -151996,6 +152362,7 @@ var init_side_thread_manager = __esm({
           this.standbyTimers.delete(parentSid);
         }
         this.standbyParentOffsets.delete(parentSid);
+        this.warmedStandbys.delete(parentSid);
         const lane = sideThreadLaneKey(parentSid, threadId);
         const { updateSessionRecord: updateSessionRecord2 } = await Promise.resolve().then(() => (init_session_tracker(), session_tracker_exports));
         await updateSessionRecord2(standby.claudeSessionId, {
@@ -152182,16 +152549,30 @@ async function promoteSideThread(parentSid, threadId, opts) {
   const threadRecord = await getSessionByClaudeId2(sessionId);
   if (!threadRecord) throw new SessionControlError("Side thread session not found", 404);
   const parentRecord = await getSessionByClaudeId2(parentSid);
-  const parentTaskId = parentRecord?.taskId?.trim() || void 0;
-  const title = opts?.title?.trim() || entry.title?.trim() || entry.question;
+  const siblingOfTaskId = parentRecord?.taskId?.trim() || void 0;
+  const threadLabel = opts?.title?.trim() || entry.title?.trim() || void 0;
   const { addTask: addTask2, linkSession: linkSession2, linkSessionSlot: linkSessionSlot2 } = await Promise.resolve().then(() => (init_task_manager(), task_manager_exports));
-  const { task } = await addTask2({
-    title,
-    description: entry.question,
-    ...parentTaskId ? { parent_task_id: parentTaskId } : {},
-    // A person clicked "promote" — same board default as any hand-made task.
-    pinned: true
-  });
+  let groupId;
+  let task;
+  if (siblingOfTaskId) {
+    const created = await createForkSiblingTask(siblingOfTaskId, {
+      // A known label short-circuits the background refine; without one the
+      // thread's first question is what gets summarized (same as a fork's message).
+      titlePrefix: threadLabel,
+      prompt: entry.question,
+      description: entry.question,
+      source: "side-thread-promote"
+    });
+    task = created.task;
+    groupId = created.groupId;
+  } else {
+    ({ task } = await addTask2({
+      title: threadLabel || entry.question,
+      description: entry.question,
+      // A person clicked "promote" — same board default as any hand-made task.
+      pinned: true
+    }));
+  }
   const stamped = await markThreadPromoted2(parentSid, threadId, task.id);
   if (!stamped) {
     log.session.warn("side thread promote: entry vanished before stamp \u2014 promote proceeds, 409 guard is unarmed", {
@@ -152205,7 +152586,7 @@ async function promoteSideThread(parentSid, threadId, opts) {
     project: task.project ?? "",
     // Clearing the lane un-hides the session (see the file header).
     lane: void 0,
-    title
+    title: task.title
   });
   try {
     const { sessionRunner: sessionRunner2 } = await Promise.resolve().then(() => (init_claude_code_session(), claude_code_session_exports));
@@ -152224,10 +152605,18 @@ async function promoteSideThread(parentSid, threadId, opts) {
       error: err2 instanceof Error ? err2.message : String(err2)
     });
   }
-  log.session.info("side thread: promoted to task", { parentSid, threadId, sessionId, taskId: task.id });
+  log.session.info("side thread: promoted to task", {
+    parentSid,
+    threadId,
+    sessionId,
+    taskId: task.id,
+    siblingOfTaskId,
+    groupId
+  });
   return {
     taskId: task.id,
-    ...task.parent_task_id ? { parentTaskId: task.parent_task_id } : {},
+    ...siblingOfTaskId ? { siblingOfTaskId } : {},
+    ...groupId ? { groupId } : {},
     sessionId
   };
 }
@@ -152242,7 +152631,7 @@ var init_side_thread_promote = __esm({
 
 // src/web/routes/sessions.ts
 import { Router as Router16 } from "express";
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 import os27 from "os";
 import path142 from "path";
 function condenseStaleReason(msg) {
@@ -152588,7 +152977,7 @@ var init_sessions = __esm({
           }
           const isNativeEngine = !isAcpEngine(engine);
           const clientSessionId = typeof req.body.sessionId === "string" && UUID_RE3.test(req.body.sessionId) ? req.body.sessionId : void 0;
-          const preassignedSessionId = isNativeEngine ? clientSessionId ?? randomUUID10() : void 0;
+          const preassignedSessionId = isNativeEngine ? clientSessionId ?? randomUUID11() : void 0;
           const updatedTask = await quickStartSession({
             message: sessionMessage,
             messagePrefix,
@@ -153563,18 +153952,38 @@ var init_sessions = __esm({
         });
       }
     });
+    sessionsRouter.post("/:sessionId/side-threads/standby/warm", async (req, res) => {
+      if (refuseSideThreadsOnReplica(res)) return;
+      const sessionId = String(req.params.sessionId);
+      try {
+        const { sideThreadManager: sideThreadManager2 } = await Promise.resolve().then(() => (init_side_thread_manager(), side_thread_manager_exports));
+        res.json(await sideThreadManager2.warmStandby(sessionId));
+      } catch (err2) {
+        log.web.warn("side thread standby warm-up failed", {
+          sessionId,
+          error: err2 instanceof Error ? err2.message : String(err2)
+        });
+        res.json({ warmed: false, reason: "error" });
+      }
+    });
     sessionsRouter.post("/:sessionId/side-threads", async (req, res, next) => {
       if (refuseSideThreadsOnReplica(res)) return;
       try {
-        const { question, title } = req.body ?? {};
+        const { question, title, images } = req.body ?? {};
         if (!question || typeof question !== "string" || !question.trim()) {
           res.status(400).json({ error: "question (non-empty string) is required" });
           return;
         }
+        let imageContext = "";
+        if (images && images.length > 0) {
+          const processed = await processAndSaveImages(images);
+          if (processed) imageContext = buildSessionImageContext(processed.savedImages);
+        }
         const { sideThreadManager: sideThreadManager2 } = await Promise.resolve().then(() => (init_side_thread_manager(), side_thread_manager_exports));
         const thread = await sideThreadManager2.createThread(String(req.params.sessionId), {
           question,
-          ...typeof title === "string" && title.trim() ? { title } : {}
+          ...typeof title === "string" && title.trim() ? { title } : {},
+          ...imageContext ? { imageContext } : {}
         });
         res.json({ thread });
       } catch (err2) {
@@ -153593,7 +154002,8 @@ var init_sessions = __esm({
         );
         res.json({
           taskId: result.taskId,
-          ...result.parentTaskId ? { parentTaskId: result.parentTaskId } : {},
+          ...result.siblingOfTaskId ? { siblingOfTaskId: result.siblingOfTaskId } : {},
+          ...result.groupId ? { groupId: result.groupId } : {},
           sessionId: result.sessionId
         });
       } catch (err2) {
@@ -154288,7 +154698,7 @@ var micro_claude_exports = {};
 __export(micro_claude_exports, {
   runMicroClaude: () => runMicroClaude
 });
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 async function runMicroClaude(opts) {
   if (opts.warm) {
     const run10 = await runWarmMicroClaude({
@@ -154297,7 +154707,7 @@ async function runMicroClaude(opts) {
       tools: opts.tools ?? [],
       prompt: opts.prompt,
       timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
-      toolUseId: opts.toolUseId ?? `micro-claude-${randomUUID11()}`,
+      toolUseId: opts.toolUseId ?? `micro-claude-${randomUUID12()}`,
       ...opts.onBlock ? { onBlock: opts.onBlock } : {}
     });
     return { response: run10.response, costUsd: run10.costUsd, durationMs: run10.durationMs };
@@ -154307,7 +154717,7 @@ async function runMicroClaude(opts) {
     systemPrompt: opts.system,
     model: opts.model ?? DEFAULT_MODEL2,
     timeoutMs: opts.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
-    toolUseId: opts.toolUseId ?? `micro-claude-${randomUUID11()}`,
+    toolUseId: opts.toolUseId ?? `micro-claude-${randomUUID12()}`,
     slim: true,
     thinking: opts.thinking ?? false,
     ...opts.tools && opts.tools.length > 0 ? { tools: opts.tools } : {},
@@ -154337,7 +154747,7 @@ __export(micro_agent_exports, {
 async function resolveTierModel(tier) {
   const { getConfig: getConfig2 } = await Promise.resolve().then(() => (init_config_manager(), config_manager_exports));
   const config = await getConfig2();
-  const provider = config.agent?.main_provider ?? "bedrock";
+  const provider = resolveMainProviderName(config);
   const { MODEL_CATALOG: MODEL_CATALOG3 } = await Promise.resolve().then(() => (init_model_catalog(), model_catalog_exports));
   const entry = MODEL_CATALOG3[provider]?.find((m6) => {
     const id = m6.id.toLowerCase();
@@ -154406,6 +154816,7 @@ var DEFAULT_TIER, DEFAULT_MAX_TOKENS2, DEFAULT_MAX_ROUNDS, DEFAULT_TIMEOUT_MS3;
 var init_micro_agent = __esm({
   "src/agent/micro-agent.ts"() {
     "use strict";
+    init_default_provider();
     DEFAULT_TIER = "sonnet";
     DEFAULT_MAX_TOKENS2 = 2e3;
     DEFAULT_MAX_ROUNDS = 3;
@@ -154421,7 +154832,7 @@ __export(task_search_agent_exports, {
   prewarmAgentSearchChild: () => prewarmAgentSearchChild,
   runTaskSearchAgent: () => runTaskSearchAgent
 });
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 function useCliEngine() {
   return process.env.WALNUT_AGENT_SEARCH_ENGINE !== "inprocess";
 }
@@ -154501,7 +154912,7 @@ async function claudeCliEngine(userPrompt, options) {
     model: options.model,
     timeoutMs: options.timeoutMs,
     tools: ["Bash"],
-    toolUseId: `task-search-${randomUUID12()}`,
+    toolUseId: `task-search-${randomUUID13()}`,
     warm: true,
     onBlock
   });
@@ -155579,10 +155990,11 @@ async function buildProvidersPayload() {
       providers[name] = {
         api: prov.api,
         base_url: prov.base_url,
-        status: caps.subscriptionReady ? "ready" : "no_key",
+        status: caps.installed ? "ready" : "no_key",
         auto_detected: !explicitNames.has(name),
         models: getModelsForProvider(name, prov.models),
-        credential_source: caps.subscriptionReady ? "subscription" : caps.installed ? "cli_no_subscription" : "cli_not_installed"
+        credential_source: caps.installed ? `cli_${caps.auth.mode}` : "cli_not_installed",
+        credential_detail: caps.installed ? caps.auth.label : void 0
       };
       continue;
     }
@@ -155641,10 +156053,11 @@ async function buildProvidersPayload() {
         const caps = detectClaudeCli2();
         providers[name] = {
           api: template.api,
-          status: caps.subscriptionReady ? "ready" : "no_key",
+          status: caps.installed ? "ready" : "no_key",
           auto_detected: false,
           models: getModelsForProvider(name),
-          credential_source: caps.subscriptionReady ? "subscription" : caps.installed ? "cli_no_subscription" : "cli_not_installed"
+          credential_source: caps.installed ? `cli_${caps.auth.mode}` : "cli_not_installed",
+          credential_detail: caps.installed ? caps.auth.label : void 0
         };
         continue;
       }
@@ -155800,7 +156213,7 @@ var init_config11 = __esm({
         const {
           traceCredentialResolution: traceCredentialResolution2,
           resolveCredentials: resolveCredentials2,
-          readClaudeSettingsEnv: readClaudeSettingsEnv2,
+          readClaudeSettingsEnv: readClaudeSettingsEnv3,
           readClaudeCredentialExport: readClaudeCredentialExport2
         } = await Promise.resolve().then(() => (init_credential_resolver(), credential_resolver_exports));
         const fs114 = await import("fs");
@@ -155816,7 +156229,7 @@ var init_config11 = __esm({
         };
         const trace = traceCredentialResolution2({
           config,
-          claudeEnv: readClaudeSettingsEnv2(),
+          claudeEnv: readClaudeSettingsEnv3(),
           processEnv: process.env,
           awsFiles: {
             credentials: exists3(path185.join(home, ".aws", "credentials")),
@@ -173146,7 +173559,7 @@ __export(task_start_exports, {
   SessionExistsError: () => SessionExistsError,
   startSessionForTask: () => startSessionForTask
 });
-import { randomUUID as randomUUID13 } from "crypto";
+import { randomUUID as randomUUID14 } from "crypto";
 async function startSessionForTask(params) {
   const { taskIdPrefix, source } = params;
   let task;
@@ -173197,7 +173610,7 @@ async function startSessionForTask(params) {
   }
   let message = params.message?.trim() || `Working on task: ${task.title}`;
   const engine = normalizeEngine(params.engine);
-  const preassignedSessionId = engineCaps(engine).idProvisioning === "provider-issued" ? void 0 : randomUUID13();
+  const preassignedSessionId = engineCaps(engine).idProvisioning === "provider-issued" ? void 0 : randomUUID14();
   let requestId;
   if (params.expectReply) {
     const { resolveCaller: resolveCaller2 } = await Promise.resolve().then(() => (init_session_send_core(), session_send_core_exports));
@@ -184525,7 +184938,7 @@ async function generateLedgerDesc(task, timeoutMs = 15e3) {
   try {
     const { getConfig: getConfig2 } = await Promise.resolve().then(() => (init_config_manager(), config_manager_exports));
     const config = await getConfig2();
-    const providerName = config.agent?.main_provider ?? "bedrock";
+    const providerName = resolveMainProviderName(config);
     const model = cheapModelFor(providerName);
     const detail = (task.description ?? "").trim().slice(0, 800);
     const project = (task.project ?? "").trim();
@@ -184584,6 +184997,7 @@ var init_task_ledger_desc = __esm({
     "use strict";
     init_model();
     init_model_catalog();
+    init_default_provider();
     init_logging();
     init_task_manager();
     MAX_DESC_LEN = 120;
@@ -184607,6 +185021,10 @@ function diffStreamedVsPersisted(streamedTextMsgIds, persistedMsgIds) {
 }
 function armStreamConvergenceCheck(sessionId, streamedTextMsgIds) {
   if (streamedTextMsgIds.length === 0) return;
+  if (consumeWarmupTurn(sessionId)) {
+    log.obs.debug("stream-convergence: skipped hidden warm-up turn", { sessionId });
+    return;
+  }
   const timer3 = setTimeout(() => {
     void runCheck(sessionId, streamedTextMsgIds).catch((err2) => {
       log.obs.warn("stream-convergence check failed", {
@@ -184672,6 +185090,7 @@ var init_stream_convergence = __esm({
   "src/core/observability/stream-convergence.ts"() {
     "use strict";
     init_logging();
+    init_side_thread_warmup();
     CHECK_DELAY_MS = 15e3;
     INCIDENT_DEDUPE_MS = 30 * 6e4;
     lastIncidentAt = /* @__PURE__ */ new Map();
@@ -184922,12 +185341,17 @@ function getSystemHealth() {
 }
 async function refreshSystemHealth() {
   systemHealth.claudeCliAvailable = checkClaudeCliAvailable();
-  const cred = await resolveCredentialHealth();
+  applyCredentialHealth(await resolveCredentialHealth());
+  broadcastEvent("system:health", systemHealth);
+  return systemHealth;
+}
+function applyCredentialHealth(cred) {
   systemHealth.hasReadyProvider = cred.hasReadyProvider;
   systemHealth.credentialSource = cred.source;
   systemHealth.credentialDetail = cred.detail;
-  broadcastEvent("system:health", systemHealth);
-  return systemHealth;
+  systemHealth.mainProvider = cred.mainProvider;
+  systemHealth.mainProviderImplicit = cred.mainProviderImplicit;
+  systemHealth.claudeCliAuth = cred.claudeCliAuth;
 }
 function checkClaudeCliAvailable() {
   return isClaudeCliInstalled();
@@ -184937,27 +185361,36 @@ async function resolveCredentialHealth() {
     const { getConfig: getConfig2 } = await Promise.resolve().then(() => (init_config_manager(), config_manager_exports));
     const { resolveCredentials: resolveCredentials2 } = await Promise.resolve().then(() => (init_credential_resolver(), credential_resolver_exports));
     const { buildProviderMap: buildProviderMap2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    const { resolveMainProviderName: resolveMainProviderName2, mainProviderIsImplicit: mainProviderIsImplicit2 } = await Promise.resolve().then(() => (init_default_provider(), default_provider_exports));
+    const { detectClaudeCli: detectClaudeCli2 } = await Promise.resolve().then(() => (init_claude_cli_detect(), claude_cli_detect_exports));
     const config = await getConfig2();
+    const cli = detectClaudeCli2();
+    const mainProvider = resolveMainProviderName2(config, cli.installed);
+    const base = {
+      mainProvider,
+      mainProviderImplicit: mainProviderIsImplicit2(config),
+      claudeCliAuth: cli.installed ? cli.auth.label : void 0
+    };
+    if (mainProvider === "claude_cli") {
+      return cli.installed ? { ...base, hasReadyProvider: true, source: "config", detail: `claude-cli (${cli.auth.label})` } : { ...base, hasReadyProvider: false, source: "none" };
+    }
     const cred = resolveCredentials2(config);
     if (cred.source !== "none") {
-      return { hasReadyProvider: true, source: cred.source, detail: cred.detail };
+      return { ...base, hasReadyProvider: true, source: cred.source, detail: cred.detail };
     }
     const providers = buildProviderMap2(config.providers, config);
     for (const [, prov] of Object.entries(providers)) {
       if (prov.api === "bedrock" || prov.api === "ollama") continue;
       if (prov.api === "claude-cli") {
-        const { detectClaudeCli: detectClaudeCli2 } = await Promise.resolve().then(() => (init_claude_cli_detect(), claude_cli_detect_exports));
-        if (detectClaudeCli2().subscriptionReady) {
-          return { hasReadyProvider: true, source: "config", detail: "claude-cli (subscription)" };
-        }
+        if (cli.installed) return { ...base, hasReadyProvider: true, source: "config", detail: `claude-cli (${cli.auth.label})` };
         continue;
       }
       const implemented = prov.api === "anthropic-messages" || prov.api === "openai-chat" || prov.api === "google-generative-ai";
       if (implemented && (prov.api_key || prov.bearer_token)) {
-        return { hasReadyProvider: true, source: "config", detail: prov.api };
+        return { ...base, hasReadyProvider: true, source: "config", detail: prov.api };
       }
     }
-    return { hasReadyProvider: false, source: "none" };
+    return { ...base, hasReadyProvider: false, source: "none" };
   } catch {
     return { hasReadyProvider: false, source: "none" };
   }
@@ -184996,11 +185429,11 @@ async function startServer(options = {}) {
   }
   {
     const cred = await resolveCredentialHealth();
-    systemHealth.hasReadyProvider = cred.hasReadyProvider;
-    systemHealth.credentialSource = cred.source;
-    systemHealth.credentialDetail = cred.detail;
+    applyCredentialHealth(cred);
     if (!systemHealth.hasReadyProvider) {
       log.web.warn("No AI provider configured \u2014 configure one in Settings");
+    } else if (cred.mainProvider === "claude_cli") {
+      log.web.info("AI provider: Claude Code", { auth: cred.claudeCliAuth, implicit: cred.mainProviderImplicit });
     } else if (cred.source && cred.source !== "config") {
       log.web.info("Auto-detected Bedrock credential", { source: cred.source, detail: cred.detail });
     }
@@ -186280,10 +186713,9 @@ async function startServer(options = {}) {
       const prev = systemHealth.hasReadyProvider;
       const prevSource = systemHealth.credentialSource;
       const cred = await resolveCredentialHealth();
-      systemHealth.hasReadyProvider = cred.hasReadyProvider;
-      systemHealth.credentialSource = cred.source;
-      systemHealth.credentialDetail = cred.detail;
-      if (cred.hasReadyProvider !== prev || cred.source !== prevSource) {
+      const prevProvider = systemHealth.mainProvider;
+      applyCredentialHealth(cred);
+      if (cred.hasReadyProvider !== prev || cred.source !== prevSource || cred.mainProvider !== prevProvider) {
         broadcastEvent("system:health", systemHealth);
       }
     } catch {