mixdog 0.9.41 → 0.9.43

package/src/standalone/agent-tool.mjs

@@ -90,6 +90,8 @@ const DEFAULT_SPAWN_PREP_TIMEOUT_MS = envTimeoutMs('MIXDOG_AGENT_SPAWN_PREP_TIME
 // startDeferredSpawnJob) so the agent tool call itself still returns task_id
 // immediately.
 const SPAWN_STAGGER_MS = envTimeoutMs('MIXDOG_SPAWN_STAGGER_MS', 0);
+const TAG_TOMBSTONE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const MAX_TAG_TOMBSTONES = 500;
 let lastSpawnStartAt = 0;
 async function waitForSpawnStagger() {
   if (SPAWN_STAGGER_MS <= 0) return;
@@ -177,13 +179,48 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       .filter(keepWorkerRow);
   }
 
+  function normalizeTagTombstones(value, { cap = true, priorityKeys = null } = {}) {
+    const source = Array.isArray(value?.tombstones)
+      ? value.tombstones
+      : (value?.tombstones && typeof value.tombstones === 'object'
+        ? Object.values(value.tombstones)
+        : []);
+    const now = Date.now();
+    const cutoff = now - TAG_TOMBSTONE_TTL_MS;
+    const rows = source
+      .filter((row) => row && typeof row === 'object')
+      .map((row) => {
+        const parsedReapedAt = Date.parse(clean(row.reapedAt)) || 0;
+        return {
+          tag: clean(row.tag),
+          agent: clean(row.agent) || null,
+          cwd: clean(row.cwd) || null,
+          clientHostPid: positiveInt(row.clientHostPid),
+          // A future clock must not outrank tombstones created by this process.
+          reapedAt: parsedReapedAt ? new Date(Math.min(parsedReapedAt, now)).toISOString() : null,
+        };
+      })
+      .filter((row) => row.tag && row.reapedAt && (Date.parse(row.reapedAt) || 0) >= cutoff)
+      .sort((a, b) => {
+        const aPriority = priorityKeys?.has(tagTombstoneKey(a)) ? 1 : 0;
+        const bPriority = priorityKeys?.has(tagTombstoneKey(b)) ? 1 : 0;
+        return bPriority - aPriority
+          || (Date.parse(b.reapedAt) || 0) - (Date.parse(a.reapedAt) || 0);
+      });
+    return cap ? rows.slice(0, MAX_TAG_TOMBSTONES) : rows;
+  }
+
+  function tagTombstoneKey(row = {}) {
+    return `${positiveInt(row.clientHostPid) || 0}\0${clean(row.tag)}`;
+  }
+
   // Mtime-keyed parse cache for the worker index. A single spawn calls
   // refreshTagsFromSessions()/resolveTag()/nextTag() which each re-read and
   // re-JSON.parse this file; across a parallel fanout that is O(spawns^2)
   // synchronous reads of the same bytes on the event loop. Cache the parsed,
   // normalized rows and reuse them while the file mtime+size is unchanged.
   // Writes bump _workerRowsCacheDirty so the very next read re-parses.
-  let _workerRowsCache = null; // { mtimeMs, size, rows }
+  let _workerRowsCache = null; // { mtimeMs, size, rows, tombstones }
   let _workerRowsCacheDirty = true;
   function invalidateWorkerRowsCache() {
     _workerRowsCacheDirty = true;
@@ -200,15 +237,26 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
       return _workerRowsCache.rows;
     }
     let rows = [];
+    let tombstones = [];
     try {
-      rows = normalizeWorkerRows(JSON.parse(readFileSync(file, 'utf8')));
+      const parsed = JSON.parse(readFileSync(file, 'utf8'));
+      rows = normalizeWorkerRows(parsed);
+      tombstones = normalizeTagTombstones(parsed);
     } catch {
       rows = [];
+      tombstones = [];
     }
-    _workerRowsCache = { mtimeMs: st.mtimeMs, size: st.size, rows };
+    _workerRowsCache = { mtimeMs: st.mtimeMs, size: st.size, rows, tombstones };
     _workerRowsCacheDirty = false;
     return rows;
   }
+  function readAllTagTombstones() {
+    readAllWorkerRows();
+    return _workerRowsCache?.tombstones || [];
+  }
+  function readTagTombstones(context = {}) {
+    return readAllTagTombstones().filter((row) => rowMatchesContext(row, context));
+  }
   function readWorkerRows(context = {}) {
     const rows = readAllWorkerRows();
     if (rows.length === 0) return rows;
@@ -229,13 +277,25 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
           const key = workerRowKey(row);
           if (key) byKey.set(key, row);
         }
