bullswarm 0.18.1 → 0.18.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # bullswarm changelog
 
+## 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.2",
   "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';
@@ -645,6 +649,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 +669,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 +744,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);
@@ -900,7 +919,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 +951,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;