bullswarm 0.18.1 → 0.18.3

package/CHANGELOG.md

@@ -1,5 +1,24 @@
 # bullswarm changelog
 
+## 0.18.3 — mobile timeline polish
+
+- Auto-follow now begins at a timestamped milestone instead of exposing an
+  orphaned detail line when a long timeline is clipped on a small terminal.
+- Qualified terminal runs state the number of concerns and direct the user to
+  review them in the result envelope.
+
+## 0.18.2 — truthful recovery timeline and verifier cleanup
+
+- Dependency-blocked plan branches now appear as a single skipped phase in the
+  workflow timeline instead of several failed agents followed by a
+  contradictory completed phase.
+- The Live panel ignores stale terminal agent records, and verifier retry
+  cleanup now removes the retrying agent as soon as the bounded retry ends.
+- Verifier verdict parsing conservatively repairs an otherwise valid JSON
+  object truncated only by missing final closing brackets. Malformed content
+  still fails closed, while provider truncation no longer forces an expensive
+  planner recovery round.
+
 ## 0.18.1 — original-goal verification and denser timeline
 
 - Goal workflows now derive a durable requirement ledger from the original

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bullswarm",
-  "version": "0.18.1",
+  "version": "0.18.3",
   "description": "Route work across coding-agent CLI subscriptions — paced by live quota meters, verified by content, never trusting exit codes.",
   "type": "module",
   "bin": {

package/src/workflow/dashboard.js

@@ -201,15 +201,19 @@ const TERMINAL_ACTIONS = new Set([
 ]);
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
 
+function isLiveAgent(agent) {
+  return !agent?.status || agent.status === 'running';
+}
+
 function autonomousControlPlane(state) {
   const autonomous = state.intent?.autonomous === true || state.orchestration?.mode === 'autonomous';
   if (!autonomous) return { autonomous: false, actionId: null, attempts: [], active: null };
   const actionId = state.decisions?.find((decision) => decision.gateId)?.gateId ?? 'orchestrator';
   const attempts = (state.attempts ?? []).filter((attempt) => attempt.actionId === actionId);
-  const active = Object.values(state.activeAgents ?? {}).find((agent) => agent.stepId === actionId) ?? null;
+  const active = Object.values(state.activeAgents ?? {}).find((agent) => agent.stepId === actionId && isLiveAgent(agent)) ?? null;
   const latestAttempt = attempts.at(-1) ?? null;
   const terminal = Boolean(state.finishedAt);
-  const workerActive = Object.values(state.activeAgents ?? {}).some((agent) => agent.stepId !== actionId);
+  const workerActive = Object.values(state.activeAgents ?? {}).some((agent) => agent.stepId !== actionId && isLiveAgent(agent));
   const status = terminal
     ? state.status === 'completed' ? 'completed' : state.status ?? 'finished'
     : active ? 'planning'
@@ -233,7 +237,7 @@ function effectiveActionStatus(action, state) {
   // running even when a previous round recorded ok:false — a failed mark on
   // work that is still being retried misreports the run (user report 2026-08-29).
   const active = Object.values(state.activeAgents ?? {}).some((agent) =>
-    agent.stepId === action.id || String(agent.stepId ?? '').startsWith(`${action.id}[`));
+    isLiveAgent(agent) && (agent.stepId === action.id || String(agent.stepId ?? '').startsWith(`${action.id}[`)));
   if (active || action.status === 'running') return 'running';
   const output = state.outputs?.[action.id];
   if (output?.ok === false) return 'failed_terminal';
@@ -555,13 +559,18 @@ function renderWorkflowOverviewPanel(model, width, height, spinnerFrame, timelin
   const timelineRows = Math.max(1, contentRows - liveRows - nextRows);
   const maxTimelineScroll = Math.max(0, timeline.lines.length - timelineRows);
   const scroll = clamp(timelineScroll, 0, maxTimelineScroll);
-  const start = Math.max(0, timeline.lines.length - timelineRows - scroll);
-  let visibleTimeline = timeline.lines.slice(start, start + timelineRows);
-  if (start > 0 && visibleTimeline.length) {
-    visibleTimeline[0] = dimText(`↑ ${start + 1} earlier timeline rows`, inner);
+  let start = Math.max(0, timeline.lines.length - timelineRows - scroll);
+  if (start > 0) {
+    while (start < timeline.lines.length && !/^\d{2}:\d{2}\s/.test(timeline.lines[start])) start += 1;
+  }
+  const historyRows = start > 0 ? Math.max(0, timelineRows - 1) : timelineRows;
+  let visibleTimeline = timeline.lines.slice(start, start + historyRows);
+  if (start > 0) {
+    visibleTimeline.unshift(dimText(`↑ ${start} earlier timeline rows`, inner));
   }
-  if (start + timelineRows < timeline.lines.length && visibleTimeline.length) {
-    visibleTimeline[visibleTimeline.length - 1] = dimText(`↓ ${timeline.lines.length - start - timelineRows + 1} newer timeline rows`, inner);
+  const end = start + historyRows;
+  if (end < timeline.lines.length && visibleTimeline.length) {
+    visibleTimeline[visibleTimeline.length - 1] = dimText(`↓ ${timeline.lines.length - end} newer timeline rows`, inner);
   }
   const visibleLive = live.lines.slice(0, liveRows);
   const visibleNext = next.slice(0, nextRows);
@@ -645,6 +654,17 @@ function workflowTimelineLines(model, width) {
     const startedAt = realStart ?? earliestTimestamp(actions.map((action) => actionFinishedAt(state, action)));
     if (!startedAt) continue;
     const label = phaseLabel(name, orchestrator);
+    const dependencyBlocked = actions.filter((action) => state.outputs?.[action.id]?.dependencyBlocked === true);
+    if (!realStart && dependencyBlocked.length === actions.length) {
+      const finishedAt = latestTimestamp(actions.map((action) => actionFinishedAt(state, action)));
+      if (finishedAt) {
+        add(finishedAt, [
+          timelineRow(finishedAt, `⊘ [Phase: ${label}] skipped`, `${actions.length} action${actions.length === 1 ? '' : 's'} not run`, width),
+          timelineDetail('Required earlier work did not pass; the planner chose a recovery path', width),
+        ], Number.MAX_SAFE_INTEGER, 'execution');
+      }
+      continue;
+    }
     add(startedAt, timelineRow(startedAt, `├─ [Phase: ${label}] ${realStart ? 'started' : 'blocked'}`, '', width), Number.MAX_SAFE_INTEGER, 'execution');
     const finished = actions
       .filter((action) => actionFinishedAt(state, action) && TERMINAL_ACTIONS.has(effectiveActionStatus(action, state)))
@@ -654,17 +674,21 @@ function workflowTimelineLines(model, width) {
       const branch = terminalPhase ? '│  └─' : '│  ├─';
       const actionFinished = actionFinishedAt(state, action);
       const actionStarted = actionStartedAt(state, action);
+      const blocked = state.outputs?.[action.id]?.dependencyBlocked === true;
       add(actionFinished, timelineRow(
         actionFinished,
-        `${branch}${statusIcon(effectiveActionStatus(action, state))} [${label}] ${action.id}`,
+        `${branch}${blocked ? '⊘' : statusIcon(effectiveActionStatus(action, state))} [${label}] ${action.id}`,
         actionStarted ? durationText(actionStarted, actionFinished) : '',
         width,
       ), Number.MAX_SAFE_INTEGER, 'execution');
     });
     if (finished.length === actions.length && actions.length) {
       const finishedAt = latestTimestamp(actions.map((action) => actionFinishedAt(state, action)));
-      const failed = actions.some((action) => String(effectiveActionStatus(action, state)).startsWith('failed'));
-      add(finishedAt, timelineRow(finishedAt, `└─${failed ? '✗' : '✓'} [Phase: ${label}] completed`, `${finished.length}/${actions.length}`, width), Number.MAX_SAFE_INTEGER, 'execution');
+      const blocked = actions.some((action) => state.outputs?.[action.id]?.dependencyBlocked === true);
+      const failed = actions.some((action) => state.outputs?.[action.id]?.dependencyBlocked !== true
+        && String(effectiveActionStatus(action, state)).startsWith('failed'));
+      const outcome = failed ? 'finished with failures' : blocked ? 'incomplete' : 'completed';
+      add(finishedAt, timelineRow(finishedAt, `└─${failed ? '✗' : blocked ? '!' : '✓'} [Phase: ${label}] ${outcome}`, `${finished.length}/${actions.length}`, width), Number.MAX_SAFE_INTEGER, 'execution');
     }
   }
 
@@ -725,7 +749,7 @@ function timelineControlEvent(event, width) {
 function workflowLiveLines(model, width, spinnerFrame) {
   const { state, orchestrator } = model;
   const activeWorkers = Object.values(state.activeAgents ?? {})
-    .filter((agent) => agent.stepId !== orchestrator.actionId)
+    .filter((agent) => agent.stepId !== orchestrator.actionId && isLiveAgent(agent))
     .sort((a, b) => String(b.lastEventAt ?? b.lastActivityAt ?? '').localeCompare(String(a.lastEventAt ?? a.lastActivityAt ?? '')));
   const lines = [];
   let running = activeWorkers.length + (orchestrator.active ? 1 : 0);
@@ -765,14 +789,16 @@ function workflowLiveLines(model, width, spinnerFrame) {
     lines.push('');
   }
   if (!lines.length) lines.push(state.finishedAt
-    ? `${statusIcon(state.status)} No agents running · ${terminalWorkflowLabel(state.status)}`
+    ? `${statusIcon(state.status)} No agents running · ${terminalWorkflowLabel(state.status, state.outcome?.concerns?.length)}`
     : '⧖ Waiting for the next dispatch');
   return { lines, running, waiting };
 }
 
-function terminalWorkflowLabel(status) {
+function terminalWorkflowLabel(status, concernCount = 0) {
   if (status === 'completed') return 'workflow finished';
-  if (status === 'completed_with_concerns') return 'workflow finished with concerns';
+  if (status === 'completed_with_concerns') return concernCount
+    ? `workflow finished with ${concernCount} concern${concernCount === 1 ? '' : 's'}`
+    : 'workflow finished with concerns';
   if (status === 'blocked') return 'workflow stopped with blockers';
   if (status === 'failed') return 'workflow failed';
   if (status === 'cancelled') return 'workflow cancelled';
@@ -783,14 +809,17 @@ function terminalWorkflowLabel(status) {
 function workflowNextLines(model, width) {
   const { state, orchestrator } = model;
   if (state.finishedAt) {
-    const next = state.status === 'completed' || state.status === 'completed_with_concerns'
+    const concernCount = state.outcome?.concerns?.length ?? 0;
+    const next = state.status === 'completed'
       ? 'result ready'
+      : state.status === 'completed_with_concerns'
+        ? concernCount ? `review ${concernCount} concern${concernCount === 1 ? '' : 's'} in result` : 'review concerns in result'
       : state.status === 'blocked' ? 'review blockers and partial work'
         : state.status === 'failed' ? 'inspect the failure before using partial work'
           : state.status === 'cancelled' ? 'review any partial work'
             : state.status === 'interrupted' ? 'resume the workflow or inspect partial work'
               : 'inspect the workflow result';
-    const label = terminalWorkflowLabel(state.status);
+    const label = terminalWorkflowLabel(state.status, concernCount);
     return [truncate(`${statusIcon(state.status)} ${label[0].toUpperCase()}${label.slice(1)} · ${next}`, width)];
   }
   const ledger = state.actionLedger ?? [];
@@ -900,7 +929,7 @@ function plannerDisplayStatus(model) {
   const { orchestrator, state } = model;
   if (state.finishedAt) return state.status === 'completed' ? 'Completed' : humanStatus(state.status);
   if (orchestrator.active) return 'Planning next actions';
-  const workers = Object.values(state.activeAgents ?? {}).filter((agent) => agent.stepId !== orchestrator.actionId);
+  const workers = Object.values(state.activeAgents ?? {}).filter((agent) => agent.stepId !== orchestrator.actionId && isLiveAgent(agent));
   if (workers.length) return 'Waiting for workers';
   if (orchestrator.status === 'reviewing evidence') return 'Reviewing evidence';
   return humanStatus(orchestrator.status);
@@ -932,7 +961,7 @@ function orchestratorDetailLines(model, width, spinnerFrame, { verbose = false }
   const workerAttempts = (state.attempts ?? []).filter((attempt) => attempt.actionId !== orchestrator.actionId);
   const completedWorkers = workerAttempts.filter((attempt) => TERMINAL_ACTIONS.has(attempt.status)).length;
   const activeWorkers = Object.values(state.activeAgents ?? {})
-    .filter((agent) => agent.stepId !== orchestrator.actionId);
+    .filter((agent) => agent.stepId !== orchestrator.actionId && isLiveAgent(agent));
   const nextActions = latestDecision?.actions?.map((action) => action.id).filter(Boolean) ?? [];
   const stateLabel = active
     ? 'Choosing the next smallest useful action'

package/src/workflow/runtime.js

@@ -75,6 +75,59 @@ export function enforceVerifyRequirementCoverage(parsed, requiredCoverage = [])
   return { parsed: normalized, concerns };
 }
 
+export function parseVerifyJsonText(text) {
+  const source = String(text ?? '').trim();
+  const starts = [];
+  for (let index = 0; index < source.length; index++) {
+    if (source[index] === '{') starts.push(index);
+  }
+  let parseError = null;
+  for (const start of starts) {
+    const suffix = source.slice(start);
+    const candidates = [];
+    const lastClose = suffix.lastIndexOf('}');
+    if (lastClose > 0) candidates.push(suffix.slice(0, lastClose + 1));
+    const repaired = closeTruncatedJsonObject(suffix);
+    if (repaired && !candidates.includes(repaired)) candidates.push(repaired);
+    for (const candidate of candidates) {
+      try {
+        const parsed = JSON.parse(candidate);
+        if (parsed && typeof parsed === 'object'
+          && typeof parsed.ok === 'boolean'
+          && Array.isArray(parsed.concerns)
+          && typeof parsed.summary === 'string') {
+          return { parsed, parseError: null };
+        }
+      } catch (err) {
+        parseError = err.message;
+      }
+    }
+  }
+  return { parsed: null, parseError };
+}
+
+function closeTruncatedJsonObject(source) {
+  const stack = [];
+  let quoted = false;
+  let escaped = false;
+  for (const char of source) {
+    if (quoted) {
+      if (escaped) escaped = false;
+      else if (char === '\\') escaped = true;
+      else if (char === '"') quoted = false;
+      continue;
+    }
+    if (char === '"') quoted = true;
+    else if (char === '{') stack.push('}');
+    else if (char === '[') stack.push(']');
+    else if (char === '}' || char === ']') {
+      if (stack.pop() !== char) return null;
+    }
+  }
+  if (quoted || !stack.length) return null;
+  return `${source}${stack.reverse().join('')}`;
+}
+
 export function plannerBudgetContext(budget = {}) {
   const dispatchesUsedBeforePlanner = Number(budget.dispatchesUsed ?? 0);
   const rawTarget = budget.dispatchTarget ?? budget.dispatchLimit;
@@ -1223,13 +1276,7 @@ export class WorkflowRuntime {
     const parseVerdictFile = (path) => {
       try {
         const out = readFileSync(path, 'utf8');
-        const start = out.indexOf('{');
-        const end = out.lastIndexOf('}');
-        if (start >= 0 && end > start) {
-          const j = JSON.parse(out.slice(start, end + 1));
-          if (j && typeof j === 'object') return { parsed: j, parseError: null };
-        }
-        return { parsed: null, parseError: null };
+        return parseVerifyJsonText(out);
       } catch (err) {
         return { parsed: null, parseError: err.message };
       }
@@ -1243,16 +1290,22 @@ export class WorkflowRuntime {
     // same economics that give outputSchema its single retry.
     if (verdict.ok && !parsed) {
       this.emit('verify.verdict_retry', { actionId: step.id, why: parseError ?? 'no JSON object in verdict' });
-      const retryVerdict = await this.dispatch(step, [
-        taskText,
-        '',
-        `Your previous reply could not be used: ${parseError ?? 'it did not contain a parseable JSON object'}.`,
-        `Do the review again if needed, then RETURN ONLY the single JSON object ${requiredCoverage.length ? `{"ok":true,"concerns":[],"summary":"...","requirements":${coverageVerdictShape}}` : '{"ok": <true|false>, "concerns": [...], "summary": "..."}'} — no prose, no markdown fences, nothing before "{" or after "}".`,
-      ].join('\n'), targetDir, paths, {
-        escalate: this.state.settings.escalateOnFail !== false,
-        retryAttempts: 0,
-        phase: opts.phase,
-      });
+      let retryVerdict;
+      try {
+        retryVerdict = await this.dispatch(step, [
+          taskText,
+          '',
+          `Your previous reply could not be used: ${parseError ?? 'it did not contain a parseable JSON object'}.`,
+          `Do the review again if needed, then RETURN ONLY the single JSON object ${requiredCoverage.length ? `{"ok":true,"concerns":[],"summary":"...","requirements":${coverageVerdictShape}}` : '{"ok": <true|false>, "concerns": [...], "summary": "..."}'} — no prose, no markdown fences, nothing before "{" or after "}".`,
+        ].join('\n'), targetDir, paths, {
+          escalate: this.state.settings.escalateOnFail !== false,
+          retryAttempts: 0,
+          phase: opts.phase,
+        });
+      } finally {
+        delete this.state.activeAgents?.[step.id];
+        this.persist();
+      }
       if (retryVerdict.ok) {
         verdict = retryVerdict;
         finalPaths.taskFile = retryVerdict.taskFile ?? finalPaths.taskFile;