bullswarm 0.29.0 → 0.29.1

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # bullswarm changelog
 
+## 0.29.1 — a revised cancelled run runs its cancelled steps again
+
+- workflow: revising a cancelled run reopened it but left every step the
+  cancellation had stopped as `cancelled`, so the kernel finalized `partial`
+  in the same second and nothing ran. Found on a real claude-code run
+  (`pxkr7s`, revision 7). Reopening now returns those steps to pending, lists
+  them as `reopened.requeued` in the revise output and the `workflow.reopened`
+  event, and never counts their earlier attempts as completion. Failed steps
+  still wait for an explicit `--rerun`.
+- watch: a run waiting for its caller planner now also prints the
+  `plan export` / `plan revise` commands next to `plan show`.
+- workflow: an attempt stopped by a plan revision or a pause now records
+  `failureKind: superseded` or `paused` on the attempt and in
+  `attempt.finished`, the same kind `action.finished` already carried. It was
+  recorded as a plain `cancelled`, which made deliberate steering look like
+  worker failures.
+- strategy: `strategy rungs` no longer counts a stopped dispatch against a
+  pool's "% ok". On 2026-09-14 all 11 claude-code dispatches recorded as not
+  ok were workflow cancellations, plan revisions or pauses, none a worker
+  failure. Dispatch records now carry `failureKind`. The share was display
+  only; routing never read it.
+
 ## 0.29.0 — steer a running workflow, providers become directories, a declared reset date
 
 - workflow: the plan of a caller-planned program run can be changed at any

package/package.json

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

package/skill/SKILL.md

@@ -174,7 +174,9 @@ Rules that matter when you edit:
   must not remain, give a new or amended step the job of reverting or repairing
   them.
 - Revising a finished run (`completed`, `partial`, `cancelled`) reopens it: the
-  new plan runs and the run finishes again with a new result.
+  new plan runs and the run finishes again with a new result. Steps a
+  cancellation stopped run again; failed steps run again only when named in
+  `rerun`.
 - To think without new work starting, pause first: `bullswarm workflow pause
   <shortId>` starts nothing new and lets running agents finish (`--now` stops
   them; they run again after resume). Export and revise while paused, then

package/skill/references/operations.md

@@ -209,8 +209,10 @@ being replaced is stopped before the new plan is committed
 CLI applies the revision itself under the kernel lease and relaunches the
 kernel detached, unless the run is paused. A finished run is reopened: its
 `result.json` moves to `result-before-revision-<n>.json`, a
-`workflow.reopened` event is written, and the new plan runs to a new result. A
-revision also clears a caller-planner wait, so it can replace `plan submit`.
+`workflow.reopened` event is written, and the new plan runs to a new result.
+Steps a cancellation stopped return to pending (`reopened.requeued`); failed
+steps stay failed unless the revision names them in `rerun`. A revision also
+clears a caller-planner wait, so it can replace `plan submit`.
 
 Stopping a process does not undo its edits in the shared tree. When a stopped
 or removed step's partial changes must go, amend it or add a step whose prompt

package/src/lib/strategy.js

@@ -303,7 +303,11 @@ export function rungRecord(decisionLog, pool, tier) {
     const window = attemptWindow(row);
     if (window) minutes.push(window.minutes);
   }
-  const verdicts = rows.filter((row) => typeof row.ok === 'boolean');
+  // A dispatch someone stopped (a workflow cancel, a plan revision, a pause) is
+  // not a verdict on the pool. Older rows carry no failureKind, only the
+  // dispatcher's fixed cancellation message.
+  const stopped = (row) => row.failureKind === 'cancelled' || row.why === 'workflow cancellation requested';
+  const verdicts = rows.filter((row) => typeof row.ok === 'boolean' && !stopped(row));
   return {
     dispatches: rows.length,
     medianMinutes: minutes.length ? Math.round(medianOf(minutes) * 100) / 100 : null,

package/src/workflow/dashboard.js

@@ -452,7 +452,9 @@ export function workflowPanelModel(row, { phaseIndex = null, agentIndex = null }
       agents.push({
         key: `attempt:${attempt.id}`, action, attempt: { ...attempt, attemptNumber: attempt.ordinal, outFile: attempt.outputFile },
         active: attempt.status === 'running' ? { ...attempt, stepId: action.id, attempt: attempt.ordinal, outFile: attempt.outputFile } : null,
-        pool: attempt.pool ?? 'unassigned', model: attempt.model ?? 'connector model', status: attempt.status,
+        pool: attempt.pool ?? 'unassigned', model: attempt.model ?? 'connector model',
+        // A worker stopped by a plan revision or a pause did not fail; say why it stopped.
+        status: attempt.status === 'cancelled' && ['superseded', 'paused'].includes(attempt.failureKind) ? attempt.failureKind : attempt.status,
       });
     }
   }
@@ -1326,7 +1328,7 @@ function statusIcon(status, spinnerFrame = 0) {
   if (value.includes('waiting') || value === 'queued' || value === 'paused'
     || value === 'blocked' || value === 'starting' || value === 'reviewing evidence'
     || value === 'directing execution') return glyphs().waiting;
-  if (value === 'skipped' || value === 'removed') return '–';
+  if (value === 'skipped' || value === 'removed' || value === 'superseded') return '–';
   return glyphs().pending;
 }
 

package/src/workflow/v2-dispatch.js

