mixdog 0.9.68 → 0.9.70

package/src/standalone/agent-tool.mjs

@@ -1,4 +1,3 @@
-import { readFileSync, statSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
@@ -12,20 +11,16 @@ import {
   taskIdFromArgs,
 } from '../runtime/shared/background-tasks.mjs';
 import { presentErrorText, errorLine } from '../runtime/shared/err-text.mjs';
-import { updateJsonAtomicSync } from '../runtime/shared/atomic-file.mjs';
 import { normalizeAgentPermission } from '../runtime/shared/markdown-frontmatter.mjs';
 import { ensureProcessListenerHeadroom } from '../runtime/shared/process-listener-headroom.mjs';
 import { resourceAdmission } from '../runtime/shared/resource-admission.mjs';
 import { prepareAgentSession } from '../runtime/agent/orchestrator/agent-runtime/session-builder.mjs';
 import {
-  abortAgentProgressWatchdog,
-  agentWatchdogPolicyActive,
-  evaluateAgentWatchdogAbort,
   resolveAgentWatchdogPolicy,
   resolveHandoffMessageStartIndex,
   watchdogPartialHandoffFromError,
-  AgentStallAbortError,
 } from '../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
+import { createProgressWatchdogRegistry } from './agent-watchdog-registry.mjs';
 import { buildAgentTaskProgressFields } from './agent-task-status.mjs';
 import { AGENT_OWNER } from '../runtime/agent/orchestrator/agent-owner.mjs';
 import {
@@ -57,15 +52,13 @@ import { createNotify } from './agent-tool/notify.mjs';
 import { resolveAgentSpawnPreset } from './agent-tool/spawn-preset.mjs';
 import {
   TAG_TOMBSTONE_TTL_MS,
-  applyWorkerRowUpsert,
   isTerminalWorkerStatus,
-  normalizeTagTombstones,
   tagTombstoneKey,
-  workerRowKey,
   workerRowTime,
   workerRowToSession,
 } from './agent-tool/worker-rows.mjs';
 import { resolveAgentTerminalReapMs } from '../session-runtime/config-helpers.mjs';
+import { createWorkerIndex } from './agent-tool/worker-index.mjs';
 // Re-export the static tool descriptor so importers of this facade keep the
 // identical public surface (`import { AGENT_TOOL } from './agent-tool.mjs'`).
 export { AGENT_TOOL };
@@ -102,253 +95,20 @@ export function createStandaloneAgent({
   const tagAgents = new Map();
   const tagCwds = new Map();
   const reapTimers = new Map();
-  const workerIndexMutators = [];
-  let workerIndexFlushTimer = null;
-  function workerIndexPath() {
-    return dataDir ? resolve(dataDir, WORKER_INDEX_FILE) : null;
-  }
-
-  function keepWorkerRow(row = {}) {
-    if (!clean(row.tag) || !clean(row.sessionId)) return false;
-    const t = workerRowTime(row);
-    if (!t) return true;
-    if (!isTerminalWorkerStatus(row.status || row.stage)) return true;
-    const reapMs = resolveAgentTerminalReapMs(cfgMod.loadConfig(), row.provider);
-    return reapMs == null || Date.now() - t < reapMs;
-  }
-
-  function normalizeWorkerRows(value) {
-    const source = Array.isArray(value?.workers)
-      ? value.workers
-      : (value?.workers && typeof value.workers === 'object'
-        ? Object.values(value.workers)
-        : (Array.isArray(value) ? value : []));
-    return source
-      .filter((row) => row && typeof row === 'object')
-      .map((row) => ({
-        tag: clean(row.tag),
-        sessionId: clean(row.sessionId),
-        agent: clean(row.agent) || null,
-        provider: clean(row.provider) || null,
-        model: clean(row.model) || null,
-        preset: clean(row.preset) || null,
-        effort: clean(row.effort) || null,
-        fast: row.fast === true ? true : (row.fast === false ? false : null),
-        status: clean(row.status) || 'idle',
-        stage: clean(row.stage) || clean(row.status) || 'idle',
-        createdAt: clean(row.createdAt) || null,
-        updatedAt: clean(row.updatedAt) || null,
-        lastUsedAt: clean(row.lastUsedAt) || null,
-        finishedAt: clean(row.finishedAt) || null,
-        clientHostPid: positiveInt(row.clientHostPid),
-        cwd: clean(row.cwd) || null,
-        task_id: clean(row.task_id || row.taskId) || null,
-        error: clean(row.error) || null,
-        permission: clean(row.permission) || null,
-        toolPermission: clean(row.toolPermission) || null,
-        messages: positiveInt(row.messages) || 0,
-        tools: positiveInt(row.tools) || 0,
-      }))
-      .filter(keepWorkerRow);
-  }
-
-  // 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, tombstones }
-  let _workerRowsCacheDirty = true;
-  function invalidateWorkerRowsCache() {
-    _workerRowsCacheDirty = true;
-  }
-  function readAllWorkerRows() {
-    const file = workerIndexPath();
-    if (!file) return [];
-    let st = null;
-    try { st = statSync(file); } catch { _workerRowsCache = null; return []; }
-    if (!_workerRowsCacheDirty
-      && _workerRowsCache
-      && _workerRowsCache.mtimeMs === st.mtimeMs
-      && _workerRowsCache.size === st.size) {
-      return _workerRowsCache.rows;
-    }
-    let rows = [];
-    let tombstones = [];
-    try {
-      const parsed = JSON.parse(readFileSync(file, 'utf8'));
-      rows = normalizeWorkerRows(parsed);
-      tombstones = normalizeTagTombstones(parsed);
-    } catch {
-      rows = [];
-      tombstones = [];
-    }
-    _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;
-    return rows.filter((row) => rowMatchesContext(row, context));
-  }
-
-  function workerRowsForUpdate(cur) {
-    return normalizeWorkerRows(cur);
-  }
-
-  function writeWorkerRows(mutator) {
-    const file = workerIndexPath();
-    if (!file || typeof mutator !== 'function') return null;
-    try {
-      const result = updateJsonAtomicSync(file, (cur) => {
-        const byKey = new Map();
-        for (const row of workerRowsForUpdate(cur)) {
-          const key = workerRowKey(row);
-          if (key) byKey.set(key, row);
-        }
-        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;
-        }
-        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.
-      invalidateWorkerRowsCache();
-      return result;
-    } catch {
-      return null;
-    }
-  }
-
-  function flushWorkerIndexMutations() {
-    if (workerIndexFlushTimer) {
-      try { clearImmediate(workerIndexFlushTimer); } catch {}
-      workerIndexFlushTimer = null;
-    }
-    if (workerIndexMutators.length === 0) return;
-    const batch = workerIndexMutators.splice(0, workerIndexMutators.length);
-    writeWorkerRows((byKey) => {
-      for (const mutator of batch) {
-        try { mutator(byKey); } catch {}
-      }
-    });
-  }
-
-  function queueWorkerIndexMutation(mutator) {
-    if (typeof mutator !== 'function') return false;
-    if (!workerIndexPath()) return false;
-    workerIndexMutators.push(mutator);
-    if (!workerIndexFlushTimer) {
-      workerIndexFlushTimer = setImmediate(flushWorkerIndexMutations);
-      workerIndexFlushTimer.unref?.();
-    }
-    return true;
-  }
-
-  function workerRowFromSession(session, fallbackTag = '', extra = {}) {
-    const tag = agentTagOf(session) || clean(fallbackTag) || clean(extra.tag);
-    const sessionId = clean(session?.id || extra.sessionId);
-    if (!tag || !sessionId) return null;
-    const runtime = mgr.getSessionRuntime?.(sessionId);
-    const status = clean(extra.status) || (session?.closed === true ? 'closed' : clean(session?.status) || 'idle');
-    const stage = clean(extra.stage) || clean(runtime?.stage) || status;
-    const nowIso = new Date().toISOString();
-    return {
-      tag,
-      sessionId,
-      agent: clean(extra.agent) || clean(session?.agent) || null,
-      provider: clean(extra.provider) || clean(session?.provider) || null,
-      model: clean(extra.model) || clean(session?.model) || null,
-      preset: clean(extra.preset) || clean(session?.presetName) || null,
-      effort: clean(extra.effort) || clean(session?.effort) || null,
-      fast: extra.fast === true || extra.fast === false ? extra.fast : (session?.fast === true ? true : null),
-      status,
-      stage,
-      createdAt: clean(session?.createdAt) || clean(extra.createdAt) || nowIso,
-      updatedAt: clean(extra.updatedAt) || nowIso,
-      lastUsedAt: clean(session?.lastUsedAt) || null,
-      finishedAt: clean(extra.finishedAt) || null,
-      clientHostPid: positiveInt(extra.clientHostPid) || positiveInt(session?.clientHostPid),
-      cwd: clean(session?.cwd) || clean(extra.cwd) || null,
-      task_id: clean(extra.task_id || extra.taskId) || null,
-      error: clean(extra.error) || null,
-      permission: clean(session?.permission) || null,
-      toolPermission: clean(session?.toolPermission) || null,
-      messages: Array.isArray(session?.messages) ? session.messages.length : 0,
-      tools: Array.isArray(session?.tools) ? session.tools.length : 0,
-    };
-  }
-
-  function upsertWorkerRow(row, { defer = false } = {}) {
-    const normalized = normalizeWorkerRows({ workers: [row] })[0];
-    if (!normalized) return false;
-    tags.set(normalized.tag, normalized.sessionId);
-    if (normalized.agent) tagAgents.set(normalized.tag, normalized.agent);
-    if (normalized.cwd) tagCwds.set(normalized.tag, normalized.cwd);
-    if (defer) {
-      return queueWorkerIndexMutation((byKey) => applyWorkerRowUpsert(byKey, normalized));
-    }
-    writeWorkerRows((byKey) => {
-      applyWorkerRowUpsert(byKey, normalized);
-    });
-    return true;
-  }
-
-  function upsertWorkerSession(session, fallbackTag = '', extra = {}) {
-    return upsertWorkerRow(workerRowFromSession(session, fallbackTag, extra));
-  }
-
-  function upsertWorkerSessionDeferred(session, fallbackTag = '', extra = {}) {
-    return upsertWorkerRow(workerRowFromSession(session, fallbackTag, extra), { defer: true });
-  }
-
-  function removeWorkerRow({ tag = '', sessionId = '' } = {}) {
-    const targetTag = clean(tag);
-    const targetSessionId = clean(sessionId);
-    flushWorkerIndexMutations();
-    writeWorkerRows((byKey) => {
-      for (const [key, row] of [...byKey.entries()]) {
-        if ((targetSessionId && row.sessionId === targetSessionId) || (targetTag && row.tag === targetTag)) {
-          byKey.delete(key);
-        }
-      }
-    });
-  }
-
-  function refreshTagsFromIndex(context = {}) {
-    const rows = readWorkerRows(context);
-    for (const row of rows) {
-      if (!row.tag || !row.sessionId) continue;
-      tags.set(row.tag, row.sessionId);
-      if (row.agent) tagAgents.set(row.tag, row.agent);
-      if (row.cwd) tagCwds.set(row.tag, row.cwd);
-    }
-    return rows;
-  }
+  // Worker-index persistence (row store, parse cache, batched atomic writer,
+  // tag projection) lives in agent-tool/worker-index.mjs; the tag maps are
+  // shared by reference so both sides see the same live state.
+  const {
+    readAllTagTombstones,
+    readTagTombstones,
+    readWorkerRows,
+    writeWorkerRows,
+    flushWorkerIndexMutations,
+    upsertWorkerSession,
+    upsertWorkerSessionDeferred,
+    removeWorkerRow,
+    refreshTagsFromIndex,
+  } = createWorkerIndex({ dataDir, cfgMod, mgr, tags, tagAgents, tagCwds });
 
   function wantsSessionScan(args = {}) {
     return args.recover === true || args.scanSessions === true || args.scan_sessions === true;
@@ -1025,95 +785,11 @@ export function createStandaloneAgent({
     }, notifyContext);
   }
 
-  const progressWatchdogs = new Map();
-  let progressWatchdogTimer = null;
-
-  function stopProgressWatchdogTimerIfIdle() {
-    if (progressWatchdogs.size > 0 || !progressWatchdogTimer) return;
-    try { clearInterval(progressWatchdogTimer); } catch {}
-    progressWatchdogTimer = null;
-  }
-
-  function checkProgressIdleWatchdog(state) {
-    const {
-      sessionId,
-      watchdogPolicy,
-      agent,
-      controller,
-      anchorTs,
-    } = state;
-    if (controller.signal?.aborted) {
-      progressWatchdogs.delete(sessionId);
-      stopProgressWatchdogTimerIfIdle();
-      return;
-    }
-    const now = Date.now();
-    const snapshot = typeof mgr.getSessionProgressSnapshot === 'function'
-      ? mgr.getSessionProgressSnapshot(sessionId)
-      : null;
-    const abortErr = snapshot
-      ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy)
-      : null;
-    const sess = typeof mgr.getSession === 'function' ? mgr.getSession(sessionId) : null;
-    const iteration = typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null;
-    if (!abortErr && !snapshot) {
-      const reported = mgr.getSessionLastProgressAt(sessionId);
-      const last = reported || anchorTs;
-      if (watchdogPolicy.idleStaleMs > 0 && now - last > watchdogPolicy.idleStaleMs) {
-        abortAgentProgressWatchdog(controller, {
-          sessionId,
-          agent,
-          error: new AgentStallAbortError(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`),
-          policy: watchdogPolicy,
-          now,
-          anchorTs,
-          lastProgressAt: reported,
-          iteration,
-        });
-      }
-      return;
-    }
-    if (abortErr) {
-      abortAgentProgressWatchdog(controller, {
-        sessionId,
-        agent,
-        error: abortErr,
-        snapshot,
-        policy: watchdogPolicy,
-        now,
-        anchorTs,
-        iteration,
-      });
-    }
-  }
-
-  function ensureProgressWatchdogTimer() {
-    if (progressWatchdogTimer || progressWatchdogs.size === 0) return;
-    progressWatchdogTimer = setInterval(() => {
-      for (const state of [...progressWatchdogs.values()]) {
-        checkProgressIdleWatchdog(state);
-      }
-    }, 1000);
-    progressWatchdogTimer.unref?.();
-  }
-
-  function startProgressIdleWatchdog(sessionId, watchdogPolicy, agent = null) {
-    if (!sessionId || !agentWatchdogPolicyActive(watchdogPolicy)) return null;
-    if (typeof mgr.getSessionProgressSnapshot !== 'function' && typeof mgr.getSessionLastProgressAt !== 'function') return null;
-    if (typeof mgr.linkParentSignalToSession !== 'function') return null;
-    const controller = new AbortController();
-    const anchorTs = Date.now();
-    try { mgr.linkParentSignalToSession(sessionId, controller.signal); } catch { return null; }
-    const state = { sessionId, watchdogPolicy, agent, controller, anchorTs };
-    progressWatchdogs.set(sessionId, state);
-    ensureProgressWatchdogTimer();
-    return {
-      stop: () => {
-        if (progressWatchdogs.get(sessionId) === state) progressWatchdogs.delete(sessionId);
-        stopProgressWatchdogTimerIfIdle();
-      },
-    };
-  }
+  // Idle-progress watchdogs (shared sweep timer) live in
+  // agent-watchdog-registry.mjs.
+  const progressWatchdogs = createProgressWatchdogRegistry({ mgr });
+  const startProgressIdleWatchdog = (sessionId, watchdogPolicy, agent = null) =>
+    progressWatchdogs.start(sessionId, watchdogPolicy, agent);
 
   async function prepareSpawn(args, callerCwd = null, context = {}, prepState = null) {
     refreshTagsFromSessions({ context });
@@ -1824,4 +1500,4 @@ export function createStandaloneAgent({
     },
     closeAll,
   };
-}
+}

package/src/standalone/agent-watchdog-registry.mjs

@@ -0,0 +1,101 @@
+// Idle-progress watchdogs for running agent sessions, extracted from
+// agent-tool.mjs. One shared 1s timer sweeps every watched session, so a burst
+// of agents costs a single interval; the timer stops as soon as the last
+// watchdog is released. Abort policy itself lives in the runtime module.
+import {
+  abortAgentProgressWatchdog,
+  agentWatchdogPolicyActive,
+  evaluateAgentWatchdogAbort,
+  AgentStallAbortError,
+} from '../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
+
+const WATCHDOG_SWEEP_INTERVAL_MS = 1000;
+
+export function createProgressWatchdogRegistry({ mgr }) {
+  const watched = new Map();
+  let timer = null;
+
+  function stopTimerIfIdle() {
+    if (watched.size > 0 || !timer) return;
+    try { clearInterval(timer); } catch {}
+    timer = null;
+  }
+
+  function check(state) {
+    const { sessionId, watchdogPolicy, agent, controller, anchorTs } = state;
+    if (controller.signal?.aborted) {
+      watched.delete(sessionId);
+      stopTimerIfIdle();
+      return;
+    }
+    const now = Date.now();
+    const snapshot = typeof mgr.getSessionProgressSnapshot === 'function'
+      ? mgr.getSessionProgressSnapshot(sessionId)
+      : null;
+    const abortErr = snapshot ? evaluateAgentWatchdogAbort(snapshot, now, watchdogPolicy) : null;
+    const sess = typeof mgr.getSession === 'function' ? mgr.getSession(sessionId) : null;
+    const iteration = typeof sess?.lastIterationIndex === 'number' ? sess.lastIterationIndex : null;
+    // No progress snapshot: fall back to the coarse last-progress timestamp so a
+    // session that never reports structured progress can still stall out.
+    if (!abortErr && !snapshot) {
+      const reported = mgr.getSessionLastProgressAt(sessionId);
+      const last = reported || anchorTs;
+      if (watchdogPolicy.idleStaleMs > 0 && now - last > watchdogPolicy.idleStaleMs) {
+        abortAgentProgressWatchdog(controller, {
+          sessionId,
+          agent,
+          error: new AgentStallAbortError(`agent task stale (${watchdogPolicy.idleStaleMs}ms without progress)`),
+          policy: watchdogPolicy,
+          now,
+          anchorTs,
+          lastProgressAt: reported,
+          iteration,
+        });
+      }
+      return;
+    }
+    if (abortErr) {
+      abortAgentProgressWatchdog(controller, {
+        sessionId,
+        agent,
+        error: abortErr,
+        snapshot,
+        policy: watchdogPolicy,
+        now,
+        anchorTs,
+        iteration,
+      });
+    }
+  }
+
+  function ensureTimer() {
+    if (timer || watched.size === 0) return;
+    timer = setInterval(() => {
+      for (const state of [...watched.values()]) check(state);
+    }, WATCHDOG_SWEEP_INTERVAL_MS);
+    timer.unref?.();
+  }
+
+  return {
+    /** Watch a session until the returned handle is stopped; null when the
+     *  policy is off or the manager cannot link an abort signal. */
+    start(sessionId, watchdogPolicy, agent = null) {
+      if (!sessionId || !agentWatchdogPolicyActive(watchdogPolicy)) return null;
+      if (typeof mgr.getSessionProgressSnapshot !== 'function'
+        && typeof mgr.getSessionLastProgressAt !== 'function') return null;
+      if (typeof mgr.linkParentSignalToSession !== 'function') return null;
+      const controller = new AbortController();
+      const anchorTs = Date.now();
+      try { mgr.linkParentSignalToSession(sessionId, controller.signal); } catch { return null; }
+      const state = { sessionId, watchdogPolicy, agent, controller, anchorTs };
+      watched.set(sessionId, state);
+      ensureTimer();
+      return {
+        stop: () => {
+          if (watched.get(sessionId) === state) watched.delete(sessionId);
+          stopTimerIfIdle();
+        },
+      };
+    },
+  };
+}

package/src/standalone/channel-worker.mjs

@@ -253,21 +253,12 @@ export function createStandaloneChannelWorker({
   }
 
   function start() {
+    if (stopPromise) return stopPromise.then(() => start());
     if (!useProcessWorker) return startInProcess();
     // Daemon mode (default): spawn-or-attach to the machine-global channels
     // daemon. The fork code below is unreachable while useProcessWorker is true.
-    return ensureDaemonAttached().then(() => status());
-    if (stopPromise) {
-      return stopPromise.then(() => start());
-    }
-    if (child && child.exitCode == null && !child.killed) return readyPromise || Promise.resolve(status());
     stopRequested = false;
-    readyPromise = new Promise((resolve, reject) => {
-      readyResolve = resolve;
-      readyReject = reject;
-    });
-    spawnWorkerChild(1);
-    return readyPromise;
+    return ensureDaemonAttached().then(() => status());
   }
 
   function spawnWorkerChild(attempt) {
@@ -745,10 +736,13 @@ export function createStandaloneChannelWorker({
       daemonClient = null;
       attachPromise = null;
       daemonPid = null;
-      return Promise.all([
+      stopPromise = Promise.all([
         client ? client.close(reason).then(() => true).catch(() => true) : Promise.resolve(false),
         Promise.resolve(inFlightAttach).catch(() => null),
-      ]).then(([detached]) => detached);
+      ]).then(([detached]) => detached).finally(() => {
+        stopPromise = null;
+      });
+      return stopPromise;
     }
     if (!child) {
       return Promise.resolve(false);

package/src/tui/components/StatusLine.jsx

@@ -682,16 +682,17 @@ function StatusLineView({ sessionId, clientHostPid, provider, model, effort, fas
 
   const lines = line ? line.split('\n').slice(0, 2) : [' ', ' '];
   const workflowLabel = workflowModeLabel(workflow, remoteEnabled);
-  // Footer footprint stays 3 rows total (L1 + L2 + one spacer). Keep L1/L2 in
-  // the TOP two rows so the statusline is visually attached to the prompt box;
-  // the leftover breathing row sits below L2 at the terminal bottom.
+  // Footer footprint is exactly 2 rows (L1 + L2) so the statusline sits tight
+  // under the prompt box — the old third "breathing" row left a dead band at
+  // the terminal bottom. Left/right insets match the prompt box's text column
+  // (1 border + 1 padding) so both edges line up vertically with the input.
   return (
-    <Box flexDirection="column" width="100%" height={3} overflow="hidden" justifyContent="flex-start" paddingLeft={2} backgroundColor={surfaceBackground()}>
+    <Box flexDirection="column" width="100%" height={2} overflow="hidden" justifyContent="flex-start" paddingLeft={2} paddingRight={2} backgroundColor={surfaceBackground()}>
       <Box flexDirection="row" width="100%" overflow="hidden">
         <Box flexGrow={1} flexShrink={1} flexBasis={0} overflow="hidden">
           <Text wrap="truncate">{lines[0] || ' '}</Text>
         </Box>
-        <Box flexShrink={0} marginLeft={1} marginRight={1}>
+        <Box flexShrink={0} marginLeft={1}>
           <Text color={theme.statusText} wrap="truncate">{workflowLabel}</Text>
         </Box>
       </Box>