mixdog 1.4.2 → 1.4.3

package/src/tui/dist/index.mjs

@@ -23551,7 +23551,12 @@ async function runAsync(steps) {
 }
 function* readLockOwner(lockPath) {
   try {
-    const parts = String(yield ["read", lockPath]).trim().split(/\s+/);
+    const text = String(yield ["read", lockPath]).trim();
+    if (text.startsWith("{")) {
+      const legacyPid = Number(JSON.parse(text)?.pid);
+      return { pid: Number.isInteger(legacyPid) && legacyPid > 0 ? legacyPid : null, token: null };
+    }
+    const parts = text.split(/\s+/);
     const pid = Number.parseInt(parts[0], 10);
     return {
       pid: Number.isFinite(pid) && pid > 0 ? pid : null,
@@ -24031,6 +24036,19 @@ function settlesWithin(promise, ms) {
   });
   return Promise.race([promise.then(() => true), bound]).finally(() => clearTimeout(timer2));
 }
+async function readTarget(path2, read) {
+  const key = targetKey(path2);
+  let use = useOf(key);
+  while (use.renaming) use = await outwaitRename(key, use);
+  use.reads += 1;
+  try {
+    return await read();
+  } finally {
+    use.reads -= 1;
+    if (use.reads === 0) for (const done of use.drained.splice(0)) done();
+    forgetIfIdle(key, use);
+  }
+}
 async function renameOver(src, dst) {
   const key = targetKey(dst);
   let use = useOf(key);
@@ -24256,6 +24274,14 @@ function readContentOrNullSync(filePath) {
     throw err;
   }
 }
+async function readContentOrNullAsync(filePath) {
+  try {
+    return await readTarget(filePath, () => readFileAsync3(filePath));
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw err;
+  }
+}
 function reportDamaged(filePath, error, outcome) {
   const reason = String(error?.message || error).replace(/[\0-\x1f]/g, (c) => `\\x${c.charCodeAt(0).toString(16)}`);
   process.stderr.write(`[state] ${filePath} is damaged (${reason}); ${outcome}
@@ -24275,6 +24301,20 @@ function recoverDamagedSync(filePath, parse, opts) {
   reportDamaged(filePath, current.error, recoveredOutcome(aside, backup));
   return backup.state === "ok" ? backup : { state: "absent" };
 }
+async function recoverDamagedAsync(filePath, parse, opts) {
+  const current = parse(await readContentOrNullAsync(filePath));
+  if (current.state !== "damaged") return current;
+  const backup = opts.restoreBackup === false ? NO_BACKUP : parse(await readContentOrNullAsync(`${filePath}.bak`));
+  if (backup.state !== "ok" && opts.keepWithoutBackup) {
+    reportDamaged(filePath, current.error, KEPT_IN_PLACE);
+    return { state: "absent" };
+  }
+  const aside = quarantinePath(filePath);
+  await renameWithRetry(filePath, aside, opts);
+  if (backup.state === "ok") await publishFileAsync(filePath, backup.content, restoreOpts(opts));
+  reportDamaged(filePath, current.error, recoveredOutcome(aside, backup));
+  return backup.state === "ok" ? backup : { state: "absent" };
+}
 function readJsonStateSync(filePath, { validate: validate2, decode, fallback = null, ...opts } = {}) {
   const parse = stateParser(validate2, decode);
   const first = parse(readContentOrNullSync(filePath));
@@ -24290,6 +24330,13 @@ function readJsonStateSync(filePath, { validate: validate2, decode, fallback = n
   }
   return recovered.state === "ok" ? recovered.value : fallback;
 }
+async function readForMutationAsync(filePath, opts) {
+  const current = parseAnyJson(await readContentOrNullAsync(filePath));
+  if (current.state === "ok") return current.value;
+  if (current.state === "absent") return null;
+  const recovered = await recoverDamagedAsync(filePath, parseAnyJson, opts);
+  return recovered.state === "ok" ? recovered.value : null;
+}
 async function writeFileAtomicAsync(filePath, data, opts = {}) {
   assertTestSecretWriteSafe(filePath, opts);
   const run = () => publishFileAsync(filePath, data, opts);
@@ -24356,6 +24403,20 @@ function writeJsonAtomicAsync(filePath, value, opts = {}) {
   return writeFileAtomicAsync(filePath, `${JSON.stringify(value, null, opts.compact ? 0 : 2)}
 `, jsonBackupOpts(opts));
 }
+async function updateJsonAtomic(filePath, mutator, opts = {}) {
+  const { lock: _lock, ...writeOpts } = opts;
+  return withFileLock(
+    `${filePath}.lock`,
+    async () => {
+      const cur = await readForMutationAsync(filePath, writeOpts);
+      const next = mutator(cur);
+      if (next === void 0) return cur;
+      await writeJsonAtomicAsync(filePath, next, { ...writeOpts, lock: false });
+      return next;
+    },
+    opts
+  );
+}
 var _ioCeiling, _ioLimit, _ioActive, _ioFastStreak, _ioQueue, RETRY_CODES, RENAME_READ_WAIT_MS, targetUse, targetKey, FILE_FSYNC_TOLERATED, DIR_FSYNC_TOLERATED, keepsAsBackup, backupWriteOpts, jsonBackupOpts, quarantinePath, LOCK_BUSY_CODES, STATE_UNSUPPORTED, acceptAny, utf8Text, stateParser, restoreOpts, KEPT_IN_PLACE, NO_BACKUP, recoveredOutcome, parseAnyJson;
 var init_atomic_file = __esm({
   "src/runtime/shared/atomic-file.mjs"() {
@@ -36033,7 +36094,7 @@ var SLASH_COMMANDS = [
   {
     name: "goal",
     usage: "/goal",
-    params: "[objective --time 1h --time-mode max|status|pause|resume|edit|stop]",
+    params: "[objective --time 1h|status|pause|resume|edit|stop]",
     description: "Run and manage a durable session Goal"
   },
   {
@@ -41346,13 +41407,8 @@ function goalUnit(a) {
   const verbs = {
     status: ["Checking", "Checked"],
     create: ["Creating", "Created"],
-    pause: ["Pausing", "Paused"],
-    resume: ["Resuming", "Resumed"],
-    set_tasks: ["Planning", "Planned"],
-    update_tasks: ["Updating", "Updated"],
     complete: ["Completing", "Completed"],
-    block: ["Blocking", "Blocked"],
-    abandon: ["Abandoning", "Abandoned"]
+    block: ["Blocking", "Blocked"]
   }[action] || ["Updating", "Updated"];
   return unitDescriptor("Setup", {
     count: 1,
@@ -41442,6 +41498,12 @@ function agentUnit(a) {
   if (/^(?:status|read|list)$/.test(type)) {
     return unitDescriptor("Agent", { count, active: "Checking", done: "Checked", noun: "agent" });
   }
+  if (type === "cancel") {
+    return unitDescriptor("Agent", { count, active: "Cancelling", done: "Cancelled", noun: "agent", effect: true });
+  }
+  if (type === "close") {
+    return unitDescriptor("Agent", { count, active: "Ending", done: "Ended", noun: "agent", effect: true });
+  }
   return unitDescriptor("Agent", { count, noun: "agent" });
 }
 function taskUnit(a) {
@@ -41533,6 +41595,25 @@ function cwdUnit(a) {
     pluralNoun: "working directories"
   });
 }
+function sessionUnit(a) {
+  const action = String(a.action || a.type || "").toLowerCase();
+  if (action === "create") {
+    return unitDescriptor("Setup", { active: "Creating", done: "Created", noun: "session", effect: true });
+  }
+  if (action === "send") {
+    return unitDescriptor("Setup", { active: "Sending to", done: "Sent to", noun: "session", effect: true });
+  }
+  if (action === "cancel") {
+    return unitDescriptor("Setup", { active: "Cancelling", done: "Cancelled", noun: "session", effect: true });
+  }
+  if (action === "delete") {
+    return unitDescriptor("Setup", { active: "Deleting", done: "Deleted", noun: "session", effect: true });
+  }
+  if (/^(?:list|bots|read|suggest)$/.test(action)) {
+    return unitDescriptor("Setup", { active: "Checking", done: "Checked", noun: "session" });
+  }
+  return cwdUnit(a);
+}
 var TOOL_UNITS = /* @__PURE__ */ new Map([
   [
     "read",
@@ -41643,7 +41724,7 @@ var TOOL_UNITS = /* @__PURE__ */ new Map([
   ],
   ["cwd", cwdUnit],
   // legacy: old transcripts
-  ["session", cwdUnit]
+  ["session", sessionUnit]
 ]);
 function mcpUnit(name, a) {
   const mcp = parseMcpToolName(name);
@@ -50908,8 +50989,8 @@ function buildSpinnerMeta({
     thinkingParts,
     tokensText: tokens > 0 ? `${formatSpinnerTokens(tokens)} tokens` : "",
     // The count appears with the FIRST token (user: 30초가 아니라 바로).
-    // Elapsed was never gated, so the byline used to grow a second field
-    // mid-turn for no reason the reader could see; now both arrive together.
+    // Elapsed is never gated, so showing tokens with the first token keeps the
+    // byline from growing a second field mid-turn; both arrive together.
     showTokens: tokens > 0,
     thinkingText,
     thinkingActive: Boolean(thinking || Number(thinkingSince) > 0),
@@ -62370,6 +62451,7 @@ function createSettingsNavigation({ openers, openSettingsPicker, setSettingsProm
 import { readFileSync as readFileSync11, readdirSync as readdirSync2, statSync as statSync5, mkdirSync as mkdirSync5, existsSync as existsSync10, watch as fsWatch } from "node:fs";
 import { basename as basename6, join as join12, dirname as dirname9 } from "node:path";
 import { createRequire as createRequire3 } from "node:module";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
 // src/runtime/shared/object.mjs
 function hasOwn(value, key) {
@@ -62837,6 +62919,7 @@ var AGENT_PROVIDER_ENV_ALIASES = Object.freeze({
 
 // src/runtime/shared/config.mjs
 var _require = createRequire3(import.meta.url);
+var _keychain = _require("../../lib/keychain-cjs.cjs");
 var {
   getSecret: _getSecret,
   setSecret: _setSecret,
@@ -62848,8 +62931,9 @@ var {
   keychainStatus: _keychainStatus,
   retryKeychain: _retryKeychain,
   refreshKeychainStatus: _refreshKeychainStatus,
-  onKeychainRecovered: _onKeychainRecovered
-} = _require("../../lib/keychain-cjs.cjs");
+  onKeychainRecovered: _onKeychainRecovered,
+  prewarmSecrets: _prewarmSecrets
+} = _keychain;
 function configPath() {
   return join12(resolvePluginData(), "mixdog-config.json");
 }
@@ -62865,6 +62949,7 @@ function withFreshDefaultsVersion(fresh, root) {
   return root;
 }
 var _configReadCache = null;
+var _inNotificationPass = false;
 var CONFIG_READ_TTL_MS = (() => {
   const n = Number(process.env.MIXDOG_CONFIG_READ_TTL_MS);
   return Number.isFinite(n) && n >= 0 ? n : 0;
@@ -62872,6 +62957,9 @@ var CONFIG_READ_TTL_MS = (() => {
 function invalidateConfigReadCache() {
   _configReadCache = null;
 }
+function statKey(st) {
+  return `${st.mtimeMs}:${st.ctimeMs}:${st.size}:${st.ino}`;
+}
 function readConfigRawCached() {
   const now = Date.now();
   if (_configReadCache && _configReadCache.path !== configPath()) _configReadCache = null;
@@ -62881,7 +62969,7 @@ function readConfigRawCached() {
     }
     try {
       const st2 = statSync5(configPath());
-      if (st2.mtimeMs === _configReadCache.mtimeMs && st2.size === _configReadCache.size) {
+      if (statKey(st2) === _configReadCache.stat) {
         _configReadCache.atMs = now;
         return _configReadCache.raw;
       }
@@ -62912,7 +63000,7 @@ function readConfigRawCached() {
 `);
     throw err;
   }
-  _configReadCache = { raw, path: configPath(), mtimeMs: st.mtimeMs, size: st.size, atMs: now };
+  _configReadCache = { raw, path: configPath(), stat: statKey(st), atMs: now };
   return raw;
 }
 function canonicalizeStoredChannelsConfig(value = {}) {
@@ -62965,6 +63053,7 @@ function readConfigFile() {
     return parseJsonText(raw);
   } catch (err) {
     invalidateConfigReadCache();
+    if (_inNotificationPass) throw configMidWriteError(err);
     quarantineMalformedConfig(err);
     return null;
   }
@@ -63108,24 +63197,164 @@ function readAllForRmW() {
     if (!isPlainObject(parsed)) throw new SyntaxError("config root must be a JSON object");
     return parsed;
   } catch (parseErr) {
+    if (_inNotificationPass) throw configMidWriteError(parseErr);
     return restoreAllForRmWOrThrow(parseErr.message, quarantineMalformedConfig(parseErr));
   }
 }