@@ -417,7 +417,7 @@ export async function dispatchV2Action({
     onAttempt?.('finished', clone(record), verdict);
     appendDecision(bullswarmDir, {
       ts: finishedAt, lane: action.lane ?? 'chore', picked: pool.name,
-      keepOnClaude: false, ok: verdict.ok, why: verdict.why ?? null,
+      keepOnClaude: false, ok: verdict.ok, failureKind: verdict.ok ? null : kind, why: verdict.why ?? null,
       wallSec: verdict.meta?.wallSec ?? null, model: record.model,
       reasoning: clone(reasoning),
       usage: verdict.meta?.usage ?? null, routing: record.routing,

package/src/workflow/v2-runtime.js

@@ -33,7 +33,7 @@ import { scoutPrompt } from './goal.js';
 import {
   createIsolatedWorkspace, disposeIsolatedWorkspace, integrateIsolatedWorkspace,
 } from './v2-workspace.js';
-import { presentationStageStatus, stageForAction } from './v2-presentation.js';
+import { deriveV2LiveStages, presentationStageStatus, stageForAction } from './v2-presentation.js';
 import { deliverSteering, peekSteering, readSteering } from './steering.js';
 import { enforcesOwnership, isProgramWorkflow, v2SchedulingOptions } from './execution-policy.js';
 import { buildWorkspaceReport, captureWorkspaceStatus } from './workspace-report.js';
@@ -264,8 +264,22 @@ function commitRevisionUnderLease(runDir, request, { now }) {
     if (state.cancellation.requested) state.cancellation = { requested: false, requestedAt: null, reason: null };
     rmSync(cancelFile, { force: true });
     if (['completed', 'cancelled', 'failed'].includes(state.planner.status)) state.planner.status = 'waiting';
-    reopened = { previousStatus, archivedResult: hadResult ? archived : null };
-    appendEvent(runDir, state, 'workflow.reopened', { previousStatus, requestId: request.id, archivedResult: reopened.archivedResult });
+    // Steps the cancellation stopped were never judged; reopening the run is
+    // what lifts that cancellation, so they run again. Their earlier attempts
+    // stay on record but never count as this step's completion. Failed steps
+    // are left as they are: rerunning them is the caller's decision.
+    const requeued = [];
+    for (const action of state.actions) {
+      if (action.status !== 'cancelled') continue;
+      Object.assign(action, {
+        status: 'pending', startedAt: null, finishedAt: null, outputFile: null, artifactIds: [],
+        lastFailure: null, supersededAttempts: action.attempts,
+      });
+      requeued.push(action.id);
+    }
+    if (requeued.length) state.presentation.stages = deriveV2LiveStages(state, { revision: state.program.revision, at });
+    reopened = { previousStatus, archivedResult: hadResult ? archived : null, requeued };
+    appendEvent(runDir, state, 'workflow.reopened', { previousStatus, requestId: request.id, archivedResult: reopened.archivedResult, requeued });
   }
   // A revision answers a caller-planner pause as fully as a submission does.
   if (state.planner.awaiting) {
@@ -1307,6 +1321,10 @@ async function runV2Kernel({
           emit('attempt.started', { actionId: action.id, attemptId: currentAttemptId, pool: record.pool, model: record.model, reasoning: clone(record.reasoning ?? null) });
         } else {
           lease.assertOwner();
+          // An attempt stopped by a plan revision or a pause is not a failure of
+          // its pool: record why it stopped, the same kind action.finished carries.
+          const stop = record.status === 'cancelled' && !interrupted ? stopRequested.get(action.id) ?? null : null;
+          if (stop) record = { ...record, failureKind: stop.kind, why: stop.message };
           if (record.status === 'succeeded') writeCompletionReceipt(receiptPath, {
             attemptId: currentAttemptId, finishedAt: record.finishedAt, before, isolated,
             verdict: verdict ?? { ok: true, outFile: record.outFile ?? record.outputFile },
@@ -1460,10 +1478,10 @@ async function runV2Kernel({
       runtime.finishedAt = finishedAt;
       runtime.lastFailure = stop ? { kind: stop.kind, message: stop.message } : { kind: 'runtime', message: error?.message || String(error) };
       for (const attempt of state.attempts) if (attempt.actionId === action.id && attempt.status === 'running') {
-        Object.assign(attempt, { status: runtime.status, finishedAt, failureKind: 'runtime', why: runtime.lastFailure.message });
+        Object.assign(attempt, { status: runtime.status, finishedAt, failureKind: runtime.lastFailure.kind, why: runtime.lastFailure.message });
         runtime.outputFile ??= attempt.outputFile;
       }
-      emit('action.finished', { actionId: action.id, status: runtime.status, failureKind: 'runtime', why: runtime.lastFailure.message });
+      emit('action.finished', { actionId: action.id, status: runtime.status, failureKind: runtime.lastFailure.kind, why: runtime.lastFailure.message });
       completePresentationStages();
     }
   };

package/src/workflow/watch-cli.js

@@ -867,7 +867,8 @@ export async function runWorkflowWatch(bullswarmDir, token, {
           output.write(`outcome: waiting for the caller planner (${snapshot.awaitingPlanner.boundary} boundary)\n`);
           output.write(snapshot.cancellationRequested
             ? `next: cancellation requested; bullswarm workflow cancel ${runToken} --json finalizes it\n`
-            : `next: bullswarm workflow plan show ${runToken} --json\n`);
+            : `next: bullswarm workflow plan show ${runToken} --json\n`
+              + `  or revise: bullswarm workflow plan export ${runToken} --out plan.json, then bullswarm workflow plan revise ${runToken} --program plan.json\n`);
         }
         return 0;
       }