blun-king-cli 9.1.58 → 9.1.60

package/LIESMICH.txt

@@ -9,7 +9,7 @@ Installation
 ------------
 Die geprüfte Version exakt global installieren:
 
-  npm install -g blun-king-cli@9.1.57
+  npm install -g blun-king-cli@9.1.59
 
 Start
 -----

package/README.md

@@ -9,7 +9,7 @@ Voraussetzung ist Node.js 24.15 oder neuer. Die geprüfte Version wird exakt
 installiert:
 
 ```powershell
-npm install -g blun-king-cli@9.1.57
+npm install -g blun-king-cli@9.1.59
 ```
 
 ## Reproduzierbares Staging und Packen

package/bin/launcher-mode.js

@@ -10,6 +10,8 @@ const LAUNCHER_HELP_TEXT = [
   'Launchers:',
   '  blun  Starts the CLI without automatically attaching Telegram.',
   '  king  Starts the same CLI and automatically attaches the configured Telegram channel.',
+  '  king <profile> starts an isolated named King profile.',
+  '  king -c <profile> continues the last session in that profile.',
   '  Both use the same version, account, model, and commands.',
   '  blun tools list shows optional tools; enable writes only explicit choices.',
   '',

package/bin/launcher-runtime.js

@@ -31,9 +31,16 @@ const {
   securePrivateFile,
   writePrivateFile,
 } = require('./private-paths');
+const {
+  parseProfileLaunchArgs,
+  resolveProfilePaths,
+  seedDefaultProfileFromLegacy,
+} = require('./profile-runtime.cjs');
 
 const PKG = path.resolve(__dirname, '..');
-const ARGS = process.argv.slice(2);
+const RAW_ARGS = process.argv.slice(2);
+const PROFILE = parseProfileLaunchArgs(RAW_ARGS, launcherModeFromArgv(process.argv));
+const ARGS = PROFILE.args;
 const CORE_LOAD_TIMEOUT_MS = 30_000;
 
 function normalizeWindowsPath(value) {
@@ -44,10 +51,24 @@ function resolveLauncherPrivatePaths(options = {}) {
   const env = options.env || process.env;
   const platform = options.platform || process.platform;
   const configuredHome = String(env.BLUN_HOME || '').trim();
+  const configuredSharedHome = String(env.BLUN_SHARED_HOME || '').trim();
+  const profileName = options.profileName || PROFILE.profileName;
   if (platform !== 'win32') {
     const userHome = (options.homedir || os.homedir)();
+    const sharedHome = configuredSharedHome
+      ? path.resolve(configuredSharedHome)
+      : configuredHome
+      ? path.resolve(configuredHome)
+      : path.join(userHome, '.blun');
+    const profilePaths = resolveProfilePaths(sharedHome, profileName);
+    if (configuredSharedHome && configuredHome
+      && path.resolve(configuredHome) !== path.resolve(profilePaths.home)) {
+      throw new Error(`BLUN_HOME passt nicht zum Profil ${profileName}: ${profilePaths.home}`);
+    }
     return {
-      blunHome: configuredHome ? path.resolve(configuredHome) : path.join(userHome, '.blun'),
+      blunHome: profilePaths.home,
+      profilePaths,
+      sharedHome,
       userHome,
     };
   }
@@ -71,12 +92,26 @@ function resolveLauncherPrivatePaths(options = {}) {
     throw new Error('Das lokale Windows-Benutzerprofil ist kein kanonischer lokaler Pfad.');
   }
 
-  const blunHome = path.win32.join(userHome, '.blun');
+  const sharedHome = path.win32.join(userHome, '.blun');
+  const profilePaths = resolveProfilePaths(sharedHome, profileName, path.win32);
+  if (configuredSharedHome
+    && normalizeWindowsPath(path.win32.resolve(configuredSharedHome)) !== normalizeWindowsPath(sharedHome)) {
+    throw new Error(`BLUN_SHARED_HOME muss unter Windows exakt im Windows-Benutzerprofil liegen: ${sharedHome}`);
+  }
+  const configuredHomeIsLegacyShared = !configuredSharedHome
+    && configuredHome
+    && normalizeWindowsPath(path.win32.resolve(configuredHome)) === normalizeWindowsPath(sharedHome);
   if (configuredHome
-    && normalizeWindowsPath(path.win32.resolve(configuredHome)) !== normalizeWindowsPath(blunHome)) {
-    throw new Error(`BLUN_HOME muss unter Windows exakt im Windows-Benutzerprofil liegen: ${blunHome}`);
+    && !configuredHomeIsLegacyShared
+    && normalizeWindowsPath(path.win32.resolve(configuredHome)) !== normalizeWindowsPath(profilePaths.home)) {
+    throw new Error(`BLUN_HOME passt nicht zum Profil ${profileName}: ${profilePaths.home}`);
   }
-  return { blunHome, userHome };
+  return {
+    blunHome: profilePaths.home,
+    profilePaths,
+    sharedHome,
+    userHome,
+  };
 }
 
 function readPackageVersion() {
@@ -271,12 +306,12 @@ async function runLauncher(options = {}) {
         if (mcpNames.length > 0) {
           seedStandardTools({
             packageRoot: PKG,
-            blunDir: privatePaths.blunHome,
+            blunDir: privatePaths.profilePaths.home,
             names: mcpNames,
           });
         }
         if (selected.includes('telegram')) {
-          installTelegramForProfile(PKG, privatePaths.blunHome);
+          installTelegramForProfile(PKG, privatePaths.profilePaths.home);
         }
         process.stdout.write(`${selected.join('\n')}\n`);
         return;
@@ -298,7 +333,7 @@ async function runLauncher(options = {}) {
         stdin: process.stdin,
         stdout: process.stdout,
         stderr: process.stderr,
-        blunDir: privatePaths.blunHome,
+        blunDir: privatePaths.sharedHome,
         packageRoot: PKG,
         noticeLease,
         request: ARGS[0],
@@ -307,13 +342,13 @@ async function runLauncher(options = {}) {
       return;
     }
 
-    let privatePaths;
+    let privatePathsCache;
     const getPrivatePaths = () => {
-      privatePaths ||= resolveLauncherPrivatePaths();
-      return privatePaths;
+      privatePathsCache ||= resolveLauncherPrivatePaths();
+      return privatePathsCache;
     };
     const nodeRuntime = await prepareManagedNodeRuntime({
-      getBlunDir: () => getPrivatePaths().blunHome,
+      getBlunDir: () => getPrivatePaths().sharedHome,
     });
     if (nodeRuntime.kind === 'failed') {
       process.stderr.write(`${nodeRuntime.message}\n`);
@@ -332,12 +367,24 @@ async function runLauncher(options = {}) {
       const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
       const informationalEnv = { ...process.env };
       delete informationalEnv.BLUN_HOME;
-      env.BLUN_HOME = resolveLauncherPrivatePaths({ env: informationalEnv }).blunHome;
+      delete informationalEnv.BLUN_SHARED_HOME;
+      const privatePaths = resolveLauncherPrivatePaths({ env: informationalEnv });
+      const profilePaths = privatePaths.profilePaths;
+      env.BLUN_HOME = profilePaths.home;
+      env.BLUN_SHARED_HOME = privatePaths.sharedHome;
+      env.BLUN_LOG_HOME = privatePaths.sharedHome;
+      env.BLUN_PROFILE = PROFILE.profileName;
       process.exitCode = await superviseProtectedCore(ARGS, env, callerCwd, releaseNotice);
       return;
     }
 
-    const blunDir = getPrivatePaths().blunHome;
+    const privatePaths = getPrivatePaths();
+    const profilePaths = privatePaths.profilePaths;
+    ensurePrivateDirectory(privatePaths.sharedHome);
+    if (PROFILE.profileName === 'default') {
+      seedDefaultProfileFromLegacy(privatePaths.sharedHome);
+    }
+    const blunDir = profilePaths.home;
     ensurePrivateDirectory(blunDir);
 
     // --- 1. Oeffentlicher npm-Update-Dialog. -------------------------------
@@ -350,7 +397,7 @@ async function runLauncher(options = {}) {
         stdin: process.stdin,
         stdout: process.stdout,
         stderr: process.stderr,
-        blunDir,
+        blunDir: privatePaths.sharedHome,
         packageRoot: PKG,
         noticeLease,
       });
@@ -382,7 +429,7 @@ async function runLauncher(options = {}) {
     });
 
   // --- 4. Eigenes BLUN-Grunddesign als einzigen Standard-Skill installieren
-    seedStandardDesignSkill({ packageRoot: PKG, blunDir });
+    seedStandardDesignSkill({ packageRoot: PKG, blunDir: privatePaths.sharedHome });
 
     // --- 5. Telegram-Plugin + Token-Vorlage (nur King) -----------------------
     if (mode === LAUNCHER_MODES.KING) {
@@ -402,7 +449,10 @@ async function runLauncher(options = {}) {
 
     // --- 6. Start -----------------------------------------------------------
     const env = createLauncherEnvironment(process.env, mode, readPackageVersion());
-    env.BLUN_HOME = blunDir;
+    env.BLUN_HOME = profilePaths.home;
+    env.BLUN_SHARED_HOME = privatePaths.sharedHome;
+    env.BLUN_LOG_HOME = privatePaths.sharedHome;
+    env.BLUN_PROFILE = PROFILE.profileName;
     env.BLUN_MODEL_MAX_COMPLETION_TOKENS = env.BLUN_MODEL_MAX_COMPLETION_TOKENS || '32768';
     process.exitCode = await superviseProtectedCore(
       ARGS,

package/bin/profile-runtime.cjs

@@ -0,0 +1,128 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_PROFILE = 'default';
+const PROFILE_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]{0,31}$/u;
+const RESERVED_SINGLE_ARGUMENTS = new Set([
+  'doctor',
+  'export',
+  'help',
+  'mcp',
+  'server',
+  'tools',
+  'update',
+  'upgrade',
+  'version',
+]);
+const LEGACY_PROFILE_ENTRIES = Object.freeze([
+  'channels',
+  'config.toml',
+  'mcp.json',
+  'plugins',
+  'session_index.jsonl',
+  'sessions',
+  'tui.toml',
+]);
+const MIGRATION_MARKER = '.legacy-profile-migrated-v1';
+
+function normalizeProfileName(value) {
+  const normalized = String(value || '').trim().toLowerCase();
+  if (!PROFILE_NAME_PATTERN.test(normalized)) {
+    throw new Error('Profilnamen duerfen nur Buchstaben, Zahlen, Unterstriche und Bindestriche enthalten.');
+  }
+  return normalized;
+}
+
+function parseProfileLaunchArgs(inputArgs, mode = 'blun') {
+  const args = Array.isArray(inputArgs) ? [...inputArgs] : [];
+  if (String(mode).toLowerCase() !== 'king') {
+    return { args, profileName: DEFAULT_PROFILE };
+  }
+
+  const profileFlagIndex = args.indexOf('--profile');
+  if (profileFlagIndex >= 0) {
+    if (profileFlagIndex + 1 >= args.length) {
+      throw new Error('--profile braucht einen Profilnamen.');
+    }
+    const profileName = normalizeProfileName(args[profileFlagIndex + 1]);
+    args.splice(profileFlagIndex, 2);
+    return { args, profileName };
+  }
+
+  if (args.length === 1) {
+    const candidate = String(args[0] || '');
+    if (!candidate.startsWith('-') && !RESERVED_SINGLE_ARGUMENTS.has(candidate.toLowerCase())) {
+      return { args: [], profileName: normalizeProfileName(candidate) };
+    }
+  }
+
+  if (args.length === 2 && args.includes('-c')) {
+    const candidate = args.find((arg) => arg !== '-c');
+    if (candidate && !candidate.startsWith('-')) {
+      return { args: ['-c'], profileName: normalizeProfileName(candidate) };
+    }
+  }
+
+  return { args, profileName: DEFAULT_PROFILE };
+}
+
+function resolveProfilePaths(sharedHome, profileName, pathImpl = path) {
+  const normalized = normalizeProfileName(profileName);
+  const home = pathImpl.join(sharedHome, 'profile', normalized);
+  return Object.freeze({
+    profileName: normalized,
+    sharedHome,
+    home,
+    channels: pathImpl.join(home, 'channels'),
+    sessions: pathImpl.join(home, 'sessions'),
+    plugins: pathImpl.join(home, 'plugins'),
+    config: pathImpl.join(home, 'config.toml'),
+    mcp: pathImpl.join(home, 'mcp.json'),
+    sessionIndex: pathImpl.join(home, 'session_index.jsonl'),
+    credentials: pathImpl.join(sharedHome, 'credentials'),
+    oauth: pathImpl.join(sharedHome, 'oauth'),
+    deviceId: pathImpl.join(sharedHome, 'device_id'),
+    skills: pathImpl.join(sharedHome, 'skills'),
+    secure: pathImpl.join(sharedHome, 'secure'),
+    persona: pathImpl.join(sharedHome, 'persona.json'),
+    globalLog: pathImpl.join(sharedHome, 'logs', 'blun.log'),
+  });
+}
+
+function copyLegacyEntry(source, target, fsImpl) {
+  if (!fsImpl.existsSync(source) || fsImpl.existsSync(target)) return;
+  const stat = fsImpl.lstatSync(source);
+  if (stat.isSymbolicLink()) return;
+  if (stat.isDirectory()) {
+    fsImpl.cpSync(source, target, { recursive: true, errorOnExist: false });
+    return;
+  }
+  if (stat.isFile()) fsImpl.copyFileSync(source, target);
+}
+
+function seedDefaultProfileFromLegacy(sharedHome, fsImpl = fs) {
+  const paths = resolveProfilePaths(sharedHome, DEFAULT_PROFILE);
+  const marker = path.join(paths.home, MIGRATION_MARKER);
+  if (fsImpl.existsSync(marker)) return paths;
+
+  fsImpl.mkdirSync(paths.home, { recursive: true });
+  for (const entry of LEGACY_PROFILE_ENTRIES) {
+    copyLegacyEntry(path.join(sharedHome, entry), path.join(paths.home, entry), fsImpl);
+  }
+  try {
+    fsImpl.writeFileSync(marker, 'legacy profile state copied once\n', { encoding: 'utf8', flag: 'wx' });
+  } catch (error) {
+    if (error?.code !== 'EEXIST') throw error;
+  }
+  return paths;
+}
+
+module.exports = {
+  DEFAULT_PROFILE,
+  normalizeProfileName,
+  parseProfileLaunchArgs,
+  resolveProfilePaths,
+  seedDefaultProfileFromLegacy,
+};

package/bin/rate-limit-recovery-policy.cjs

@@ -0,0 +1,34 @@
+"use strict";
+
+const MAX_AUTOMATIC_RATE_LIMIT_RESUMES = 3;
+const RATE_LIMIT_RETRY_BASE_MS = 60_000;
+const RATE_LIMIT_COMPACTION_THRESHOLD_TOKENS = 64_000;
+
+function isImmediateGenerateRetryAllowed(statusCode) {
+  return statusCode !== 429 && [500, 502, 503, 504].includes(statusCode);
+}
+
+function rateLimitRetryDelayMs(retryCount) {
+  if (!Number.isInteger(retryCount) || retryCount < 1) {
+    throw new Error("retryCount must be a positive integer.");
+  }
+  return RATE_LIMIT_RETRY_BASE_MS * (2 ** (retryCount - 1));
+}
+
+function shouldStopAutomaticRateLimitResume(retryCount) {
+  return retryCount >= MAX_AUTOMATIC_RATE_LIMIT_RESUMES;
+}
+
+function shouldCompactBeforeRateLimitResume(estimatedRequestTokens) {
+  return Number.isFinite(estimatedRequestTokens)
+    && estimatedRequestTokens >= RATE_LIMIT_COMPACTION_THRESHOLD_TOKENS;
+}
+
+module.exports = {
+  MAX_AUTOMATIC_RATE_LIMIT_RESUMES,
+  RATE_LIMIT_RETRY_BASE_MS,
+  isImmediateGenerateRetryAllowed,
+  rateLimitRetryDelayMs,
+  shouldCompactBeforeRateLimitResume,
+  shouldStopAutomaticRateLimitResume,
+};

package/bin/standard-tools-bootstrap.js

@@ -74,6 +74,41 @@ function hasEquivalentServer(servers, name, tool) {
   });
 }
 
+function sameStringArray(left, right) {
+  return Array.isArray(left)
+    && Array.isArray(right)
+    && left.length === right.length
+    && left.every((value, index) => value === right[index]);
+}
+
+function recognizedBundledServer(current, expected) {
+  return isObject(current)
+    && current.transport === expected.transport
+    && current.command === expected.command
+    && sameStringArray(current.args, expected.args);
+}
+
+function migrateBundledTimeouts(name, current, expected) {
+  if (!recognizedBundledServer(current, expected)) return false;
+  let changed = false;
+  if (name === 'agent-browser') {
+    if (current.startupTimeoutMs === 30_000) {
+      current.startupTimeoutMs = expected.startupTimeoutMs;
+      changed = true;
+    }
+    if (current.toolTimeoutMs === 60_000) {
+      current.toolTimeoutMs = expected.toolTimeoutMs;
+      changed = true;
+    }
+  }
+  if (name === 'blun-language-guard'
+    && (current.toolTimeoutMs === 30_000 || current.toolTimeoutMs === 60_000)) {
+    current.toolTimeoutMs = expected.toolTimeoutMs;
+    changed = true;
+  }
+  return changed;
+}
+
 function writeMcpDocument(configPath, document) {
   const temporaryPath = path.join(
     path.dirname(configPath),
@@ -160,21 +195,27 @@ function seedStandardTools({
   const document = readMcpDocument(configPath);
   const servers = { ...document.mcpServers };
   const added = [];
+  const updated = [];
 
   for (const name of selectedNames) {
     const tool = catalogue.tools[name];
-    if (hasEquivalentServer(servers, name, tool)) continue;
-    servers[name] = bundledToolConfig(name, tool, {
+    const expected = bundledToolConfig(name, tool, {
       packageRoot,
       blunDir,
       platform,
       env,
     });
+    if (Object.hasOwn(servers, name)) {
+      if (migrateBundledTimeouts(name, servers[name], expected)) updated.push(name);
+      continue;
+    }
+    if (hasEquivalentServer(servers, name, tool)) continue;
+    servers[name] = expected;
     added.push(name);
   }
 
-  if (added.length > 0) writeMcpDocument(configPath, { ...document, mcpServers: servers });
-  return { added, configPath };
+  if (added.length > 0 || updated.length > 0) writeMcpDocument(configPath, { ...document, mcpServers: servers });
+  return { added, updated, configPath };
 }
 
 function seedStandardDesignSkill({ packageRoot, blunDir }) {

package/bin/subagent-timeout-policy.cjs

@@ -0,0 +1,79 @@
+"use strict";
+
+const DEFAULT_SUBAGENT_TIMEOUT_MS = 4 * 60 * 60 * 1000;
+const MAX_SUBAGENT_TIMEOUT_MINUTES = 7 * 24 * 60;
+const SUBAGENT_TIMEOUT_ENV = "BLUN_SUBAGENT_TIMEOUT_MINUTES";
+
+function resolveSubagentTimeoutMs({ perRunMinutes, env = process.env } = {}) {
+  const raw = perRunMinutes ?? env[SUBAGENT_TIMEOUT_ENV];
+  if (raw === undefined || raw === null || raw === "") {
+    return DEFAULT_SUBAGENT_TIMEOUT_MS;
+  }
+
+  const minutes = typeof raw === "number" ? raw : Number(raw);
+  if (!Number.isInteger(minutes) || minutes < 0 || minutes > MAX_SUBAGENT_TIMEOUT_MINUTES) {
+    throw new Error(
+      `${SUBAGENT_TIMEOUT_ENV} must be an integer from 0 to ${MAX_SUBAGENT_TIMEOUT_MINUTES} minutes.`,
+    );
+  }
+  return minutes === 0 ? undefined : minutes * 60 * 1000;
+}
+
+function abortError(reason) {
+  if (reason instanceof Error) return reason;
+  return new Error(reason === undefined ? "Subagent interrupted." : String(reason));
+}
+
+async function runAgentWithTimeoutContinuation({
+  handle,
+  timeoutMs,
+  signal,
+  abortCurrent,
+  retrySameAgent,
+}) {
+  let currentHandle = handle;
+
+  while (true) {
+    let timeout;
+    let removeAbortListener = () => {};
+    const completion = Promise.resolve(currentHandle.completion).then(
+      (outcome) => ({ kind: "completed", outcome }),
+      (error) => ({ kind: "failed", error }),
+    );
+    const timedOut = timeoutMs === undefined
+      ? new Promise(() => {})
+      : new Promise((resolve) => {
+          timeout = setTimeout(() => resolve({ kind: "timed_out" }), timeoutMs);
+        });
+    const interrupted = signal.aborted
+      ? Promise.resolve({ kind: "interrupted", reason: signal.reason })
+      : new Promise((resolve) => {
+          const onAbort = () => resolve({ kind: "interrupted", reason: signal.reason });
+          signal.addEventListener("abort", onAbort, { once: true });
+          removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+        });
+
+    const result = await Promise.race([completion, timedOut, interrupted]);
+    if (timeout !== undefined) clearTimeout(timeout);
+    removeAbortListener();
+
+    if (result.kind === "completed") return { handle: currentHandle, outcome: result.outcome };
+    if (result.kind === "failed") throw result.error;
+    if (result.kind === "interrupted") {
+      abortCurrent(result.reason);
+      await Promise.resolve(currentHandle.completion).catch(() => {});
+      throw abortError(result.reason);
+    }
+
+    const reason = new Error("Subagent continuation interval elapsed.");
+    abortCurrent(reason);
+    await Promise.resolve(currentHandle.completion).catch(() => {});
+    currentHandle = await retrySameAgent(currentHandle.agentId);
+  }
+}
+
+module.exports = {
+  DEFAULT_SUBAGENT_TIMEOUT_MS,
+  resolveSubagentTimeoutMs,
+  runAgentWithTimeoutContinuation,
+};

package/blun.mjs

@@ -1539,7 +1539,6 @@ function isRetryableGenerateError(error) {
 	if (error instanceof APIConnectionError || error instanceof APITimeoutError) return true;
 	if (error instanceof APIEmptyResponseError) return true;
 	return error instanceof APIStatusError && [
-		429,
 		500,
 		502,
 		503,
@@ -10263,6 +10262,11 @@ function resolveBlunHome$1(homeDir) {
 	if (env !== void 0 && env.length > 0) return env;
 	return join$4(homedir(), ".blun");
 }
+function resolveSharedBlunHome(homeDir) {
+	const shared = process.env["BLUN_SHARED_HOME"];
+	if (shared !== void 0 && shared.length > 0) return shared;
+	return homeDir ?? resolveBlunHome$1();
+}
 function resolveConfigPath(input) {
 	return input.configPath ?? join$4(resolveBlunHome$1(input.homeDir), "config.toml");
 }
@@ -16884,11 +16888,16 @@ function resolvePayload(payload) {
 	};
 }
 function mergeCtx(payloadCtx, boundCtx) {
-	if (!(Object.keys(boundCtx).length > 0)) return payloadCtx;
-	if (payloadCtx === void 0) return { ...boundCtx };
+	const runtimeCtx = process.env["BLUN_PROFILE"] ? { profile: process.env["BLUN_PROFILE"] } : {};
+	if (!(Object.keys(boundCtx).length > 0) && Object.keys(runtimeCtx).length === 0) return payloadCtx;
+	if (payloadCtx === void 0) return {
+		...boundCtx,
+		...runtimeCtx
+	};
 	return {
 		...payloadCtx,
-		...boundCtx
+		...boundCtx,
+		...runtimeCtx
 	};
 }
 function resolveGlobalLogPath(homeDir) {
@@ -28180,6 +28189,8 @@ var init_conduct = __esmMin((() => {}));
 * read/write the same location: `BLUN_HOME` env override, else `~/.blun`.
 */
 function resolveBlunHome(env = process.env) {
+	const shared = env["BLUN_SHARED_HOME"]?.trim();
+	if (shared && shared.length > 0) return shared;
 	const override = env["BLUN_HOME"]?.trim();
 	return override && override.length > 0 ? override : join$4(homedir(), ".blun");
 }
@@ -29016,26 +29027,46 @@ var init_agent_task = __esmMin((() => {
 		description;
 		subagentHost;
 		abortController;
+		continuationTimeoutMs;
+		runInBackground;
+		parentToolCallId;
 		kind = "agent";
 		idPrefix = "agent";
 		agentId;
 		subagentType;
-		constructor(handle, description, subagentHost, abortController) {
+		constructor(handle, description, subagentHost, abortController, options) {
 			this.handle = handle;
 			this.description = description;
 			this.subagentHost = subagentHost;
 			this.abortController = abortController;
+			this.continuationTimeoutMs = options.timeoutMs;
+			this.runInBackground = options.runInBackground;
+			this.parentToolCallId = options.parentToolCallId;
 			this.agentId = handle.agentId;
 			this.subagentType = handle.profileName;
 		}
 		async start(sink) {
-			const requestAbort = () => {
-				this.abortController.abort(sink.signal.reason);
-			};
-			if (sink.signal.aborted) requestAbort();
-			else sink.signal.addEventListener("abort", requestAbort, { once: true });
 			try {
-				const outcome = await this.handle.completion;
+				const { handle, outcome } = await runAgentWithTimeoutContinuation({
+					handle: this.handle,
+					timeoutMs: this.continuationTimeoutMs,
+					signal: sink.signal,
+					abortCurrent: (reason) => {
+						this.abortController.abort(reason);
+					},
+					retrySameAgent: async (agentId) => {
+						this.abortController = new AbortController();
+						this.handle = await this.subagentHost.retry(agentId, {
+							parentToolCallId: this.parentToolCallId,
+							prompt: "Continue from the preserved context after the wall-clock interval.",
+							description: this.description,
+							runInBackground: this.runInBackground,
+							signal: this.abortController.signal
+						});
+						return this.handle;
+					}
+				});
+				this.handle = handle;
 				sink.appendOutput(outcome.result);
 				await sink.settle({ status: "completed" });
 			} catch (error) {
@@ -29047,16 +29078,16 @@ var init_agent_task = __esmMin((() => {
 					status: "failed",
 					stopReason: errorMessage$12(error)
 				});
-			} finally {
-				sink.signal.removeEventListener("abort", requestAbort);
 			}
 		}
 		onDetach() {
+			this.runInBackground = true;
 			this.subagentHost.markActiveChildDetached(this.agentId);
 		}
 		toInfo(base) {
 			return {
 				...base,
+				timeoutMs: this.continuationTimeoutMs,
 				kind: "agent",
 				agentId: this.agentId,
 				subagentType: this.subagentType
@@ -235026,7 +235057,7 @@ async function resolveSkillRoots(options) {
 	const roots = [];
 	const mergeAllAvailableSkills = options.mergeAllAvailableSkills ?? true;
 	const { userHomeDir, workDir } = options.paths;
-	const brandHomeDir = options.paths.brandHomeDir ?? process.env["BLUN_HOME"] ?? posix$2.join(userHomeDir, ".blun");
+	const brandHomeDir = options.paths.brandHomeDir ?? process.env["BLUN_SHARED_HOME"] ?? process.env["BLUN_HOME"] ?? posix$2.join(userHomeDir, ".blun");
 	const projectRoot = await findProjectRoot$1(workDir);
 	if (options.explicitDirs !== void 0 && options.explicitDirs.length > 0) await pushConfiguredDirs(roots, options.explicitDirs, projectRoot, userHomeDir, "user", isDir, realpath);
 	else {
@@ -251078,14 +251109,14 @@ function resolveSwarmMaxConcurrency(env = process.env) {
 	if (!Number.isInteger(value) || value <= 0) throw new Error(`${AGENT_SWARM_MAX_CONCURRENCY_ENV} must be a positive integer, got ${JSON.stringify(raw)}.`);
 	return value;
 }
-var import_retry, INITIAL_LAUNCH_LIMIT, INITIAL_LAUNCH_INTERVAL_MS, RATE_LIMIT_RETRY_BASE_MS, RATE_LIMIT_RETRY_FACTOR, RATE_LIMIT_CAPACITY_SHRINK_INTERVAL_MS, RATE_LIMIT_CAPACITY_RECOVERY_INTERVAL_MS, RATE_LIMIT_SUSPENDED_REASON, AGENT_SWARM_MAX_CONCURRENCY_ENV, SubagentBatch;
+var import_retry, INITIAL_LAUNCH_LIMIT, INITIAL_LAUNCH_INTERVAL_MS, RATE_LIMIT_RETRY_BASE_MS, RATE_LIMIT_RETRY_FACTOR, RATE_LIMIT_CAPACITY_SHRINK_INTERVAL_MS, RATE_LIMIT_CAPACITY_RECOVERY_INTERVAL_MS, RATE_LIMIT_SUSPENDED_REASON, AGENT_SWARM_MAX_CONCURRENCY_ENV, MAX_AUTOMATIC_RATE_LIMIT_RESUMES, rateLimitRetryDelayMs, shouldCompactBeforeRateLimitResume, shouldStopAutomaticRateLimitResume, SubagentBatch;
 var init_subagent_batch = __esmMin((() => {
 	init_src$4();
 	import_retry = /* @__PURE__ */ __toESM(require_retry$1(), 1);
 	init_abort();
+	({ MAX_AUTOMATIC_RATE_LIMIT_RESUMES, RATE_LIMIT_RETRY_BASE_MS, rateLimitRetryDelayMs, shouldCompactBeforeRateLimitResume, shouldStopAutomaticRateLimitResume } = createRequire(import.meta.url)("./bin/rate-limit-recovery-policy.cjs"));
 	INITIAL_LAUNCH_LIMIT = 5;
 	INITIAL_LAUNCH_INTERVAL_MS = 700;
-	RATE_LIMIT_RETRY_BASE_MS = 3e3;
 	RATE_LIMIT_RETRY_FACTOR = 2;
 	RATE_LIMIT_CAPACITY_SHRINK_INTERVAL_MS = 2e3;
 	RATE_LIMIT_CAPACITY_RECOVERY_INTERVAL_MS = 180 * 1e3;
@@ -251226,6 +251257,7 @@ var init_subagent_batch = __esmMin((() => {
 				description: task.description,
 				swarmIndex: task.swarmIndex,
 				runInBackground: task.runInBackground,
+				compactBeforeRetry: attempt.state.retryCount > 0,
 				signal: attempt.controller.signal,
 				onReady: () => {
 					this.markAttemptReady(attempt);
@@ -251291,17 +251323,27 @@ var init_subagent_batch = __esmMin((() => {
 		handleAttemptOutcome(attempt, outcome) {
 			if (!this.releaseAttempt(attempt)) return;
 			if (this.finished) return;
-			if ("status" in outcome) this.results[attempt.state.index] = outcome;
-			else if (this.isOnlyUnfinishedTask(attempt.state)) this.results[attempt.state.index] = {
+			if ("status" in outcome && attempt.timedOut && outcome.agentId !== void 0) {
+				this.requeueTimedOut(attempt, outcome.agentId);
+			}
+			else if ("status" in outcome) this.results[attempt.state.index] = outcome;
+			else if (shouldStopAutomaticRateLimitResume(attempt.state.retryCount)) this.results[attempt.state.index] = {
 				task: attempt.state.task,
 				agentId: outcome.agentId,
 				status: "failed",
 				state: "started",
-				error: outcome.error
+				error: `${outcome.error} Automatic continuation stopped after ${String(MAX_AUTOMATIC_RATE_LIMIT_RESUMES)} attempts; agent ${outcome.agentId} remains resumable.`
 			};
 			else this.requeueRateLimited(attempt, outcome.agentId);
 			this.schedule();
 		}
+		requeueTimedOut(attempt, agentId) {
+			const state = attempt.state;
+			state.agentId = agentId;
+			state.retryAgentId = agentId;
+			state.retryReadyAt = 0;
+			this.pending.unshift(state);
+		}
 		handleAttemptError(attempt, error) {
 			if (!this.releaseAttempt(attempt)) return;
 			if (this.finished) return;
@@ -251330,12 +251372,7 @@ var init_subagent_batch = __esmMin((() => {
 			const now = Date.now();
 			this.lastRateLimitAt = now;
 			state.retryCount += 1;
-			const retryDelay = import_retry.createTimeout(Math.max(0, state.retryCount - 1), {
-				minTimeout: RATE_LIMIT_RETRY_BASE_MS,
-				maxTimeout: Number.POSITIVE_INFINITY,
-				factor: RATE_LIMIT_RETRY_FACTOR,
-				randomize: false
-			});
+			const retryDelay = rateLimitRetryDelayMs(state.retryCount);
 			state.retryReadyAt = now + retryDelay;
 			this.pending.unshift(state);
 			this.enterRateLimitMode(now);
@@ -251509,7 +251546,7 @@ function shouldSuppressQueuedAttemptFailureEvent(options, error) {
 	if (isProviderRateLimitError(error)) return true;
 	return isAbortError$4(error) || options.signal.aborted;
 }
-var DEFAULT_SUBAGENT_TIMEOUT_MS, DEFAULT_SUBAGENT_TIMEOUT_DESCRIPTION, SUMMARY_MIN_LENGTH, SUMMARY_CONTINUATION_ATTEMPTS, HOOK_TEXT_PREVIEW_LENGTH, SUBAGENT_MAX_TOKENS_ERROR, TOOL_CALL_DISABLED_MESSAGE, SUBAGENT_PROMPT_ORIGIN, SIDE_QUESTION_SYSTEM_REMINDER, SessionSubagentHost;
+var DEFAULT_SUBAGENT_TIMEOUT_MS, resolveSubagentTimeoutMs, runAgentWithTimeoutContinuation, SUMMARY_MIN_LENGTH, SUMMARY_CONTINUATION_ATTEMPTS, HOOK_TEXT_PREVIEW_LENGTH, SUBAGENT_MAX_TOKENS_ERROR, TOOL_CALL_DISABLED_MESSAGE, SUBAGENT_PROMPT_ORIGIN, SIDE_QUESTION_SYSTEM_REMINDER, SessionSubagentHost;
 var init_subagent_host = __esmMin((() => {
 	init_src$4();
 	init_errors$8();
@@ -251521,8 +251558,7 @@ var init_subagent_host = __esmMin((() => {
 	init_git_context();
 	init_subagent_batch();
 	init_summary_continuation();
-	DEFAULT_SUBAGENT_TIMEOUT_MS = 1800 * 1e3;
-	DEFAULT_SUBAGENT_TIMEOUT_DESCRIPTION = "30 minutes";
+	({ DEFAULT_SUBAGENT_TIMEOUT_MS, resolveSubagentTimeoutMs, runAgentWithTimeoutContinuation } = createRequire(import.meta.url)("./bin/subagent-timeout-policy.cjs"));
 	SUMMARY_MIN_LENGTH = 200;
 	SUMMARY_CONTINUATION_ATTEMPTS = 1;
 	HOOK_TEXT_PREVIEW_LENGTH = 500;
@@ -251634,6 +251670,13 @@ IMPORTANT:
 							modelAlias: parent.config.modelAlias,
 							actionStyle: parent.config.actionStyle
 						});
+						if (runOptions.compactBeforeRetry === true && shouldCompactBeforeRateLimitResume(child.fullCompaction.estimateCurrentRequestTokens())) {
+							child.fullCompaction.begin({
+								source: "manual",
+								instruction: "Preserve completed work, current state, exact evidence, and the next action so this same agent can continue after the provider rate limit."
+							});
+							await child.fullCompaction.block(runOptions.signal);
+						}
 						this.emitSubagentStarted(parent, agentId);
 						if (child.turn.retry("agent-host") === null) throw new Error(`Agent instance "${agentId}" could not start a retry turn`);
 						this.observeFirstRequest(child, runOptions);
@@ -251865,7 +251908,7 @@ var init_agent_background_enabled = __esmMin((() => {
 //#region ../../packages/agent-core/src/tools/builtin/collaboration/agent.md?raw
 var agent_default;
 var init_agent$2 = __esmMin((() => {
-	agent_default = "Launch a subagent to handle a task. The subagent runs as a same-process loop instance with its own context and wire file. Delegating also keeps the bulk of intermediate file contents out of your own context — you get a conclusion back instead of a pile of dumps.\n\nWriting the prompt:\n- The subagent starts with zero context — it has not seen this conversation. Brief it like a colleague who just walked into the room: state the goal, list what you already know, hand over the specifics.\n- Lookups (read this file, run that test): put the exact path or command in the prompt. The subagent should not have to search for things you already know.\n- Investigations (figure out X, find why Y): give the question, not prescribed steps — fixed steps become dead weight when the premise is wrong.\n- Do not delegate understanding. If the task hinges on a file path or line number, find it yourself first and write it into the prompt.\n\nUsage notes:\n- When the task continues earlier work a subagent already did, prefer resuming that agent (pass its `resume` id) over spawning a fresh instance — the resumed agent keeps its prior context.\n- A subagent's result is only visible to you, not to the user. When the user needs to see what a subagent produced, summarize the relevant parts yourself in your own reply.\n- Subagents use a fixed 30-minute timeout. If one times out, resume the same agent instead of starting over.\n\nWhen NOT to use Agent: skip delegation for trivial work you can do directly — reading a file whose path you already know, searching a small known set of files, or any task that takes only a step or two. Delegation has a context-handoff cost; it pays off only when the task is substantial enough to outweigh it.\n\nOnce a subagent is running, leave that scope to it: do not redo its searches or reads in parallel, and do not abandon it midway and finish the job manually. Both undo the context savings the delegation was meant to buy.\n";
+	agent_default = "Launch a subagent to handle a task. The subagent runs as a same-process loop instance with its own context and wire file. Delegating also keeps the bulk of intermediate file contents out of your own context — you get a conclusion back instead of a pile of dumps.\n\nWriting the prompt:\n- The subagent starts with zero context — it has not seen this conversation. Brief it like a colleague who just walked into the room: state the goal, list what you already know, hand over the specifics.\n- Lookups (read this file, run that test): put the exact path or command in the prompt. The subagent should not have to search for things you already know.\n- Investigations (figure out X, find why Y): give the question, not prescribed steps — fixed steps become dead weight when the premise is wrong.\n- Do not delegate understanding. If the task hinges on a file path or line number, find it yourself first and write it into the prompt.\n\nUsage notes:\n- When the task continues earlier work a subagent already did, prefer resuming that agent (pass its `resume` id) over spawning a fresh instance — the resumed agent keeps its prior context.\n- A subagent's result is only visible to you, not to the user. When the user needs to see what a subagent produced, summarize the relevant parts yourself in your own reply.\n- The default wall-clock interval is four hours; when it elapses, the same agent continues automatically with its preserved context. Set `timeout_minutes=0` to disable the interval, or provide another minute value for this run.\n\nWhen NOT to use Agent: skip delegation for trivial work you can do directly — reading a file whose path you already know, searching a small known set of files, or any task that takes only a step or two. Delegation has a context-handoff cost; it pays off only when the task is substantial enough to outweigh it.\n\nOnce a subagent is running, leave that scope to it: do not redo its searches or reads in parallel, and do not abandon it midway and finish the job manually. Both undo the context savings the delegation was meant to buy.\n";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/collaboration/agent.ts
@@ -251944,7 +251987,8 @@ var init_agent$1 = __esmMin((() => {
 		description: string().describe("Short task description (3-5 words) for UI display"),
 		subagent_type: string().optional().describe("One of the available agent types (see \"Available agent types\" in this tool description). Defaults to \"coder\" when omitted."),
 		resume: string().optional().describe("Optional agent ID to resume instead of creating a new instance. When set, do not also pass subagent_type — the resumed agent keeps its own type, and supplying both is rejected."),
-		run_in_background: boolean$1().optional().describe("If true, return immediately without waiting for completion. Prefer false unless the task can run independently and there is a clear benefit to not waiting.")
+		run_in_background: boolean$1().optional().describe("If true, return immediately without waiting for completion. Prefer false unless the task can run independently and there is a clear benefit to not waiting."),
+		timeout_minutes: number$1().int().min(0).max(10080).optional().describe("Wall-clock interval before the same agent is continued automatically. Defaults to 240 minutes. Set 0 to disable the interval for this run.")
 	}));
 	object({
 		result: string().describe("Aggregated text output from the subagent"),
@@ -252039,9 +252083,12 @@ var init_agent$1 = __esmMin((() => {
 				}
 				let taskId;
 				try {
-					taskId = this.backgroundManager.registerTask(new AgentBackgroundTask(handle, args.description, this.subagentHost, controller), {
+					taskId = this.backgroundManager.registerTask(new AgentBackgroundTask(handle, args.description, this.subagentHost, controller, {
+						timeoutMs: resolveSubagentTimeoutMs({ perRunMinutes: args.timeout_minutes }),
+						runInBackground,
+						parentToolCallId: toolCallId
+					}), {
 						detached: runInBackground,
-						timeoutMs: DEFAULT_SUBAGENT_TIMEOUT_MS,
 						signal: runInBackground ? void 0 : signal
 					});
 					signal.removeEventListener("abort", abortBeforeRegister);
@@ -252075,7 +252122,7 @@ var init_agent$1 = __esmMin((() => {
 			if (info?.status === "completed") return { output: formatForegroundAgentSuccess(handle, await this.backgroundManager.readOutput(taskId)) };
 			const timedOut = info?.status === "timed_out";
 			return {
-				output: formatForegroundAgentFailure(handle, timedOut ? `Agent timed out after ${DEFAULT_SUBAGENT_TIMEOUT_DESCRIPTION}.` : info?.stopReason === "Interrupted by user" ? USER_INTERRUPTED_SUBAGENT_MESSAGE : info?.stopReason !== void 0 ? info.stopReason : "The subagent was stopped before it finished.", timedOut),
+				output: formatForegroundAgentFailure(handle, timedOut ? "Agent timed out before automatic continuation could start." : info?.stopReason === "Interrupted by user" ? USER_INTERRUPTED_SUBAGENT_MESSAGE : info?.stopReason !== void 0 ? info.stopReason : "The subagent was stopped before it finished.", timedOut),
 				isError: true
 			};
 		}
@@ -252184,7 +252231,8 @@ var init_agent_swarm = __esmMin((() => {
 		subagent_type: string().trim().min(1).optional().describe("Subagent type used for every new subagent spawned from items; defaults to coder when omitted. Resumed subagents always keep their original type, so passing subagent_type together with resume_agent_ids is allowed — it only affects the item-based spawns."),
 		prompt_template: string().trim().min(1).optional().describe(`Prompt template for each subagent. The ${PROMPT_TEMPLATE_PLACEHOLDER} placeholder is replaced with each item value.`),
 		items: array(string().trim().min(1)).max(MAX_AGENT_SWARM_SUBAGENTS).optional().describe(`Values used to fill ${PROMPT_TEMPLATE_PLACEHOLDER}. Each item launches one new subagent.`),
-		resume_agent_ids: record(string().trim().min(1), string().trim().min(1)).optional().describe("Map of existing subagent agent_id to the prompt used to resume that subagent. These resumed subagents are launched before new item-based subagents.")
+		resume_agent_ids: record(string().trim().min(1), string().trim().min(1)).optional().describe("Map of existing subagent agent_id to the prompt used to resume that subagent. These resumed subagents are launched before new item-based subagents."),
+		timeout_minutes: number$1().int().min(0).max(10080).optional().describe("Wall-clock interval before each same swarm agent is continued automatically. Defaults to 240 minutes. Set 0 to disable the interval for this run.")
 	}).strict();
 	AgentSwarmTool = class {
 		subagentHost;
@@ -252235,7 +252283,7 @@ var init_agent_swarm = __esmMin((() => {
 					runInBackground: false,
 					swarmItem: spec.item,
 					signal,
-					timeout: DEFAULT_SUBAGENT_TIMEOUT_MS
+					timeout: resolveSubagentTimeoutMs({ perRunMinutes: args.timeout_minutes })
 				};
 				if (spec.kind === "resume") return {
 					...common,
@@ -257129,7 +257177,7 @@ function rgBinaryName() {
 	return process.platform === "win32" ? "rg.exe" : "rg";
 }
 function getShareDir() {
-	const override = process.env["BLUN_HOME"];
+	const override = process.env["BLUN_SHARED_HOME"] ?? process.env["BLUN_HOME"];
 	if (override !== void 0 && override !== "") return override;
 	return join$4(homedir(), ".blun");
 }
@@ -295369,7 +295417,7 @@ var init_session$1 = __esmMin((() => {
 			this.currentMcpConfig = options.mcpConfig;
 			this.skills = new SessionSkillRegistry({ sessionId: options.id });
 			this.mcp = new McpConnectionManager({
-				oauthService: new McpOAuthService({ blunHomeDir: options.blunHomeDir }),
+				oauthService: new McpOAuthService({ blunHomeDir: resolveSharedBlunHome(options.blunHomeDir) }),
 				log: this.log,
 				stdioCwd: options.kaos.getcwd()
 			});
@@ -295805,7 +295853,7 @@ var init_session$1 = __esmMin((() => {
 			const roots = await resolveSkillRoots({
 				paths: {
 					userHomeDir: this.options.skills?.userHomeDir ?? homedir(),
-					brandHomeDir: this.options.skills?.brandHomeDir ?? this.options.blunHomeDir,
+					brandHomeDir: this.options.skills?.brandHomeDir ?? resolveSharedBlunHome(this.options.blunHomeDir),
 					workDir: this.options.kaos.getcwd()
 				},
 				explicitDirs: this.options.skills?.explicitDirs,
@@ -315180,7 +315228,7 @@ var init_core_impl = __esmMin((() => {
 			const explicitDirs = this.skillDirs.length > 0 ? this.skillDirs : void 0;
 			return {
 				userHomeDir: this.userHomeDir,
-				brandHomeDir: this.homeDir,
+				brandHomeDir: resolveSharedBlunHome(this.homeDir),
 				explicitDirs,
 				extraDirs: config.extraSkillDirs,
 				pluginSkillRoots: this.plugins.pluginSkillRoots(),
@@ -315364,7 +315412,7 @@ function resolveLoggingConfig(input) {
 	const env = input.env ?? process.env;
 	return {
 		level: parseLevel(env["BLUN_LOG_LEVEL"]) ?? "info",
-		globalLogPath: resolveGlobalLogPath(input.homeDir),
+		globalLogPath: resolveGlobalLogPath(env["BLUN_LOG_HOME"] ?? input.homeDir),
 		globalMaxBytes: parsePositiveInt(env["BLUN_LOG_GLOBAL_MAX_BYTES"]) ?? 6291456,
 		globalFiles: parsePositiveInt(env["BLUN_LOG_GLOBAL_FILES"]) ?? 5,
 		sessionMaxBytes: parsePositiveInt(env["BLUN_LOG_SESSION_MAX_BYTES"]) ?? 5242880,
@@ -316463,7 +316511,7 @@ var init_managedAuth = __esmMin((() => {
 		constructor(options) {
 			this.options = options;
 			this.toolkit = new BlunOAuthToolkit({
-				homeDir: options.homeDir,
+				homeDir: resolveSharedBlunHome(options.homeDir),
 				configAdapter: {
 					configPath: options.configPath,
 					read: () => readConfigFile(options.configPath),
@@ -325309,9 +325357,9 @@ var BlunAuthFacade = class {
 	managedApiKeyRevocations;
 	constructor(options) {
 		this.options = options;
-		this.managedApiKeyRevocations = new FileManagedApiKeyRevocationStore(options.homeDir);
+		this.managedApiKeyRevocations = new FileManagedApiKeyRevocationStore(resolveSharedBlunHome(options.homeDir));
 		this.toolkit = new BlunOAuthToolkit({
-			homeDir: options.homeDir,
+			homeDir: resolveSharedBlunHome(options.homeDir),
 			identity: options.identity,
 			onRefresh: options.onRefresh,
 			configAdapter: {
@@ -340448,7 +340496,7 @@ function createCliTelemetryBootstrap() {
 	const homeDir = resolveBlunHome$1();
 	return {
 		homeDir,
-		deviceId: createBlunDeviceId(homeDir, { onFirstLaunch: () => {
+		deviceId: createBlunDeviceId(resolveSharedBlunHome(homeDir), { onFirstLaunch: () => {
 			firstLaunch = true;
 		} }),
 		firstLaunch
@@ -420638,12 +420686,20 @@ const LOOP_CREATE_FILLERS = new Set([
 	"every",
 	"each"
 ]);
-const LOOP_INTERVAL_TOKEN = /^\d+(?:m|h|d)$/i;
+const LOOP_INTERVAL_TOKEN = /^(\d+)(m|min(?:ute)?n?|minutes?|h|std|stunden?|hours?|d|tage?|days?)$/i;
 const LOOP_NATURAL_INTERVAL = /\b(?:alle|jede(?:n|r|s)?|every|each)\s+(\d+)\s*(min(?:ute)?n?|minutes?|stunden?|hours?|tage?|days?)\b/iu;
 const LOOP_NATURAL_HALF_HOUR = /\b(?:alle|jede(?:n|r|s)?|every|each)\s+(?:halbe|half(?:\s+an)?)\s+(?:stunde|hour)\b/iu;
 const LOOP_NATURAL_SINGLE_INTERVAL = /\b(?:jede(?:n|r|s)?|every|each)\s+(minute|stunde|hour|tag|day)\b/iu;
 const LOOP_NATURAL_ADVERB_INTERVAL = /\b(stündlich|stuendlich|hourly|täglich|taeglich|daily)\b/iu;
 const LOOP_SELF_CONTROLLED = /\b(?:selbst\s+entscheiden|selbstgesteuert)\b/iu;
+function normalizeLoopIntervalToken(token) {
+	const match = LOOP_INTERVAL_TOKEN.exec(token);
+	if (match === null) return null;
+	const amount = match[1];
+	const unit = match[2]?.toLowerCase() ?? "";
+	const suffix = unit === "h" || unit === "std" || unit.startsWith("stund") || unit.startsWith("hour") ? "h" : unit === "d" || unit.startsWith("tag") || unit.startsWith("day") ? "d" : "m";
+	return `${amount}${suffix}`;
+}
 function naturalLoopIntervalMatch(args) {
 	const numeric = LOOP_NATURAL_INTERVAL.exec(args);
 	if (numeric !== null) {
@@ -420706,8 +420762,9 @@ function loopInputHint(rawArgs) {
 	if (/^(?:status|pause|paused|resume|stop)$/i.test(args)) return "";
 	const natural = naturalLoopIntervalMatch(args);
 	if (natural !== null) return naturalLoopIntervalText(natural.interval);
-	const explicit = /^(?:start\s+)?([1-9]\d*(?:m|h|d))\b/i.exec(args);
-	if (explicit?.[1] !== void 0) return naturalLoopIntervalText(explicit[1].toLowerCase());
+	const explicitToken = /^(?:start\s+)?(\S+)/i.exec(args)?.[1];
+	const explicit = explicitToken === void 0 ? null : normalizeLoopIntervalToken(explicitToken);
+	if (explicit !== null) return naturalLoopIntervalText(explicit);
 	return "Selbstgesteuert";
 }
 function parseLoopCommand(rawArgs) {
@@ -420735,8 +420792,9 @@ function parseLoopCommand(rawArgs) {
 		};
 	}
 	if (LOOP_CREATE_FILLERS.has(tokens[startIndex]?.toLowerCase() ?? "")) startIndex += 1;
-	const interval = tokens[startIndex];
-	if (interval !== void 0 && LOOP_INTERVAL_TOKEN.test(interval)) {
+	const intervalToken = tokens[startIndex];
+	const interval = intervalToken === void 0 ? null : normalizeLoopIntervalToken(intervalToken);
+	if (interval !== null) {
 		const prompt = tokens.slice(startIndex + 1).join(" ").trim();
 		if (prompt.length === 0) return { kind: "error" };
 		return {
@@ -489065,6 +489123,14 @@ function formatLiveElapsed(seconds) {
 	const remainingMinutes = minutes % 60;
 	return `${String(hours)}h ${String(remainingMinutes).padStart(2, "0")}m`;
 }
+function formatLiveStartedAt(startedAtMs) {
+	const startedAt = new Date(startedAtMs > 0 ? startedAtMs : Date.now());
+	const day = String(startedAt.getDate()).padStart(2, "0");
+	const month = String(startedAt.getMonth() + 1).padStart(2, "0");
+	const hour = String(startedAt.getHours()).padStart(2, "0");
+	const minute = String(startedAt.getMinutes()).padStart(2, "0");
+	return `${day}.${month}. · ${hour}:${minute}`;
+}
 var ThinkingComponent = class {
 	text;
 	showMarker;
@@ -489142,14 +489208,15 @@ var ThinkingComponent = class {
 			const frame = BLUN_SPINNER_FRAMES[this.spinnerFrame] ?? BLUN_SPINNER_FRAMES[0];
 			const spinner = currentTheme.fg("primary", `${frame} `);
 			const elapsed = formatLiveElapsed(this.formatElapsedSeconds());
+			const startedAt = formatLiveStartedAt(this.thinkStartMs ?? Date.now());
 			const roundedTokenCount = Math.max(0, Math.round(this.estimatedOutputTokens));
 			const tokenCount = formatLiveTokenCount(roundedTokenCount);
 			const abortMark = this.thinkAborted ? ` (${uiText("thinking.aborted")})` : "";
 			const tokenKey = roundedTokenCount === 1 ? "thinking.tokens.one" : "thinking.tokens.other";
 			const thinkingLabel = uiText("thinking.label", { name: this.persona });
-			const fullLabel = `${thinkingLabel}… (${elapsed} · ↓ ~${uiText(tokenKey, { count: tokenCount })})${abortMark}`;
-			const compactLabel = `${thinkingLabel}… (${elapsed} · ↓${tokenCount})${abortMark}`;
-			const metricsOnly = `(${elapsed} · ↓${tokenCount})${abortMark}`;
+			const fullLabel = `${thinkingLabel}… (${elapsed} · ↓ ~${uiText(tokenKey, { count: tokenCount })} · ${startedAt})${abortMark}`;
+			const compactLabel = `${thinkingLabel}… (${elapsed} · ↓${tokenCount} · ${startedAt})${abortMark}`;
+			const metricsOnly = `(${elapsed} · ${startedAt})${abortMark}`;
 			const availableWidth = Math.max(1, width - visibleWidth(spinner));
 			const label = visibleWidth(fullLabel) <= availableWidth ? fullLabel : visibleWidth(compactLabel) <= availableWidth ? compactLabel : metricsOnly;
 			rendered = ["", spinner + currentTheme.fg("textDim", truncateToWidth(label, availableWidth))];
@@ -500355,7 +500422,8 @@ var BtwPanelComponent = class {
 		const outputTokens = estimateLiveOutputTokens(turn.thinking + turn.answer);
 		const frame = BLUN_SPINNER_FRAMES[this.spinnerFrame] ?? BLUN_SPINNER_FRAMES[0];
 		const label = uiText("blunTui.activity.thinking", { name: "BTW" });
-		const metrics = `(${formatLiveElapsed(elapsedSeconds)} · ↓ ~${formatLiveTokenCount(outputTokens)} ${uiText("blunTui.activity.tokens")})`;
+		const startedAt = formatLiveStartedAt(turn.startedAtMs);
+		const metrics = `(${formatLiveElapsed(elapsedSeconds)} · ↓ ~${formatLiveTokenCount(outputTokens)} ${uiText("blunTui.activity.tokens")} · ${startedAt})`;
 		return chalk.hex(currentTheme.palette.accent)(`${frame} `) + chalk.hex(currentTheme.palette.accent).bold(label) + " " + chalk.hex(currentTheme.palette.text)(metrics);
 	}
 	startLiveStatusTimer() {
@@ -502143,7 +502211,6 @@ var EditorKeyboardController = class {
 			}
 			if (host.state.appState.isCompacting) {
 				this.clearPendingExit();
-				if (this.clearEditorTextIfPresent()) return;
 				this.cancelCurrentCompaction();
 				return;
 			}
@@ -502157,7 +502224,6 @@ var EditorKeyboardController = class {
 			}
 			if (host.state.appState.streamingPhase !== "idle") {
 				this.clearPendingExit();
-				if (this.clearEditorTextIfPresent()) return;
 				this.cancelCurrentStream();
 				return;
 			}
@@ -502177,8 +502243,15 @@ var EditorKeyboardController = class {
 			}
 			this.armPendingExit("ctrl-d", ctrlDHint());
 		};
-		editor.onEscape = () => {
+		editor.onEscape = (autocompleteCancelled = false) => {
 			if (this.pendingExit) this.clearPendingExit();
+			if (host.cancelInFlight !== void 0) {
+				const cancel = host.cancelInFlight;
+				host.cancelInFlight = void 0;
+				this.clearPendingUndoEsc();
+				cancel();
+				return;
+			}
 			if (host.state.activeDialog === "session-picker") {
 				host.hideSessionPicker();
 				this.clearPendingUndoEsc();
@@ -502198,6 +502271,10 @@ var EditorKeyboardController = class {
 				this.clearPendingUndoEsc();
 				return;
 			}
+			if (autocompleteCancelled) {
+				this.clearPendingUndoEsc();
+				return;
+			}
 			if (this.pendingUndoEsc !== null) {
 				this.clearPendingUndoEsc();
 				host.openUndoSelector();
@@ -504257,6 +504334,13 @@ function mcpServerStatusKey(server) {
 		server.error
 	]);
 }
+function mcpStartupInventory(servers) {
+	const connected = servers.filter((server) => server.status === "connected");
+	return {
+		serverCount: connected.length,
+		toolCount: connected.reduce((total, server) => total + Math.max(0, Number(server.toolCount) || 0), 0)
+	};
+}
 //#endregion
 //#region src/utils/usage/debug-timing.ts
 const MIN_STREAM_MS_FOR_TPS = 50;
@@ -504916,6 +505000,7 @@ var SessionEventHandler = class {
 	renderedMcpServerStatusKeys = /* @__PURE__ */ new Map();
 	mcpServerStatusSpinners = /* @__PURE__ */ new Map();
 	mcpServers = /* @__PURE__ */ new Map();
+	mcpInventoryLogged = false;
 	goalCompletionAwaitingClear = false;
 	goalCompletionTurnEnded = false;
 	currentTurnHasAssistantText = false;
@@ -504935,6 +505020,7 @@ var SessionEventHandler = class {
 		this.renderedPluginCommandActivationIds.clear();
 		this.renderedMcpServerStatusKeys.clear();
 		this.mcpServers.clear();
+		this.mcpInventoryLogged = false;
 		this.goalCompletionAwaitingClear = false;
 		this.goalCompletionTurnEnded = false;
 		this.currentTurnHasAssistantText = false;
@@ -504986,6 +505072,7 @@ var SessionEventHandler = class {
 		}
 		if (host.session !== session || host.state.appState.sessionId !== session.id) return;
 		const startupServers = servers.filter((server) => !isManagedTelegramMissingTokenFailure(server));
+		this.logMcpInventoryIfReady(startupServers);
 		const visible = selectMcpStartupStatusRows(startupServers);
 		const visibleNames = new Set(visible.map((server) => server.name));
 		for (const server of visible) {
@@ -505656,6 +505743,7 @@ var SessionEventHandler = class {
 		this.mcpServers.set(server.name, server);
 		const summary = formatMcpStartupStatusSummary([...this.mcpServers.values()]);
 		this.host.setAppState({ mcpServersSummary: summary || null });
+		this.logMcpInventoryIfReady([...this.mcpServers.values()]);
 		switch (server.status) {
 			case "connected": {
 				const tools = uiText(server.toolCount === 1 ? "sessionEvent.mcp.tool.one" : "sessionEvent.mcp.tool.other", { count: server.toolCount });
@@ -505688,6 +505776,12 @@ var SessionEventHandler = class {
 				return;
 		}
 	}
+	logMcpInventoryIfReady(servers) {
+		if (this.mcpInventoryLogged || servers.some((server) => server.status === "pending")) return;
+		const inventory = mcpStartupInventory(servers);
+		log.info("mcp startup inventory", inventory);
+		this.mcpInventoryLogged = true;
+	}
 	showMcpServerStatusSpinner(name) {
 		const { state } = this.host;
 		const label = uiText("sessionEvent.mcp.connecting", { name });
@@ -507601,7 +507695,7 @@ function formatGoalBadge(goal, colors, wallClockMs) {
 	const label = `${uiText(`goal.panel.status.${goal.status}`)} · ${formatBadgeElapsed(wallClockMs ?? goal.wallClockMs)} · ${turns}`;
 	return chalk.hex(colors.textMuted)(`[${uiText("footer.goal.label")} `) + chalk.hex(dotColor)("●") + chalk.hex(colors.textMuted)(` ${label}]`);
 }
-function formatLoopBadge(loop, colors, nowMs = Date.now()) {
+function formatLoopChatIndicator(loop, colors, nowMs = Date.now()) {
 	if (loop === null || loop === void 0 || loop.status !== "active" || !Number.isFinite(loop.nextFireAt)) return null;
 	const remainingMs = Math.max(0, loop.nextFireAt - nowMs);
 	let value;
@@ -507623,7 +507717,7 @@ function formatLoopBadge(loop, colors, nowMs = Date.now()) {
 		numeric: "always",
 		style: "short"
 	}).format(value, unit);
-	return chalk.hex(colors.textMuted)(`[/loop · ${relative}]`);
+	return chalk.hex(colors.primary)("\u25cf") + chalk.hex(colors.textMuted)(` Loop ${relative}`);
 }
 function formatBadgeElapsed(ms) {
 	const totalSeconds = Math.round(ms / 1e3);
@@ -507794,6 +507888,41 @@ function formatFooterGitBadge(status, colors) {
 	if (status.pullRequest === null) return base;
 	return `${base} ${chalk.hex(colors.primary)(formatPullRequestBadge(status.pullRequest, { linkPullRequest: true }))}`;
 }
+var LoopChatIndicatorComponent = class {
+	state;
+	onRefresh;
+	loopTimer = null;
+	constructor(state, onRefresh = () => {}) {
+		this.state = state;
+		this.onRefresh = onRefresh;
+		this.syncTimer(state.loop);
+	}
+	setState(state) {
+		this.state = state;
+		this.syncTimer(state.loop);
+	}
+	render(width) {
+		const indicator = formatLoopChatIndicator(this.state.loop, currentTheme.palette);
+		return indicator === null ? [] : [truncateToWidth(indicator, width, "…")];
+	}
+	syncTimer(loop) {
+		if (loop?.status === "active" && Number.isFinite(loop.nextFireAt)) {
+			if (this.loopTimer !== null) return;
+			this.loopTimer = setInterval(() => {
+				this.onRefresh();
+			}, GOAL_TIMER_INTERVAL_MS);
+			this.loopTimer.unref?.();
+			return;
+		}
+		this.dispose();
+	}
+	dispose() {
+		if (this.loopTimer !== null) {
+			clearInterval(this.loopTimer);
+			this.loopTimer = null;
+		}
+	}
+};
 var FooterComponent = class {
 	state;
 	onRefresh;
@@ -507803,7 +507932,6 @@ var FooterComponent = class {
 	goalSnapshotKey = null;
 	goalObservedAtMs = Date.now();
 	goalTimer = null;
-	loopTimer = null;
 	compactionAttemptStartedAtMs = null;
 	compactionEstimatedInputTokens;
 	compactionProgress;
@@ -507825,7 +507953,6 @@ var FooterComponent = class {
 		this.gitCache = createGitStatusCache(state.workDir, { onChange: this.onRefresh });
 		this.syncGoalClock(state.goal);
 		this.syncGoalTimer(state.goal);
-		this.syncLoopTimer(state.loop);
 		if (state.isCompacting) this.startCompaction();
 	}
 	setState(state) {
@@ -507835,7 +507962,6 @@ var FooterComponent = class {
 		}
 		this.syncGoalClock(state.goal);
 		this.syncGoalTimer(state.goal);
-		this.syncLoopTimer(state.loop);
 		this.state = state;
 		if (state.isCompacting && this.compactionAttemptStartedAtMs === null) this.startCompaction();
 		else if (!state.isCompacting) this.finishCompaction();
@@ -507902,13 +508028,13 @@ var FooterComponent = class {
 		if (modes.length > 0) left.push(modes.join(" "));
 		const goalBadge = formatGoalBadge(state.goal, colors, this.goalWallClockMs(state.goal));
 		if (goalBadge !== null) left.push(goalBadge);
-		const loopBadge = formatLoopBadge(state.loop, colors);
-		if (loopBadge !== null) left.push(loopBadge);
 		const model = modelDisplayName(state);
 		if (model) {
 			const sep = chalk.hex(colors.textMuted)(" · ");
 			const persona = personaName();
-			const brand = chalk.hex(colors.primary).bold("● BLUN") + sep + (persona !== void 0 ? chalk.hex(colors.text)(persona) + sep : "");
+			const profileLabel = process.env["BLUN_PROFILE"] ?? "default";
+			const profile = chalk.hex(colors.textDim)(profileLabel) + sep;
+			const brand = chalk.hex(colors.primary).bold("● BLUN") + sep + profile + (persona !== void 0 ? chalk.hex(colors.text)(persona) + sep : "");
 			const modelLabel = model;
 			const modeLabel = uiText(state.permissionMode === "yolo" ? "footer.mode.god" : state.permissionMode === "auto" ? "footer.mode.auto" : "footer.mode.manual");
 			const modeSuffix = sep + chalk.hex(colors.textDim)(uiText("footer.mode", { mode: modeLabel }));
@@ -507968,29 +508094,11 @@ var FooterComponent = class {
 			this.goalTimer = null;
 		}
 	}
-	syncLoopTimer(loop) {
-		if (loop?.status === "active" && Number.isFinite(loop.nextFireAt)) {
-			if (this.loopTimer !== null) return;
-			this.loopTimer = setInterval(() => {
-				this.onRefresh();
-			}, GOAL_TIMER_INTERVAL_MS);
-			this.loopTimer.unref?.();
-			return;
-		}
-		if (this.loopTimer !== null) {
-			clearInterval(this.loopTimer);
-			this.loopTimer = null;
-		}
-	}
 	dispose() {
 		if (this.goalTimer !== null) {
 			clearInterval(this.goalTimer);
 			this.goalTimer = null;
 		}
-		if (this.loopTimer !== null) {
-			clearInterval(this.loopTimer);
-			this.loopTimer = null;
-		}
 		this.finishCompaction();
 	}
 	goalWallClockMs(goal) {
@@ -511361,11 +511469,9 @@ var CustomEditor = class extends Editor {
 			}
 		}
 		if (matchesKey(normalized, Key.escape)) {
-			if (this.hasAutocompleteActivity()) {
-				this.cancelAutocompleteActivity();
-				return;
-			}
-			this.onEscape?.();
+			const autocompleteCancelled = this.hasAutocompleteActivity();
+			if (autocompleteCancelled) this.cancelAutocompleteActivity();
+			this.onEscape?.(autocompleteCancelled);
 			return;
 		}
 		if (matchesKey(normalized, Key.tab) && !this.isShowingAutocomplete()) return;
@@ -511736,6 +511842,11 @@ function createTUIState(options) {
 	const quotaWarningContainer = new GutterContainer(1, 1);
 	const quotaWarning = new ManagedQuotaWarningComponent();
 	quotaWarningContainer.addChild(quotaWarning);
+	const loopIndicatorContainer = new GutterContainer(1, 1);
+	const loopIndicator = new LoopChatIndicatorComponent(appState, () => {
+		ui.requestRender();
+	});
+	loopIndicatorContainer.addChild(loopIndicator);
 	return {
 		ui,
 		terminal,
@@ -511747,6 +511858,8 @@ function createTUIState(options) {
 		btwPanelContainer,
 		quotaWarningContainer,
 		quotaWarning,
+		loopIndicatorContainer,
+		loopIndicator,
 		editorContainer: new GutterContainer(1, 1),
 		editor: new GhostSuggestEditor(ui, {
 			disablePasteBurst: initialAppState.disablePasteBurst ?? DEFAULT_TUI_CONFIG.disablePasteBurst,
@@ -513624,6 +513737,7 @@ var BlunTUI = class {
 		this.editorKeyboard.dispose();
 		this.scrollbackController.dispose();
 		this.managedQuotaWarningController.dispose();
+		this.state.loopIndicator.dispose();
 		this.state.footer.dispose();
 		for (const dispose of this.reverseRpcDisposers) dispose();
 		this.reverseRpcDisposers.length = 0;
@@ -513704,6 +513818,7 @@ var BlunTUI = class {
 		ui.addChild(this.state.queueContainer);
 		ui.addChild(this.state.quotaWarningContainer);
 		ui.addChild(this.state.btwPanelContainer);
+		ui.addChild(this.state.loopIndicatorContainer);
 		ui.addChild(this.state.editorContainer);
 		if (ui instanceof BottomPinnedTUI) {
 			ui.pinFromIndex = ui.children.indexOf(this.state.quotaWarningContainer);
@@ -514686,6 +514801,7 @@ var BlunTUI = class {
 		const busyChanged = "streamingPhase" in effectivePatch || "isCompacting" in effectivePatch;
 		Object.assign(this.state.appState, effectivePatch);
 		if ("planMode" in effectivePatch) this.updateEditorBorderHighlight();
+		this.state.loopIndicator.setState(this.state.appState);
 		this.state.footer.setState(this.state.appState);
 		if ("sessionId" in effectivePatch || "managedQuotaWindows" in effectivePatch) this.managedQuotaWarningController.update(this.state.appState.sessionId, this.state.appState.managedQuotaWindows);
 		this.updateActivityPane();
@@ -515707,10 +515823,11 @@ var BlunTUI = class {
 		const startedAtMs = metrics.startedAtMs ?? this.activitySpinnerFallbackStartMs;
 		const elapsed = formatLiveElapsed(startedAtMs > 0 ? Math.max(0, Math.floor((Date.now() - startedAtMs) / 1e3)) : 0);
 		const tokens = formatLiveTokenCount(metrics.estimatedOutputTokens);
+		const startedAt = formatLiveStartedAt(startedAtMs);
 		return {
-			full: `${this.activitySpinnerBaseLabel} (${elapsed} · ↓ ~${tokens} ${uiText("blunTui.activity.tokens")})`,
-			compact: `${this.activitySpinnerBaseLabel} (${elapsed} · ↓${tokens})`,
-			minimal: `(${elapsed} · ↓${tokens})`
+			full: `${this.activitySpinnerBaseLabel} (${elapsed} · ↓ ~${tokens} ${uiText("blunTui.activity.tokens")} · ${startedAt})`,
+			compact: `${this.activitySpinnerBaseLabel} (${elapsed} · ↓${tokens} · ${startedAt})`,
+			minimal: `(${elapsed} · ${startedAt})`
 		};
 	}
 	ensureActivitySpinner(style, label = "", colorFn) {
@@ -516860,7 +516977,7 @@ async function appendRolloutDecisionLog(entry, filePath = getUpdateRolloutLogFil
 * creates the telemetry device_id before telemetry can emit first_launch.
 */
 function resolveUpdateDeviceId() {
-	return readBlunDeviceId(resolveBlunHome$1()) ?? randomUUID();
+	return readBlunDeviceId(resolveSharedBlunHome(resolveBlunHome$1())) ?? randomUUID();
 }
 /**
 * The experimental master switch opts a device out of staged rollouts: the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.58",
+  "version": "9.1.60",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {

package/standard-tools/manifest.json

@@ -11,8 +11,8 @@
         "command": "npx",
         "args": ["-y", "agent-browser@0.31.2", "mcp"],
         "enabled": false,
-        "startupTimeoutMs": 30000,
-        "toolTimeoutMs": 60000
+        "startupTimeoutMs": 120000,
+        "toolTimeoutMs": 120000
       }
     },
     "blun-language-guard": {
@@ -28,7 +28,7 @@
         "inheritEnv": false,
         "enabled": false,
         "startupTimeoutMs": 20000,
-        "toolTimeoutMs": 60000
+        "toolTimeoutMs": 120000
       }
     },
     "telegram": {