+var SECRETS_MARKER_FILE = "mixdog-secrets-changed.json";
+var SECRET_DELETED_KEY = "#deleted";
+var _secretsSeen = null;
+var _secretsSeenPath = "";
+var _secretsMarkerStat = "";
+function secretsMarkerPath() {
+  return join12(dirname9(configPath()), SECRETS_MARKER_FILE);
+}
+function secretsMarkerStat(path2) {
+  try {
+    const stat2 = statSync5(path2);
+    return `${stat2.mtimeMs}:${stat2.size}:${stat2.ino}`;
+  } catch {
+    return "missing";
+  }
+}
+function readSecretsMarker() {
+  try {
+    const parsed = parseJsonText(readFileSync11(secretsMarkerPath(), "utf8"));
+    return isPlainObject(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function syncSecretsMarker() {
+  const path2 = secretsMarkerPath();
+  if (_secretsSeenPath !== path2) {
+    _secretsSeen = null;
+    _secretsSeenPath = path2;
+  }
+  _secretsMarkerStat = secretsMarkerStat(path2);
+  const marker = readSecretsMarker();
+  if (_secretsSeen === null) {
+    _secretsSeen = marker;
+    return [];
+  }
+  const seen = _secretsSeen;
+  const changed = [.../* @__PURE__ */ new Set([...Object.keys(seen), ...Object.keys(marker)])].filter(
+    (account) => seen[account] !== marker[account]
+  );
+  _secretsSeen = marker;
+  if (changed.includes(SECRET_DELETED_KEY)) _keychain.invalidateSecretCache?.();
+  else for (const account of changed) if (!account.startsWith("#")) _keychain.invalidateSecretCache?.(account);
+  return changed;
+}
+function syncSecretsMarkerIfMoved() {
+  if (_secretsSeen !== null && _secretsSeenPath === secretsMarkerPath()) {
+    if (secretsMarkerStat(_secretsSeenPath) === _secretsMarkerStat) return;
+  }
+  syncSecretsMarker();
+}
+var secretChangeToken = () => `${process.pid}:${Date.now()}:${randomUUID2()}`;
+function withSecretChange(marker, account, token, deleted) {
+  const next = { ...isPlainObject(marker) ? marker : {} };
+  if (deleted) {
+    delete next[account];
+    next[SECRET_DELETED_KEY] = token;
+  } else {
+    next[account] = token;
+  }
+  return next;
+}
+function beginSecretChange() {
+  syncSecretsMarker();
+  return secretChangeToken();
+}
+function finishSecretChange(account, token, deleted) {
+  _secretsSeen = withSecretChange(_secretsSeen, account, token, deleted);
+  _secretsMarkerStat = secretsMarkerStat(secretsMarkerPath());
+  notifyConfigChanged();
+}
+var secretMarkerFailure = (err) => process.stderr.write(`[config] secret change marker write failed: ${err?.message || err}
+`);
+async function publishSecretChangeAsync(account, deleted = false) {
+  const token = beginSecretChange();
+  try {
+    mkdirSync5(dirname9(secretsMarkerPath()), { recursive: true, mode: 448 });
+    await updateJsonAtomic(secretsMarkerPath(), (marker) => withSecretChange(marker, account, token, deleted), {
+      mode: 384
+    });
+  } catch (err) {
+    secretMarkerFailure(err);
+  }
+  finishSecretChange(account, token, deleted);
+}
 var CONFIG_CHANGE_DEBOUNCE_MS = 100;
+var WATCHED_FILES = /* @__PURE__ */ new Set(["mixdog-config.json", SECRETS_MARKER_FILE]);
 var _configChangeListeners = /* @__PURE__ */ new Set();
 var _configChangeTimer = null;
-function notifyConfigChanged() {
-  if (!_configChangeListeners.size) return;
-  if (_configChangeTimer) clearTimeout(_configChangeTimer);
-  _configChangeTimer = setTimeout(() => {
-    _configChangeTimer = null;
-    invalidateConfigReadCache();
+var _configChangeForced = false;
+var _watchedContent = null;
+function watchedContent() {
+  const dir = dirname9(configPath());
+  return [...WATCHED_FILES].map((file) => {
+    try {
+      return readFileSync11(join12(dir, file), "latin1");
+    } catch {
+      return null;
+    }
+  });
+}
+var CONFIG_SETTLE_RETRY_MS = 300;
+var _configSettleTimer = null;
+var _configSettleRetried = false;
+function configMidWriteError(parseErr) {
+  _configChangeForced = true;
+  if (!_configSettleRetried && !_configSettleTimer && _configChangeListeners.size) {
+    _configSettleTimer = setTimeout(() => {
+      _configSettleTimer = null;
+      _configSettleRetried = true;
+      void runConfigChangeListeners();
+    }, CONFIG_SETTLE_RETRY_MS);
+    _configSettleTimer.unref?.();
+  }
+  const error = new Error(
+    `[config] mixdog-config.json does not parse yet (${parseErr.message}); keeping the current config`
+  );
+  error.code = "ECONFIG_MID_WRITE";
+  return error;
+}
+async function runConfigChangeListeners() {
+  const forced = _configChangeForced;
+  _configChangeForced = false;
+  const content = watchedContent();
+  const last = _watchedContent;
+  if (!forced && Array.isArray(last) && last.every((value, index) => value === content[index])) return;
+  _watchedContent = content;
+  invalidateConfigReadCache();
+  if (syncSecretsMarker().length && process.platform === "linux") {
+    try {
+      await _prewarmSecrets?.();
+    } catch {
+    }
+  }
+  _inNotificationPass = true;
+  try {
     for (const listener of [..._configChangeListeners]) {
       try {
         listener();
       } catch {
       }
     }
+  } finally {
+    _inNotificationPass = false;
+  }
+}
+function notifyConfigChanged({ fromWatch = false } = {}) {
+  if (!_configChangeListeners.size) return;
+  if (!fromWatch) _configChangeForced = true;
+  _configSettleRetried = false;
+  if (_configChangeTimer) clearTimeout(_configChangeTimer);
+  _configChangeTimer = setTimeout(() => {
+    _configChangeTimer = null;
+    void runConfigChangeListeners();
   }, CONFIG_CHANGE_DEBOUNCE_MS);
   _configChangeTimer.unref?.();
 }
@@ -63190,6 +63419,21 @@ var SECRET_ACCOUNTS = Object.freeze({
   agentApiKey: (provider) => `agent.${provider}.apiKey`,
   openaiUsageSessionKey: "agent.openai.usageSessionKey"
 });
+var keychainSecretStore = Object.freeze({
+  getSecretAsync(account) {
+    syncSecretsMarkerIfMoved();
+    return _keychain.getSecretAsync(account);
+  },
+  invalidateSecretCache: (account) => _keychain.invalidateSecretCache?.(account),
+  async setSecretAsync(account, value, { announce = true } = {}) {
+    await _keychain.setSecretAsync(account, value);
+    if (announce) await publishSecretChangeAsync(account);
+  },
+  async deleteSecretAsync(account, { announce = true } = {}) {
+    await _keychain.deleteSecretAsync(account);
+    if (announce) await publishSecretChangeAsync(account, true);
+  }
+});
 
 // src/runtime/channels/lib/voice-setup.mjs
 var _voiceRuntimeFetcherPromise = null;
@@ -63704,6 +63948,11 @@ function createSettingsToggles({
 }
 
 // src/tui/app/settings-picker.mjs
+var heavyGates = /* @__PURE__ */ new WeakMap();
+var heavyGateOf = (cacheRef) => {
+  if (!heavyGates.has(cacheRef)) heavyGates.set(cacheRef, { running: false, queued: false, freshWrites: 0 });
+  return heavyGates.get(cacheRef);
+};
 function createSettingsPicker({
   store,
   state,
@@ -63712,6 +63961,7 @@ function createSettingsPicker({
   setSettingsPrompt,
   settingsHeavyCacheRef,
   settingsRequestRef,
+  settingsLiveRefreshRef,
   formatDuration: formatDuration2,
   displayModelName: displayModelName3,
   routeModelLabel: routeModelLabel2,
@@ -63730,10 +63980,18 @@ function createSettingsPicker({
     const own = surface.claim();
     const light = opts.light === true;
     if (!light && !own.paint(settingsHandoffPanel())) return;
-    const heavyCache = light ? settingsHeavyCacheRef.current : null;
+    const heavyCache = light && opts.heavy !== true ? settingsHeavyCacheRef.current : null;
+    const gate = heavyGateOf(settingsHeavyCacheRef);
+    const freshWritesAtStart = gate.freshWrites;
     const snapshot = await store.getSettingsSnapshot?.({ heavy: !heavyCache }) || {};
     const view = readSettingsView({ snapshot, heavyCache, state });
+    if (!isCurrentSettingsRequest(requestId)) {
+      if (!heavyCache && own.owns() && gate.freshWrites === freshWritesAtStart) gate.queued = true;
+      return;
+    }
+    if (!own.owns()) return;
     settingsHeavyCacheRef.current = { mcp: view.mcp, plugins: view.plugins, skills: view.skills };
+    if (!heavyCache) gate.freshWrites += 1;
     const toggles = createSettingsToggles({
       store,
       view,
@@ -63758,8 +64016,6 @@ function createSettingsPicker({
       routeModelLabel: routeModelLabel2,
       workflowDisplayName: workflowDisplayName2
     });
-    if (!isCurrentSettingsRequest(requestId)) return;
-    if (!own.owns()) return;
     setProviderPrompt(null);
     setSettingsPrompt(null);
     own.paint({
@@ -63784,6 +64040,7 @@ function createSettingsPicker({
         own.close();
       }
     });
+    if (settingsLiveRefreshRef) settingsLiveRefreshRef.current = own.defer(() => refreshSettings({ heavy: true }));
   };
   const openSettingsPicker = async (opts = {}) => {
     const requestId = nextSettingsRequest();
@@ -63793,8 +64050,23 @@ function createSettingsPicker({
       store.pushNotice(`settings unavailable: ${error?.message || error}`, "error");
     }
   };
-  const refreshSettings = () => {
-    void openSettingsPicker({ light: true });
+  const refreshHeavy = () => {
+    const gate = heavyGateOf(settingsHeavyCacheRef);
+    if (gate.running) {
+      gate.queued = true;
+      return;
+    }
+    gate.running = true;
+    void openSettingsPicker({ light: true, heavy: true }).finally(() => {
+      gate.running = false;
+      if (!gate.queued) return;
+      gate.queued = false;
+      settingsLiveRefreshRef?.current?.();
+    });
+  };
+  const refreshSettings = ({ heavy = false } = {}) => {
+    if (heavy) refreshHeavy();
+    else void openSettingsPicker({ light: true });
   };
   const navigation = createSettingsNavigation({ openers, openSettingsPicker, setSettingsPrompt });
   return { openSettingsPicker };
@@ -64104,7 +64376,7 @@ var sessionCommands = {
         store.pushNotice("Goal is unavailable.", "warn");
         return;
       }
-      store.pushNotice(result.message || "Goal updated.", "info");
+      store.pushNotice(result.message || "Goal updated.", result.ok === false ? "warn" : "info");
     }).catch((error) => store.pushNotice(`Goal failed: ${error?.message || error}`, "error"));
     return true;
   },
@@ -64298,6 +64570,7 @@ function createAppPickers({
   onboardingPrefetchSeqRef,
   settingsHeavyCacheRef,
   settingsRequestRef,
+  settingsLiveRefreshRef,
   livePickerRef,
   disabledSkills,
   setDisabledSkills,
@@ -64418,6 +64691,7 @@ function createAppPickers({
     setSettingsPrompt,
     settingsHeavyCacheRef,
     settingsRequestRef,
+    settingsLiveRefreshRef,
     formatDuration,
     displayModelName,
     routeModelLabel,
@@ -64903,15 +65177,15 @@ import { join as join16 } from "node:path";
 import { Worker as Worker2 } from "node:worker_threads";
 
 // src/tui/session/transcript-spill/spill-dir.mjs
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import { mkdtempSync, readdirSync as readdirSync5, readFileSync as readFileSync14, rmSync as rmSync5, statSync as statSync7, writeFileSync as writeFileSync4 } from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import { join as join15 } from "node:path";
 var STALE_MS = 24 * 60 * 60 * 1e3;
-var PROCESS_NONCE = randomUUID2();
+var PROCESS_NONCE = randomUUID3();
 
 // src/tui/session/transcript-spill/spill-writer.mjs
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import { mkdirSync as mkdirSync8 } from "node:fs";
 import { dirname as dirname11 } from "node:path";
 
@@ -66506,6 +66780,10 @@ function App2({ store, initialStatusLine = "", forceOnboarding = false, onboardi
   const { btwPanel, btw } = useBtwPanel({ store, sessionId: state.sessionId });
   const settingsHeavyCacheRef = useRef33(null);
   const settingsRequestRef = useRef33(0);
+  const settingsLiveRefreshRef = useRef33(null);
+  useEffect36(() => {
+    if (state.setupChanged) settingsLiveRefreshRef.current?.();
+  }, [state.setupChanged]);
   const [providerPrompt, setProviderPrompt] = useState26(null);
   const oauthSubmitRef = useRef33(false);
   const [settingsPrompt, setSettingsPrompt] = useState26(null);
@@ -66617,6 +66895,7 @@ function App2({ store, initialStatusLine = "", forceOnboarding = false, onboardi
     onboardingPrefetchSeqRef,
     settingsHeavyCacheRef,
     settingsRequestRef,
+    settingsLiveRefreshRef,
     livePickerRef,
     disabledSkills,
     setDisabledSkills,

package/src/tui/markdown/render-ansi.mjs

@@ -33,7 +33,7 @@ const MD_SYNTAX_RE = /[#*`|[>\-_~]|\n\n|(?:^|\n)\d+[.)] |(?:^|\n)\+ |(?:^|\n)={2
 
 // GFM strikethrough, pair-only. marked's default `del` also accepts a SINGLE
 // tilde, which turns approximation prose ("~100", "1~2개") into struck text —
-// the reason this tokenizer used to be disabled outright. Requiring `~~` keeps
+// so the default tokenizer cannot be used as is. Requiring `~~` keeps
 // real strikethrough working and lockstep with the desktop pipeline
 // (remark-gfm singleTilde:false).
 const DEL_RE = /^~~(?=[^\s~])([\s\S]*?[^\s~])~~(?!~)/;

package/src/tui/session/agent-job-feed/notification-router.mjs

@@ -2,6 +2,10 @@ import { parseAgentJob } from '../agent-envelope.mjs';
 import { notificationQueueKey, resolveTuiRuntimeNotificationDelivery } from '../notification-plan.mjs';
 import { isTerminalExecutionStatus } from './agent-status-refresh.mjs';
 
+// The runtime's setup-changed action after an empty session's settings
+// reconcile (session-runtime/boot/tools.mjs CONTEXT_STATUS_REFRESHED_ACTION).
+const CONTEXT_STATUS_REFRESHED = 'context_status_refreshed';
+
 // Routes one runtime notification by its delivery plan: UI-only kinds patch
 // the store or raise a notice, execution envelopes go through the execution
 // delivery, everything else becomes a model-visible task notification.
@@ -13,6 +17,7 @@ export function createNotificationRouter({
   statusRefresh,
   executionDelivery,
   modelNotification,
+  refreshContextStats = null,
   getAdmission = () => 'open',
 }) {
   let uiOpenSeq = 0;
@@ -20,6 +25,11 @@ export function createNotificationRouter({
   const uiActions = {
     'setup-ui': (delivery) => set({ setupUiRequest: { id: delivery.id, at: Date.now() } }),
     'setup-changed': (delivery) => {
+      // An empty session took moved settings: the context gauge re-reads.
+      if (delivery.setupAction === CONTEXT_STATUS_REFRESHED) {
+        refreshContextStats?.();
+        return;
+      }
       // Monotonic like ui-open: consecutive changes by the same action must
       // each refresh the attached surfaces.
       setupChangeSeq += 1;

package/src/tui/session/agent-job-feed.mjs

@@ -37,6 +37,7 @@ export function createAgentJobFeed({
   displayedExecutionNotificationKeys,
   itemIndexById,
   pushNotice,
+  refreshContextStats = null,
   now = () => Date.now(),
   executionResumeTombstoneTtlMs = 30_000,
   executionResumeTombstoneLimit = 128,
@@ -79,6 +80,7 @@ export function createAgentJobFeed({
     statusRefresh,
     executionDelivery,
     modelNotification,
+    refreshContextStats,
     getAdmission,
   });
 

package/src/tui/session/context-state.mjs

@@ -7,6 +7,7 @@
  */
 import { contextMeasurementStats } from '../../runtime/shared/context-measurement.mjs';
 import { goalStateSnapshot } from '../../runtime/agent/orchestrator/runtime-core/goal-state.mjs';
+import { todoSnapshot } from '../../runtime/agent/orchestrator/runtime-core/todo-list.mjs';
 
 export function createContextState({
   runtime,
@@ -92,6 +93,8 @@ export function createContextState({
     // The daemon-queued quota resume of this session id (identity-stable while
     // unchanged), so a resume or session switch republishes it with the route.
     quotaResume: typeof getQuotaResume === 'function' ? getQuotaResume() : null,
+    // The session's own step list (identity-stable while unchanged); null when empty.
+    todo: todoSnapshot(runtime.session),
   });
 
   const routeState = () => {

package/src/tui/session/quota-resume.mjs

@@ -57,7 +57,7 @@ export function latestQuotaFailure(items) {
 
 /** The turn key of the failed turndone that ends the transcript, when no
  *  later turn has begun; '' otherwise. */
-export function latestFailedTurnKey(items) {
+function latestFailedTurnKey(items) {
   const transcript = Array.isArray(items) ? items : [];
   for (let index = transcript.length - 1; index >= 0; index -= 1) {
     const item = transcript[index];

package/src/tui/session/session-api/lifecycle/dispose.mjs

@@ -34,6 +34,7 @@ export function createDisposeAction(bag, { oauthFlows }) {
         'unsubscribeCompletionWakeGate',
         'unsubscribeGitHeadWatch',
         'unsubscribeWorktreeSetup',
+        'unsubscribeTodo',
       ]) {
         try {
           lifecycle[key]?.();