-        mutator(byKey);
+        const tombstonesByKey = new Map();
+        for (const row of normalizeTagTombstones(cur, { cap: false })) {
+          tombstonesByKey.set(tagTombstoneKey(row), row);
+        }
+        const priorityTombstoneKeys = new Set();
+        mutator(byKey, tombstonesByKey, priorityTombstoneKeys);
         const workers = {};
         for (const row of [...byKey.values()].filter(keepWorkerRow)) {
           const key = workerRowKey(row);
           if (key) workers[key] = row;
         }
-        return { version: 1, updatedAt: new Date().toISOString(), workers };
+        const tombstones = {};
+        for (const row of normalizeTagTombstones(
+          { tombstones: [...tombstonesByKey.values()] },
+          { priorityKeys: priorityTombstoneKeys },
+        )) {
+          tombstones[tagTombstoneKey(row)] = row;
+        }
+        return { version: 2, updatedAt: new Date().toISOString(), workers, tombstones };
       }, { lock: true });
       // This process just rewrote the index; force the next read to re-parse
       // even if the new mtime/size happen to collide with the cached stat.
@@ -504,6 +564,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
   }
 
   function refreshTagsFromSessions({ scanSessions = false, context = {} } = {}) {
+    transitionStaleNonterminalRows(context);
     const indexedRows = refreshTagsFromIndex(context);
     const indexedKeys = new Set(indexedRows.map((row) => `${row.tag}\0${row.sessionId}`));
     for (const [tag, sessionId] of [...tags.entries()]) {
@@ -555,6 +616,50 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     if (id) removeWorkerRow({ sessionId: id });
   }
 
+  function tombstoneTerminalSession(tag, sessionId, session = null) {
+    const value = clean(tag);
+    const id = clean(sessionId);
+    if (!value || !id) {
+      forgetTerminalSession(value, id);
+      return;
+    }
+    if (tags.get(value) === id) {
+      tags.delete(value);
+      tagAgents.delete(value);
+      tagCwds.delete(value);
+    }
+    const tombstone = {
+      tag: value,
+      agent: clean(session?.agent) || null,
+      cwd: clean(session?.cwd) || null,
+      clientHostPid: positiveInt(session?.clientHostPid),
+      reapedAt: new Date().toISOString(),
+    };
+    flushWorkerIndexMutations();
+    writeWorkerRows((byKey, tombstonesByKey, priorityTombstoneKeys) => {
+      for (const [key, row] of [...byKey.entries()]) {
+        if (clean(row.sessionId) === id) byKey.delete(key);
+      }
+      const tombstoneKey = tagTombstoneKey(tombstone);
+      tombstonesByKey.set(tombstoneKey, tombstone);
+      priorityTombstoneKeys.add(tombstoneKey);
+    });
+  }
+
+  function tagTombstoneForTag(tag, context = {}) {
+    const value = clean(tag);
+    if (!value || value.startsWith('sess_')) return null;
+    return readTagTombstones(context).find((row) => row.tag === value) || null;
+  }
+
+  function consumeTagTombstone(tombstone) {
+    if (!tombstone?.tag) return false;
+    const key = tagTombstoneKey(tombstone);
+    flushWorkerIndexMutations();
+    writeWorkerRows((_byKey, tombstonesByKey) => tombstonesByKey.delete(key));
+    return true;
+  }
+
   function cancelReap(sessionId) {
     const handle = reapTimers.get(sessionId);
     if (!handle) return false;
@@ -571,9 +676,10 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     if (reapMs == null) return;
     const handle = setTimeout(() => {
       reapTimers.delete(sessionId);
+      const session = getLiveSession(sessionId);
       try { mgr.hideSessionFromList?.(sessionId); } catch {}
       const tag = tagForSession(sessionId);
-      forgetTerminalSession(tag, sessionId);
+      tombstoneTerminalSession(tag, sessionId, session);
       clearAgentStatuslineRoute(sessionId);
       try { mgr.closeSession(sessionId, 'terminal-reap'); } catch {}
     }, reapMs);
@@ -581,6 +687,47 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     reapTimers.set(sessionId, handle);
   }
 
+  function transitionStaleNonterminalRows(context = {}) {
+    const staleRows = readWorkerRows(context).filter((row) => {
+      if (isTerminalWorkerStatus(row.status || row.stage)) return false;
+      if (getLiveSession(clean(row.sessionId))) return false;
+      const rowTime = workerRowTime(row);
+      const reapMs = resolveAgentTerminalReapMs(cfgMod.loadConfig(), row.provider);
+      // A row with no timestamp has no usable heartbeat at all. Explicitly
+      // disabled terminal reaping still gets the tombstone TTL as a finite
+      // stale-heartbeat bound, so malformed/running index rows cannot block a
+      // tag forever.
+      return rowTime <= 0 || Date.now() - rowTime >= (reapMs ?? TAG_TOMBSTONE_TTL_MS);
+    });
+    if (staleRows.length === 0) return false;
+    flushWorkerIndexMutations();
+    const nowIso = new Date().toISOString();
+    writeWorkerRows((byKey, tombstonesByKey, priorityTombstoneKeys) => {
+      for (const row of staleRows) {
+        const sessionId = clean(row.sessionId);
+        for (const [key, candidate] of [...byKey.entries()]) {
+          if (clean(candidate.sessionId) === sessionId) byKey.delete(key);
+        }
+        const tombstone = {
+          tag: clean(row.tag),
+          agent: clean(row.agent) || null,
+          cwd: clean(row.cwd) || null,
+          clientHostPid: positiveInt(row.clientHostPid),
+          reapedAt: nowIso,
+        };
+        const tombstoneKey = tagTombstoneKey(tombstone);
+        tombstonesByKey.set(tombstoneKey, tombstone);
+        priorityTombstoneKeys.add(tombstoneKey);
+        if (tags.get(tombstone.tag) === sessionId) {
+          tags.delete(tombstone.tag);
+          tagAgents.delete(tombstone.tag);
+          tagCwds.delete(tombstone.tag);
+        }
+      }
+    });
+    return true;
+  }
+
   function isSessionBusy(sessionId) {
     const runtime = mgr.getSessionRuntime?.(sessionId);
     if (runtime?.controller?.signal && !runtime.controller.signal.aborted) return true;
@@ -1522,7 +1669,10 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
     tagAgents.clear();
     tagCwds.clear();
     flushWorkerIndexMutations();
-    writeWorkerRows((byKey) => byKey.clear());
+    writeWorkerRows((byKey, tombstonesByKey) => {
+      byKey.clear();
+      tombstonesByKey.clear();
+    });
     return { closed, failed };
   }
 
@@ -1589,25 +1739,26 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
           if (!fallbackTag || fallbackTag.startsWith('sess_') || !isDeadTarget) throw err;
           const prompt = clean(args.message || args.prompt);
           if (!prompt) throw err;
-          // A retained row is proof that this terminal owned the tag. Once the
-          // reaper removes that row, an explicit agent plus usable cwd is enough
-          // to cold-spawn a replacement without retaining closed sessions.
+          // A retained row or reap tombstone proves that this terminal owned
+          // the tag. Unknown tags stay errors even when the caller supplies an
+          // agent/cwd: typo absorption requires persisted same-tag evidence.
+          // Absorption identity is always terminal-local, even when live
+          // resolution was explicitly requested across all terminals.
+          const ownershipContext = context;
           let inheritedRow = null;
           try {
-            inheritedRow = readWorkerRows(scopedContext).find((row) => clean(row.tag) === fallbackTag) || null;
+            inheritedRow = readWorkerRows(ownershipContext).find((row) => clean(row.tag) === fallbackTag) || null;
           } catch { inheritedRow = null; }
-          // Never use explicit cold-spawn identity to take over a tag retained
-          // by another terminal. In-memory maps can contain peer entries, so
-          // inspect the persisted index directly.
-          const peerRow = readAllWorkerRows().find((row) => (
-            clean(row.tag) === fallbackTag && !rowMatchesContext(row, scopedContext)
-          ));
+          const inheritedTombstone = tagTombstoneForTag(fallbackTag, ownershipContext);
           const explicitAgent = clean(args.agent);
-          const explicitCwd = clean(args.cwd) || clean(callerCwd);
-          if (peerRow || (!inheritedRow && (!explicitAgent || !explicitCwd))) throw err;
+          // A local proof wins even if another terminal also owns this tag.
+          // With no local proof, foreign rows/tombstones and unknown tags are
+          // both non-absorbable and retain the original not-found error.
+          if (!inheritedRow && !inheritedTombstone) throw err;
           const inheritedSessionId = clean(inheritedRow?.sessionId);
-          const inheritedAgent = explicitAgent || clean(inheritedRow?.agent) || 'worker';
-          const inheritedCwd = clean(args.cwd) || clean(inheritedRow?.cwd) || clean(callerCwd);
+          const inheritedAgent = explicitAgent || clean(inheritedRow?.agent) || clean(inheritedTombstone?.agent);
+          const inheritedCwd = clean(args.cwd) || clean(inheritedRow?.cwd) || clean(inheritedTombstone?.cwd) || clean(callerCwd);
+          if (!inheritedAgent || !inheritedCwd) throw err;
           // Drop this terminal's in-memory trace and remove ONLY the persisted
           // row matching inheritedRow.sessionId. Do NOT call forgetTag here: it
           // does a tag-wide removeWorkerRow({tag,sessionId}) (L556) whose OR
@@ -1618,6 +1769,7 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
             try { tags.delete(fallbackTag); tagAgents.delete(fallbackTag); tagCwds.delete(fallbackTag); } catch {}
           }
           if (inheritedSessionId) { try { removeWorkerRow({ sessionId: inheritedSessionId }); } catch {} }
+          if (inheritedTombstone) consumeTagTombstone(inheritedTombstone);
           const spawnArgs = {
             ...args,
             type: 'spawn',
@@ -1638,6 +1790,8 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
         //   3) lingering terminal trace -> reap trace and fresh spawn under same tag
         //   4) genuinely new tag -> fresh deferred spawn
         const explicitTag = clean(args.tag);
+        let respawned = false;
+        let spawnArgs = args;
         if (explicitTag) {
           // Resolve a LIVE same-tag session in this terminal (busy or idle).
           let liveSessionId = null;
@@ -1658,9 +1812,35 @@ export function createStandaloneAgent({ cfgMod, reg, mgr, dataDir, cwd: defaultC
           }
           if (hasTerminalTrace(explicitTag, scopedContext)) {
             reapTerminalTraceForTag(explicitTag, scopedContext);
+            respawned = true;
+          } else {
+            // Tombstone inheritance never honors allTerminals/global scope.
+            const tombstone = tagTombstoneForTag(explicitTag, context);
+            if (tombstone) {
+              consumeTagTombstone(tombstone);
+              spawnArgs = {
+                ...args,
+                agent: clean(args.agent) || clean(tombstone.agent),
+                ...(clean(args.cwd) || !clean(tombstone.cwd) ? {} : { cwd: tombstone.cwd }),
+              };
+              respawned = true;
+            } else {
+              const foreignTombstone = readAllTagTombstones().find((row) => (
+                clean(row.tag) === explicitTag && !rowMatchesContext(row, context)
+              ));
+              if (foreignTombstone) {
+                throw new Error(`agent spawn: tag "${explicitTag}" belongs to another terminal`);
+              }
+            }
           }
         }
-        const job = startDeferredSpawnJob(args, callerCwd, context, notifyContext);
+        const job = startDeferredSpawnJob(
+          spawnArgs,
+          callerCwd,
+          context,
+          notifyContext,
+          respawned ? { respawned: true } : {},
+        );
         return renderResult(renderJob(job, false));
       }
       throw new Error(`agent: unknown type "${type}"`);

package/src/tui/components/StatusLine.jsx

@@ -250,26 +250,6 @@ function localRunningWorkerCount(agentWorkers = [], agentJobs = []) {
   return seen.size;
 }
 
-function localRunningWorkerTags(agentWorkers = [], agentJobs = [], limit = 3) {
-  const tags = [];
-  const seen = new Set();
-  for (const worker of Array.isArray(agentWorkers) ? agentWorkers : []) {
-    const tag = String(worker?.tag || worker?.agent || worker?.name || '').trim();
-    if (!tag || isTerminalStatus(worker?.stage || worker?.status) || seen.has(tag)) continue;
-    seen.add(tag);
-    tags.push(tag);
-  }
-  for (const job of Array.isArray(agentJobs) ? agentJobs : []) {
-    if (!/running/i.test(String(job?.status || job?.stage || ''))) continue;
-    const tag = String(job?.tag || job?.agent || job?.type || job?.task_id || job?.taskId || '').trim();
-    if (!tag || seen.has(tag)) continue;
-    seen.add(tag);
-    tags.push(tag);
-  }
-  if (tags.length <= limit) return tags.join(', ');
-  return `${tags.slice(0, limit).join(', ')}, +${tags.length - limit}`;
-}
-
 function localTimeMs(value) {
   if (typeof value === 'number' && Number.isFinite(value) && value > 0) return value;
   const n = Date.parse(String(value || ''));
@@ -311,11 +291,9 @@ function localStatusLineL2({
   const runningCount = localRunningWorkerCount(agentWorkers, agentJobs);
   if (runningCount > 0) {
     const label = `Running ${runningCount} Agent${runningCount === 1 ? '' : 's'}`;
-    const tagSummary = localRunningWorkerTags(agentWorkers, agentJobs);
-    const tags = tagSummary ? ` ${SUBTLE}(${RESET}${STATUS}${tagSummary}${RESET}${SUBTLE})${RESET}` : '';
     const oldestStart = localOldestWorkerStartMs(agentWorkers, agentJobs);
     const elapsed = oldestStart > 0 ? localFormatElapsed(now - oldestStart) : '';
-    l2Parts.push(`${spin} ${STATUS}${label}${RESET}${tags}${elapsedSuffix(elapsed)}`);
+    l2Parts.push(`${spin} ${STATUS}${label}${RESET}${elapsedSuffix(elapsed)}`);
   }
   const tools = activeTools && typeof activeTools === 'object' ? activeTools : {};
   const exploreInfo = tools.explore || null;
@@ -369,9 +347,9 @@ function extractCachedShellSegments(cachedL2 = '', now = Date.now(), capturedAt
     // Start-anchored so only a REAL standalone shell segment matches. A visible
     // segment is `<spinner-glyph> Running N … [· elapsed]`, so allow the single
     // leading spinner token via `^(?:\S+\s+)?` then pin `Running N Shell(s)` to
-    // that position. An Agents segment is `<glyph> Running N Agents (tags) …` →
-    // `Shells?` cannot match `Agents`; a tag-injected `Running 3 Shells · 9s`
-    // sits AFTER `Running N Agents (` (not at the pinned start) → no false match.
+    // that position. An Agents segment is `<glyph> Running N Agents · …` →
+    // `Shells?` cannot match `Agents`; any shell-like text after the Agents label
+    // is not at the pinned start, so it cannot produce a false match.
     const m = /^(?:\S+\s+)?Running (\d+) Shells?\b(?:\s·\s(.+?))?\s*$/.exec(seg.trim());
     if (!m) continue;
     const n = Number(m[1]) || 0;

package/src/tui/dist/index.mjs

@@ -2896,7 +2896,7 @@ function toolWorkUnit(name, args = {}, category = "") {
     case "memory": {
       const action = String(a.action || "").toLowerCase();
       const op = String(a.op || "").toLowerCase();
-      const isMutation = op === "add" || op === "edit" || op === "delete" || op === "promote" || op === "dismiss" || action === "core" && !op;
+      const isMutation = op === "add" || op === "edit" || op === "delete" || op === "promote" || op === "dismiss";
       if (isMutation) return unitDescriptor("Memory", { count: queryCount(a, "entries", "items", "memories", "query", "text", "value") || 1, active: "Writing", done: "Wrote", noun: "memory item" });
       return unitDescriptor("Memory", { count: queryCount(a, "entries", "items", "memories", "query", "text", "value") || 1, active: "Checking", done: "Checked", noun: "memory item" });
     }
@@ -4023,25 +4023,6 @@ function localRunningWorkerCount(agentWorkers = [], agentJobs = []) {
   }
   return seen.size;
 }
-function localRunningWorkerTags(agentWorkers = [], agentJobs = [], limit = 3) {
-  const tags = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const worker of Array.isArray(agentWorkers) ? agentWorkers : []) {
-    const tag = String(worker?.tag || worker?.agent || worker?.name || "").trim();
-    if (!tag || isTerminalStatus(worker?.stage || worker?.status) || seen.has(tag)) continue;
-    seen.add(tag);
-    tags.push(tag);
-  }
-  for (const job of Array.isArray(agentJobs) ? agentJobs : []) {
-    if (!/running/i.test(String(job?.status || job?.stage || ""))) continue;
-    const tag = String(job?.tag || job?.agent || job?.type || job?.task_id || job?.taskId || "").trim();
-    if (!tag || seen.has(tag)) continue;
-    seen.add(tag);
-    tags.push(tag);
-  }
-  if (tags.length <= limit) return tags.join(", ");
-  return `${tags.slice(0, limit).join(", ")}, +${tags.length - limit}`;
-}
 function localTimeMs(value) {
   if (typeof value === "number" && Number.isFinite(value) && value > 0) return value;
   const n = Date.parse(String(value || ""));
@@ -4074,11 +4055,9 @@ function localStatusLineL2({
   const runningCount = localRunningWorkerCount(agentWorkers, agentJobs);
   if (runningCount > 0) {
     const label = `Running ${runningCount} Agent${runningCount === 1 ? "" : "s"}`;
-    const tagSummary = localRunningWorkerTags(agentWorkers, agentJobs);
-    const tags = tagSummary ? ` ${SUBTLE}(${RESET2}${STATUS}${tagSummary}${RESET2}${SUBTLE})${RESET2}` : "";
     const oldestStart = localOldestWorkerStartMs(agentWorkers, agentJobs);
     const elapsed = oldestStart > 0 ? localFormatElapsed(now - oldestStart) : "";
-    l2Parts.push(`${spin} ${STATUS}${label}${RESET2}${tags}${elapsedSuffix(elapsed)}`);
+    l2Parts.push(`${spin} ${STATUS}${label}${RESET2}${elapsedSuffix(elapsed)}`);
   }
   const tools = activeTools && typeof activeTools === "object" ? activeTools : {};
   const exploreInfo = tools.explore || null;
@@ -24054,6 +24033,7 @@ function createSessionFlow(bag) {
     pendingNotificationKeys,
     displayedExecutionNotificationKeys,
     clearExecutionDedupState,
+    clearToastTimers,
     getState,
     set,
     pushItem,
@@ -24356,7 +24336,14 @@ function createSessionFlow(bag) {
       useCompaction: true
     });
   }
-  async function performSessionClear({ verb, doneLabel, skipLabel, surface, useCompaction }) {
+  async function performSessionClear({
+    verb,
+    doneLabel,
+    skipLabel,
+    surface,
+    useCompaction,
+    compactTimeoutMs = AUTO_CLEAR_COMPACT_TIMEOUT_MS
+  }) {
     flags.autoClearRunning = true;
     const startedAt = Date.now();
     set({ commandBusy: true, commandStatus: { active: true, verb, startedAt, mode: "auto-clear" } });
@@ -24367,21 +24354,23 @@ function createSessionFlow(bag) {
         const compaction = runtime.getCompactionSettings();
         compactType = compaction.compactType || compaction.type || null;
       }
+      let clearResult;
       if (compactType) {
         const clearPromise = runtime.clear({ compactType, requireCompactSuccess: true });
         let timer2 = null;
         const timeout = new Promise((_, reject) => {
           timer2 = setTimeout(
-            () => reject(new Error(`compaction timed out after ${AUTO_CLEAR_COMPACT_TIMEOUT_MS}ms; auto-clear deferred to next idle`)),
-            AUTO_CLEAR_COMPACT_TIMEOUT_MS
+            () => reject(new Error(`compaction timed out after ${compactTimeoutMs}ms; auto-clear deferred to next idle`)),
+            compactTimeoutMs
           );
         });
         try {
-          await Promise.race([clearPromise, timeout]);
+          clearResult = await Promise.race([clearPromise, timeout]);
         } catch (raceError) {
           flags.autoClearInFlight = true;
           clearPromise.then(
-            () => {
+            (lateResult) => {
+              if (lateResult === false) return;
               if (getState().busy) {
                 flags.pendingClearedSessionUi = { doneLabel, surface };
               } else {
@@ -24399,7 +24388,10 @@ function createSessionFlow(bag) {
           if (timer2) clearTimeout(timer2);
         }
       } else {
-        await runtime.clear({});
+        clearResult = await runtime.clear({});
+      }
+      if (clearResult === false) {
+        throw new Error("runtime clear returned false");
       }
       applyClearedSessionUi(doneLabel);
       return true;
@@ -24441,6 +24433,8 @@ function createSessionFlow(bag) {
     return getState().stats;
   };
   const clearUiActivityBeforeContextSync = () => {
+    clearToastTimers();
+    resetAllStreamingMarkdownStablePrefixes();
     getState().items = replaceItems([]);
     getState().toasts = [];
     getState().queued = [];
@@ -24546,6 +24540,7 @@ function createRunTurn(bag) {
     set,
     pushItem,
     patchItem,
+    replaceItems,
     updateStreamingTail: updateStreamingTailFromStore,
     settleStreamingTail: settleStreamingTailFromStore,
     clearStreamingTail: clearStreamingTailFromStore,
@@ -24734,7 +24729,11 @@ function createRunTurn(bag) {
     let cancelled = false;
     let askResult = null;
     let turnFinishedNormally = false;
+    let transcriptCompactedThisTurn = false;
     const itemsAtTurnStart = getState().items.length;
+    const submittedIdSet = new Set(submittedIds.filter((id) => id != null));
+    const firstSubmittedIndex = getState().items.findIndex((item) => submittedIdSet.has(item?.id));
+    let currentTurnItemsStart = firstSubmittedIndex >= 0 ? firstSubmittedIndex : itemsAtTurnStart;
     const cardByCallId = /* @__PURE__ */ new Map();
     const toolCards = [];
     const toolGroups = /* @__PURE__ */ new Map();
@@ -25301,6 +25300,13 @@ function createRunTurn(bag) {
           if (!markTurnProgress("compact-event")) return;
           flushStreamBatch();
           clearAggregateContinuation();
+          const compactStatus = String(event?.status || "").toLowerCase();
+          if (!["failed", "skipped", "no_change"].includes(compactStatus)) {
+            const currentTurnItems = getState().items.slice(currentTurnItemsStart);
+            set({ items: replaceItems(currentTurnItems, { preserveStreamingTail: true }) });
+            currentTurnItemsStart = 0;
+            transcriptCompactedThisTurn = true;
+          }
           pushItem({
             kind: "statusdone",
             id: nextId2(),
@@ -25399,6 +25405,13 @@ function createRunTurn(bag) {
       } else {
         askResult = result;
         markPromptCommitted();
+        if (result?.terminationReason === "refusal") {
+          pushNotice(
+            "\uBAA8\uB378\uC774 \uC548\uC804 \uBD84\uB958\uAE30(refusal)\uB85C \uC751\uB2F5\uC744 \uAC70\uBD80\uD588\uC2B5\uB2C8\uB2E4 \u2014 \uB2E4\uC2DC \uC2DC\uB3C4\uD558\uAC70\uB098 \uBB38\uAD6C\uB97C \uBC14\uAFD4\uC8FC\uC138\uC694.",
+            "warn",
+            { transcript: true }
+          );
+        }
         flushToolResults(session?.messages || [], toolCards, cardByCallId, toolGroups, resultsDone, { finalize: true });
         finalizeToolHeaders();
         flushStreamBatch();
@@ -25464,7 +25477,7 @@ function createRunTurn(bag) {
             clearStreamingTail(currentAssistantId);
           }
         }
-        const producedTranscriptItem = getState().items.length + closingItems.length > itemsAtTurnStart;
+        const producedTranscriptItem = transcriptCompactedThisTurn || getState().items.length + closingItems.length > itemsAtTurnStart;
         const reclaimed = cancelled && flags.activePromptRestore?.reclaimed === true;
         flags.activePromptRestore = null;
         const elapsedMs = Date.now() - startedAt;
@@ -26667,6 +26680,9 @@ function createEngineApiA(bag) {
         syncContextStats({ allowEstimated: true });
         set({ ...routeState(), stats: { ...getState().stats } });
         if (result) {
+          if (!result.error && result.changed !== false) {
+            set({ items: replaceItems([]) });
+          }
           pushItem({
             kind: "statusdone",
             id: nextId2(),
@@ -27308,7 +27324,6 @@ async function createEngineSession({
     requestToolApproval,
     patchToolCardResult,
     flushToolResults,
-    clearExecutionDedupState,
     kickExecutionPendingResume,
     flushDeferredExecutionPendingResumeKick,
     scheduleExecutionPendingResumeKick,

package/src/tui/engine/session-api.mjs

@@ -516,6 +516,9 @@ export function createEngineApiA(bag) {
         syncContextStats({ allowEstimated: true });
         set({ ...routeState(), stats: { ...getState().stats } });
         if (result) {
+          if (!result.error && result.changed !== false) {
+            set({ items: replaceItems([]) });
+          }
           pushItem({
             kind: 'statusdone',
             id: nextId(),