bullswarm 0.16.0 → 0.17.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # bullswarm changelog
 
+## Unreleased
+
+- Workflow timeline (PR #5) hardened after a 16-agent adversarial review against
+  real run state (23 findings, 21 confirmed): worker rows now name their phase
+  (`├─✓ [Verify] verify-impl`) because concurrent phases interleave in time
+  order and the tree glyph alone hung a row under the wrong phase; a phase whose
+  actions never started (a blocked tail) is shown as `[Phase: X] blocked`
+  instead of vanishing; the header line is truncated so widths down to 20
+  columns really hold; PgUp now scrolls the timeline to earlier rows (it was a
+  dead key at the newest view) and scroll state resets when the pane changes;
+  below 100 columns the footer and status line no longer advertise a timeline
+  the narrow layout does not render. Confirmed minors left open are listed on
+  PR #5.
+- Reworked the autonomous workflow TUI around a human-readable execution story:
+  the existing Workflow Planner and phase sidebar now sits beside a timestamped
+  timeline of completed preflight, planner, phase, and worker milestones; active
+  workers and the waiting/running planner are isolated in a Live section with
+  their latest normalized action and stream heartbeat, and future work stays in
+  a distinct Next section. `v` keeps raw action-ledger and event evidence one key
+  away without mixing it into the default view.
+- Rule 7: a verify checks the goal's own acceptance criteria and never adds a
+  process rule the goal does not state (append-only, existing tests
+  untouched); when the implementation changes what an existing assertion
+  pins, a worker must own updating it. Earned three times on goal 4 (attempt
+  3, `r2vu9i`, `euh622`): the planner wrote "EXTEND BY APPENDING only" into
+  the test worker and its verify while the goal said "do NOT modify existing
+  tests except to extend them" and item 5 forced `programFeatures` to grow,
+  so the assertion at `workflow-adaptive.test.js:206` had no owner, the
+  re-verify rejected the mandated extension, and a planner turn recovered.
+- Goal-4 rerun on v0.16.0 (`euh622`): 36 min 00 s, four stage phases in the TUI
+  (implement, tests, verify, report) instead of sixteen one-action rows, 22/24
+  dispatches on `kaihk/gpt-5.6-luna`, auto-completed, 319/319; two planner
+  turns because of the false rejection above (planner turn 2: "an append-only
+  rule that the goal itself makes unsatisfiable").
+
 ## 0.16.0 — the planner sets the width; a re-verify judges the repair
 
 - A re-verify after a repair round now receives the concerns it raised and the

package/README.md

@@ -289,14 +289,19 @@ bullswarm workflow watch <shortId> --verbose     # detailed agent/action view
 ```
 
 `workflow tui` is the interactive, Claude-style `/workflows` view. For an
-autonomous goal its left navigation stacks a compact Orchestrator panel above
-the Phases panel; internal planner turns never appear as workers or phases.
-Select Orchestration and press Enter, or press `o`
-anywhere, to open a summary-first orchestration overview: what it is doing now,
+autonomous goal its left navigation stacks a compact Workflow Planner panel
+above the Phases panel; internal planner turns never appear as workers or phases.
+The default desktop main panel is a timestamped workflow timeline: completed
+preflight, planner-checkpoint, phase-transition, and worker-result events stay
+above a live section containing the waiting/running Workflow Planner and workers,
+each with its latest semantic action and stream heartbeat. Planned work is kept
+in a separate Next section so it cannot be mistaken for execution evidence.
+Select Workflow Planner and press Enter, or press `o`
+anywhere, to open a summary-first planner overview: what it is doing now,
 its latest decision in plain language, why it chose that path, what happens
-next, progress, and the last three semantic actions. Press `v` to toggle the
-technical view with provider session, every checkpoint turn, usage, prompt,
-and artifact paths. Status marks are consistent throughout the tree: `○` not started,
+next, progress, and the last three semantic actions. Press `v` from the timeline
+for workflow technical state, or from Workflow Planner for provider session,
+every checkpoint turn, usage, prompt, and artifact paths. Status marks are consistent throughout the tree: `○` not started,
 an animated Braille spinner for active work, `⧖` waiting, `✓` finished, and
 `✗` failed or interrupted. The non-emoji `⧖` avoids the inconsistent cell
 width of `⌛` across terminal fonts. It watches ongoing runs from disk and supports `j`/`k` or arrow-key selection, Enter for

package/docs/experiments/2026-08-29-dogfood-bullswarm-builds-bullswarm.md

@@ -307,3 +307,47 @@ is met: each round fixed a defect the deliverable needed fixed. Prediction befor
 rounds and the 10-min recovery turn vanish, wall ≈ 30 min"; observed 25 min 13 s with one planner turn.
 
 Cost: 22 of 23 dispatches on the unmetered opencode2 seat; Claude quota spent on one 247 s planner turn.
+
+## Goal-4 rerun on v0.16.0 (phase = stage) — `euh622` (wf-mtej85ws-18a3c0), 15:25:14 → 16:01:14 Z — **36 min 00 s, auto-completed; one planner-authored false rejection cost the recovery turn**
+
+Runtime `4bfd7f4` = released v0.16.0 (rule 3 "a phase is a pipeline stage … never one per action"); workers pinned to
+`opencode2`/`kaihk/gpt-5.6-luna` (cleared after); orchestrator `claude-code`/`claude-opus-5`; fresh fixture `g4-bs-v5`.
+
+| metric | `r2vu9i` | `bizp4s` | **`euh622`** |
+| --- | ---: | ---: | ---: |
+| wall | 36 min 58 s | 25 min 13 s | 36 min 00 s (2 157 s) |
+| planner turns / plannerSec | 2 / 648 s | 1 / 247 s | 2 / 728 s (34 %) — 462 s + 266 s |
+| dispatches | 26 | 23 | 24 (22 luna + 2 opus) |
+| max concurrent / parallelism | 4 / 1.55 | 4 / 1.77 | 4 / 1.5 |
+| phases in the TUI | 19 one-action rows | 16 one-action rows | **4 stages** (implement 2, tests 3, verify 6 + repairs, report 2) + 2 recovery phases |
+| repairs (rounds / repaired ok / re-verify rejected) | 4 / 2 / 2 | 3 / 2 / 1 | 4 / 2 / 2 |
+| tests after | 314 | 319 | **319/319**; existing tests +116/−1 (the mandated `:206` extension) and +153/−0 |
+
+What the phase change did: the planner wrote `implement` (impl ∥ docs), `tests` (three test writers), `verify` (six
+verifies), `report` — the layout asked for, with no scheduling change (impl ∥ docs started together; three test writers
+and verify-impl started the second impl landed; verify-docs ran while impl was still running). Width was one docs
+worker (three files merged; off the critical path) but three test writers — comparable to `bizp4s`.
+
+The four repair rounds:
+- `verify-impl` r1: fan-out items dispatched through plain `dispatch()`, so `stepTemplate.outputSchema` was never applied
+  — real. Re-verify rejected: the repair tested `step.outputSchema` instead of `itemStep.outputSchema` — the listed
+  concern still unresolved, exactly the rejection the re-verify rule permits. r2 repaired; re-verify ok.
+- `verify-test-runtime` r1: the retry case did not assert the `errors` payload of `action.output_schema_retry` — real.
+- `verify-test-refs` r1: the acceptance command failed on the pre-existing assertion at `workflow-adaptive.test.js:206`
+  (`programFeatures` pinned to three entries) because goal item 5 mandates adding `outputSchema` to it. The repair
+  extended the assertion (+116/−1). Re-verify rejected BECAUSE an existing assertion changed — the planner had written
+  "EXTEND BY APPENDING new test cases only" into `test-refs` and "shows APPENDED cases only" into `verify-test-refs`,
+  and "Do NOT modify existing tests" into `impl`, while the goal says "do NOT modify existing tests except to extend
+  them". No worker owned the assertion; the verifier treated its prompt's rule as an unresolved concern. `verify-suite`,
+  `report`, `verify-report` blocked → planner turn 2 (266 s), whose reason is exact: "verify-test-refs ended ok:false
+  on an append-only rule that the goal itself makes unsatisfiable — goal item 5 mandates adding 'outputSchema' to
+  programFeatures". Recovery program `verify-suite-full` → `final-report` → `verify-final-report`, auto-completed.
+  Third occurrence of this shape (attempt 3, `r2vu9i`, here); `bizp4s` avoided it only because its implementation
+  happened to keep the old assertion true.
+
+Cost of the false rejection: the 266 s planner turn plus the serialised tail ≈ 5–6 min; the rest of the gap to
+`bizp4s` is variance (planner turn 1 462 s vs 247 s on the same contract; `impl` 445 s vs 377 s).
+
+Fix committed after the run, unreleased (`71960ae`): rule 7 — "A verify checks the goal's own acceptance criteria …
+never add a process rule the goal does not state (append-only, tests untouched); when the implementation changes what
+an existing assertion pins, a worker must own updating it." Proof pending a rerun on that commit.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bullswarm",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "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

@@ -277,8 +277,12 @@ supports explicit model selection, Bullswarm pins an allowed model in the same
 effort tier; otherwise that pool is excluded because its implicit default
 cannot be guaranteed. Restore eligibility with `strategy include-model`.
 
-In the human TUI, the autonomous orchestrator has a compact selectable panel
-stacked above the phase tree. Select it and press Enter, or press
+In the human TUI, the autonomous orchestrator is presented as Workflow Planner
+in a compact selectable panel stacked above the phase tree. The default desktop
+view pairs that unchanged navigation with a timestamped workflow timeline:
+finished events stay above a live Planner/worker section with each participant's
+latest semantic action, while unexecuted work stays in a separate Next section.
+Select Workflow Planner and press Enter, or press
 `o`, to see a summary-first overview of its current role, latest decision,
 reason, next action, progress, and recent semantic activity. Press `v` for the
 durable provider session, checkpoint prompts and turns, usage, and artifact

package/src/help.js

@@ -676,8 +676,9 @@ const workflowInspectText = rich({
 
 const workflowTuiText = rich({
   usage: 'bullswarm workflow tui [<runId>] [--json] [--all] [--show <runId>] [--cancel <runId>]',
-  purpose: 'Open the interactive full-screen phase → agent → step/detail browser for ongoing '
-    + 'and historical runs, or print a static/JSON snapshot for a non-interactive caller.',
+  purpose: 'Open the interactive full-screen workflow timeline with Workflow Planner, phase, '
+    + 'live-agent, and technical drill-down views for ongoing and historical runs, or print a '
+    + 'static/JSON snapshot for a non-interactive caller.',
   args: [{ name: '[<runId>]', desc: 'shortId or runId to open directly in detail view; omit to see the run picker' }],
   options: [
     { flag: '--json', desc: "print a JSON snapshot instead of opening the interactive browser (list of ongoing runs, or one run's state/report/events when a runId is given)", default: "opens the interactive browser on a TTY; without a TTY, a given runId instead prints one static text detail tree" },
@@ -689,6 +690,7 @@ const workflowTuiText = rich({
     'interactive mode and the --json/--show/--all views are read-only',
     '--cancel writes state.json (cancelRequested=true, status=cancelling) — cooperative, not a force-kill: the workflow stops at its next safe checkpoint',
     'inside the interactive browser, q detaches without stopping the underlying workflow; c requests the same cancellation with a confirmation prompt',
+    'the default timeline is derived from durable state and events; press v for raw action-ledger and event evidence',
   ],
   examples: [
     { cmd: 'bullswarm workflow tui', note: 'interactive run picker' },

package/src/workflow/dashboard.js

@@ -259,6 +259,8 @@ export function workflowPanelModel(row, {
   const isControlAction = (action) => orchestrator.autonomous
     && action.id === orchestrator.actionId
     && action.kind === 'decide';
+  const isPreflightAction = (action) => orchestrator.autonomous && action.id === 'scout';
+  const isNonPhaseAction = (action) => isControlAction(action) || isPreflightAction(action);
   const phaseNames = [];
   const addPhase = (name) => {
     if (name && !phaseNames.includes(name)) phaseNames.push(name);
@@ -266,12 +268,13 @@ export function workflowPanelModel(row, {
   for (const phase of state._doc?.phases ?? []) {
     const controlOnly = orchestrator.autonomous
       && (phase.steps ?? []).length
-      && (phase.steps ?? []).every((step) => step.id === orchestrator.actionId && step.type === 'decide');
+      && (phase.steps ?? []).every((step) =>
+        (step.id === orchestrator.actionId && step.type === 'decide') || step.id === 'scout');
     if (!controlOnly) addPhase(phase.name);
   }
-  for (const action of ledger) if (!isControlAction(action)) addPhase(action.phase);
-  for (const step of state.steps ?? []) if (step.stepId !== orchestrator.actionId) addPhase(step.phase);
-  if (state.currentStep?.id !== orchestrator.actionId) addPhase(state.currentStep?.phase);
+  for (const action of ledger) if (!isNonPhaseAction(action)) addPhase(action.phase);
+  for (const step of state.steps ?? []) if (step.stepId !== orchestrator.actionId && step.stepId !== 'scout') addPhase(step.phase);
+  if (state.currentStep?.id !== orchestrator.actionId && state.currentStep?.id !== 'scout') addPhase(state.currentStep?.phase);
   if (!orchestrator.autonomous) addPhase(state.currentPhase?.name);
   if (!phaseNames.length) phaseNames.push(orchestrator.autonomous ? 'execution' : 'starting');
 
@@ -283,7 +286,7 @@ export function workflowPanelModel(row, {
     phaseNames.length - 1,
   );
   const phases = phaseNames.map((name) => {
-    const actions = ledger.filter((action) => action.phase === name && !isControlAction(action));
+    const actions = ledger.filter((action) => action.phase === name && !isNonPhaseAction(action));
     const effectiveStatuses = actions.map((action) => effectiveActionStatus(action, state));
     const completed = effectiveStatuses.filter((status) => TERMINAL_ACTIONS.has(status)).length;
     const failed = effectiveStatuses.filter((status) => String(status).startsWith('failed')).length;
@@ -322,6 +325,11 @@ export function workflowPanelModel(row, {
   }
   for (const [key, active] of Object.entries(state.activeAgents ?? {})) {
     if (representedActiveKeys.has(key)) continue;
+    // The autonomous orchestrator is a control-plane thread, not a worker in
+    // whichever execution phase happens to be selected. It has its own panel.
+    // Without this guard, an active checkpoint is re-added below a completed
+    // phase when both share the durable `autonomous-delivery` phase name.
+    if (orchestrator.autonomous && active.stepId === orchestrator.actionId) continue;
     const action = ledger.find((entry) => entry.id === active.stepId || active.stepId?.startsWith(`${entry.id}[`));
     if ((action?.phase ?? state.currentPhase?.name) !== selectedPhase.name) continue;
     agents.push({
@@ -355,10 +363,12 @@ export function renderWorkflowTui(row, {
   width = 120, height = 36, focus = 0, phaseIndex = null, agentIndex = null,
   detailScroll = 0, message = null, confirmCancel = false,
   controlSelected = false, orchestratorDetail = false, orchestratorVerbose = false,
+  workflowVerbose = false,
   spinnerFrame = 0,
 } = {}) {
-  width = Math.max(38, Number(width) || 120);
+  width = Math.max(20, Number(width) || 120);
   height = Math.max(18, Number(height) || 36);
+  const narrow = width < 100;
   const model = workflowPanelModel(row, { phaseIndex, agentIndex });
   const state = model.state;
   const status = row?.status ?? state.status ?? 'starting';
@@ -372,17 +382,21 @@ export function renderWorkflowTui(row, {
   const terminalLabel = state.finishedAt ? ` · ${status === 'completed' ? 'done' : status}` : '';
   const runName = state.workflow ?? row?.shortId ?? state.shortId ?? row?.runId ?? 'workflow';
   const header = [
-    ` ${truncate(runName, Math.max(1, width - agentProgress.length - elapsed.length - terminalLabel.length - 5))} · ${agentProgress}${elapsed}${terminalLabel}`,
+    truncate(` ${truncate(runName, Math.max(1, width - agentProgress.length - elapsed.length - terminalLabel.length - 5))} · ${agentProgress}${elapsed}${terminalLabel}`, width),
     ` ${truncate(state.intent?.goal ?? state.workflow ?? 'workflow', width - 2)}`,
   ];
   const footer = confirmCancel
     ? ' Stop this workflow? y confirm · n/Esc keep running'
     : orchestratorDetail
       ? ` ↑/↓ scroll · v ${orchestratorVerbose ? 'overview' : 'technical details'} · Esc back · c stop · q detach`
-      : ` ↑/↓ select · Enter drill in · Esc back · o orchestrator · c stop · q detach`;
+      : workflowVerbose
+        ? ' ↑/↓ scroll · v overview · Esc back · c stop · q detach'
+        : narrow
+          ? ' ↑/↓ select · Enter inspect · Esc back · o planner · v technical · c stop · q detach'
+          : ' ↑/↓ select · PgUp/PgDn timeline · Enter inspect · ←/→ switch · v technical · q detach';
   const rawMessageLine = message
     ? ` ${truncate(message, width - 2)}`
-    : ` ${orchestratorDetail ? `Orchestrator ${orchestratorVerbose ? 'technical details' : 'overview'}` : focus === 0 ? 'Phases' : focus === 1 ? 'Agents' : 'Agent activity'} · r refresh · workflow continues after detach`;
+    : ` ${orchestratorDetail ? `Workflow Planner ${orchestratorVerbose ? 'technical details' : 'overview'}` : workflowVerbose ? 'Workflow technical details' : focus === 0 ? (narrow ? 'Phases' : 'Timeline · auto-following newest event') : focus === 1 ? 'Agents' : 'Agent activity'} · r refresh · workflow continues after detach`;
   const messageLine = truncate(rawMessageLine, width);
   const bodyHeight = Math.max(10, height - header.length - 3);
 
@@ -414,7 +428,6 @@ export function renderWorkflowTui(row, {
 
   // Two information-rich panes become counterproductive on typical 80-column
   // SSH/mobile terminals. Keep the drill-down full-width below 100 columns.
-  const narrow = width < 100;
   const leftWidth = narrow ? width : Math.max(24, Math.min(34, Math.floor(width * 0.27)));
   const rightWidth = narrow ? width : width - leftWidth;
   const orchestrationLines = orchestratorDetailLines(
@@ -426,8 +439,10 @@ export function renderWorkflowTui(row, {
   const detail = orchestratorDetail
     ? orchestrationLines
     : agentDetailLines(model, Math.max(20, rightWidth - 4), spinnerFrame);
+  const technical = workflowTechnicalLines(model, Math.max(20, rightWidth - 4));
   const contentHeight = bodyHeight - 2;
-  const maxScroll = Math.max(0, detail.length - contentHeight);
+  const scrollSource = workflowVerbose ? technical : detail;
+  const maxScroll = Math.max(0, scrollSource.length - contentHeight);
   const scroll = clamp(detailScroll, 0, maxScroll);
   const visiblePhases = panelWindow(['', ...phaseLines], model.phaseIndex, 1, contentHeight).slice(1);
   const visibleAgents = panelWindow(['', ...agentLines], model.agentIndex, 1, contentHeight).slice(1);
@@ -436,7 +451,7 @@ export function renderWorkflowTui(row, {
   const orchestrationNavLines = model.orchestrator.autonomous
     ? [
       selectLine(
-        `${statusIcon(model.orchestrator.active ? 'running' : model.orchestrator.status, spinnerFrame)} Orchestration · ${model.orchestrator.status}`,
+        `${statusIcon(model.orchestrator.active ? 'running' : model.orchestrator.status, spinnerFrame)} ${plannerDisplayStatus(model)}`,
         controlSelected,
         focus === 0 && !orchestratorDetail,
         leftWidth - 2,
@@ -445,6 +460,7 @@ export function renderWorkflowTui(row, {
         [model.orchestrator.pool, model.orchestrator.model].filter(Boolean).join(' · ') || 'select to inspect',
         leftWidth - 2,
       ),
+      dimLine(plannerUsageSummary(model), leftWidth - 2),
     ]
     : [];
   const narrowWorkflowLines = model.orchestrator.autonomous
@@ -457,7 +473,19 @@ export function renderWorkflowTui(row, {
 
   let body;
   if (orchestratorDetail) {
-    body = renderPanel(`Orchestrator · ${orchestratorVerbose ? 'technical details' : 'overview'}`, visibleDetail, width, bodyHeight);
+    body = renderPanel(`Workflow Planner · ${orchestratorVerbose ? 'technical details' : 'overview'}`, visibleDetail, width, bodyHeight);
+  } else if (workflowVerbose) {
+    const visibleTechnical = technical.slice(scroll, scroll + contentHeight);
+    if (narrow) body = renderPanel('Workflow technical details', visibleTechnical, width, bodyHeight);
+    else {
+      const left = model.orchestrator.autonomous
+        ? [
+          ...renderPanel('Workflow Planner', orchestrationNavLines, leftWidth, 5),
+          ...renderPanel(phaseTitle, visiblePhases, leftWidth, bodyHeight - 5),
+        ]
+        : renderPanel(phaseTitle, visiblePhases, leftWidth, bodyHeight);
+      body = joinPanels(left, renderPanel('Workflow technical details', visibleTechnical, rightWidth, bodyHeight));
+    }
   } else if (narrow) {
     const mobile = focus === 0
       ? {
@@ -473,15 +501,17 @@ export function renderWorkflowTui(row, {
   } else if (focus < 2) {
     const left = model.orchestrator.autonomous
       ? [
-        ...renderPanel('Orchestrator', orchestrationNavLines, leftWidth, 5),
+        ...renderPanel('Workflow Planner', orchestrationNavLines, leftWidth, 5),
         ...renderPanel(phaseTitle, visiblePhases, leftWidth, bodyHeight - 5),
       ]
       : renderPanel(phaseTitle, visiblePhases, leftWidth, bodyHeight);
     body = joinPanels(
       left,
       controlSelected
-        ? renderPanel(`Orchestration · ${model.orchestrator.status}`, orchestrationLines.slice(0, contentHeight), rightWidth, bodyHeight)
-        : renderPanel(agentTitle, visibleAgents, rightWidth, bodyHeight),
+        ? renderPanel(`Workflow Planner · ${model.orchestrator.status}`, orchestrationLines.slice(0, contentHeight), rightWidth, bodyHeight)
+        : focus === 0
+          ? renderWorkflowOverviewPanel(model, rightWidth, bodyHeight, spinnerFrame, detailScroll)
+          : renderPanel(agentTitle, visibleAgents, rightWidth, bodyHeight),
     );
   } else {
     body = joinPanels(
@@ -508,6 +538,349 @@ function joinPanels(left, right) {
   return left.map((line, index) => `${line}${right[index] ?? ''}`);
 }
 
+function renderWorkflowOverviewPanel(model, width, height, spinnerFrame, timelineScroll = 0) {
+  const inner = Math.max(1, width - 2);
+  const timeline = workflowTimelineLines(model, inner);
+  const live = workflowLiveLines(model, inner, spinnerFrame);
+  const next = workflowNextLines(model, inner);
+  const contentRows = Math.max(3, height - 4); // outer border + two section dividers
+  const nextRows = Math.min(next.length, 2);
+  const liveRows = Math.min(live.lines.length, Math.max(2, Math.floor(contentRows * 0.42)));
+  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);
+  }
+  if (start + timelineRows < timeline.lines.length && visibleTimeline.length) {
+    visibleTimeline[visibleTimeline.length - 1] = dimText(`↓ ${timeline.lines.length - start - timelineRows + 1} newer timeline rows`, inner);
+  }
+  const visibleLive = live.lines.slice(0, liveRows);
+  const visibleNext = next.slice(0, nextRows);
+  const title = ` Workflow timeline · ${timeline.milestoneCount} milestone${timeline.milestoneCount === 1 ? '' : 's'} `;
+  const rows = [`┌${truncate(title, inner)}${'─'.repeat(Math.max(0, inner - truncate(title, inner).length))}┐`];
+  for (const line of visibleTimeline) rows.push(`│${panelCell(line, inner)}│`);
+  while (rows.length < 1 + timelineRows) rows.push(`│${panelCell('', inner)}│`);
+  rows.push(sectionDivider(`Live · ${live.running} running · ${live.waiting} waiting`, inner));
+  for (const line of visibleLive) rows.push(`│${panelCell(line, inner)}│`);
+  while (rows.length < 2 + timelineRows + liveRows) rows.push(`│${panelCell('', inner)}│`);
+  rows.push(sectionDivider('Next', inner));
+  for (const line of visibleNext) rows.push(`│${panelCell(line, inner)}│`);
+  while (rows.length < height - 1) rows.push(`│${panelCell('', inner)}│`);
+  rows.push(`└${'─'.repeat(inner)}┘`);
+  return rows.slice(0, height);
+}
+
+function sectionDivider(label, inner) {
+  const text = truncate(` ${label} `, inner);
+  return `├${text}${'─'.repeat(Math.max(0, inner - text.length))}┤`;
+}
+
+function workflowTimelineLines(model, width) {
+  const { state, orchestrator } = model;
+  const ledger = state.actionLedger ?? [];
+  const events = [];
+  const add = (at, lines, sequence = Number.MAX_SAFE_INTEGER) => {
+    if (!at) return;
+    events.push({ at, sequence, lines: Array.isArray(lines) ? lines : [lines] });
+  };
+  const scout = ledger.find((action) => action.id === 'scout');
+  add(state.startedAt, [
+    timelineRow(state.startedAt, '● Workflow initiated', '', width),
+    timelineDetail(scout ? 'Goal accepted; preparing repository reconnaissance' : 'Execution started', width),
+  ]);
+
+  const scoutStartedAt = actionStartedAt(state, scout);
+  const scoutFinishedAt = actionFinishedAt(state, scout);
+  if (scoutStartedAt) {
+    add(scoutStartedAt, [
+      timelineRow(scoutStartedAt, '● [Preflight: Scout] started', '', width),
+      timelineDetail('Read-only repository and capability inspection', width),
+    ]);
+  }
+  if (scoutFinishedAt && TERMINAL_ACTIONS.has(effectiveActionStatus(scout, state))) {
+    const attempt = latestAttemptForAction(state, scout);
+    const metadata = [attempt?.pool, attempt?.model, tokenText(attempt?.usage)].filter(Boolean).join(' · ');
+    add(scoutFinishedAt, [
+      timelineRow(scoutFinishedAt, `${statusIcon(effectiveActionStatus(scout, state))} [Preflight: Scout] completed`, durationText(scoutStartedAt, scoutFinishedAt), width),
+      ...(metadata ? [timelineDetail(metadata, width)] : []),
+    ]);
+  }
+
+  orchestrator.attempts.forEach((attempt, index) => {
+    if (!attempt.finishedAt || !TERMINAL_ACTIONS.has(attempt.status)) return;
+    const decision = decisionForPlannerAttempt(state, attempt, index, orchestrator.attempts);
+    const summary = decision?.reason ? sentencePreview(decision.reason, Math.max(30, width - 10))
+      : decision ? decisionLabel(decision.decision) : 'No accepted decision; correction or retry turn';
+    add(attempt.finishedAt, [
+      timelineRow(attempt.finishedAt, `◆ [Workflow Planner] checkpoint #${index + 1}`, durationText(attempt.startedAt, attempt.finishedAt), width),
+      timelineDetail(summary, width),
+    ]);
+  });
+
+  const phases = new Map();
+  for (const action of ledger) {
+    if (action.id === 'scout' || (orchestrator.autonomous && action.id === orchestrator.actionId && action.kind === 'decide')) continue;
+    if (!action.phase) continue;
+    if (!phases.has(action.phase)) phases.set(action.phase, []);
+    phases.get(action.phase).push(action);
+  }
+  for (const [name, actions] of phases) {
+    const realStart = earliestTimestamp(actions.map((action) => actionStartedAt(state, action)));
+    const startedAt = realStart ?? earliestTimestamp(actions.map((action) => actionFinishedAt(state, action)));
+    if (!startedAt) continue;
+    const label = phaseLabel(name, orchestrator);
+    add(startedAt, timelineRow(startedAt, `├─ [Phase: ${label}] ${realStart ? 'started' : 'blocked'}`, '', width));
+    const finished = actions
+      .filter((action) => actionFinishedAt(state, action) && TERMINAL_ACTIONS.has(effectiveActionStatus(action, state)))
+      .sort((a, b) => Date.parse(actionFinishedAt(state, a)) - Date.parse(actionFinishedAt(state, b)));
+    finished.forEach((action, index) => {
+      const terminalPhase = finished.length === actions.length && index === finished.length - 1;
+      const branch = terminalPhase ? '│  └─' : '│  ├─';
+      const actionFinished = actionFinishedAt(state, action);
+      const actionStarted = actionStartedAt(state, action);
+      add(actionFinished, timelineRow(
+        actionFinished,
+        `${branch}${statusIcon(effectiveActionStatus(action, state))} [${label}] ${action.id}`,
+        actionStarted ? durationText(actionStarted, actionFinished) : '',
+        width,
+      ));
+    });
+    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));
+    }
+  }
+
+  for (const event of model.events) {
+    const detail = timelineControlEvent(event, width);
+    if (detail) add(event.committedAt, detail, Number(event.sequence));
+  }
+
+  events.sort((a, b) => Date.parse(a.at) - Date.parse(b.at) || a.sequence - b.sequence);
+  const lines = [];
+  events.forEach((event, index) => {
+    if (index) lines.push('');
+    lines.push(...event.lines);
+  });
+  return { lines: lines.length ? lines : ['Waiting for the first durable workflow milestone'], milestoneCount: events.length };
+}
+
+function decisionForPlannerAttempt(state, attempt, index, attempts) {
+  const decisions = state.decisions ?? [];
+  if (attempt?.outFile) {
+    const artifactMatch = decisions.find((decision) => decision.artifact === attempt.outFile);
+    if (artifactMatch) return artifactMatch;
+  }
+  const started = Date.parse(attempt?.startedAt ?? '');
+  const finished = Date.parse(attempt?.finishedAt ?? '');
+  if (Number.isFinite(started) && Number.isFinite(finished)) {
+    const timeMatch = decisions.find((decision) => {
+      const created = Date.parse(decision.createdAt ?? '');
+      return Number.isFinite(created) && created >= started && created <= finished + 2_000;
+    });
+    if (timeMatch) return timeMatch;
+  }
+  const hasDurableCorrelation = decisions.some((decision) => decision.artifact || decision.createdAt)
+    || attempts.some((entry) => entry.outFile);
+  return hasDurableCorrelation ? null : decisions[index];
+}
+
+function timelineControlEvent(event, width) {
+  const labels = {
+    'decision.rejected': '✗ [Workflow Planner] decision rejected',
+    'decision.correction_requested': '⧖ [Workflow Planner] correction requested',
+    'decision.orchestrator_escalated': '◆ [Workflow Planner] provider escalated',
+    'run.cancellation_requested': '⧖ Workflow cancellation requested',
+    'run.cancelling': '⧖ Workflow cancellation requested',
+    'run.interruption_requested': '⧖ Workflow interruption requested',
+    'workflow.expansion_target_exceeded': '! Advisory expansion target exceeded',
+    'workflow.agent_target_exceeded': '! Advisory agent target exceeded',
+  };
+  const label = labels[event.type];
+  if (!label) return null;
+  const reason = event.payload?.why ?? event.payload?.reason;
+  return [
+    timelineRow(event.committedAt, label, '', width),
+    ...(reason ? [timelineDetail(sentencePreview(reason, Math.max(20, width - 8)), width)] : []),
+  ];
+}
+
+function workflowLiveLines(model, width, spinnerFrame) {
+  const { state, orchestrator } = model;
+  const activeWorkers = Object.values(state.activeAgents ?? {})
+    .filter((agent) => agent.stepId !== orchestrator.actionId)
+    .sort((a, b) => String(b.lastEventAt ?? b.lastActivityAt ?? '').localeCompare(String(a.lastEventAt ?? a.lastActivityAt ?? '')));
+  const lines = [];
+  let running = activeWorkers.length + (orchestrator.active ? 1 : 0);
+  let waiting = 0;
+  if (orchestrator.autonomous && !state.finishedAt) {
+    const plannerWaiting = !orchestrator.active && activeWorkers.length > 0;
+    if (plannerWaiting) waiting += 1;
+    const plannerStatus = orchestrator.active ? 'planning' : plannerWaiting ? 'waiting' : orchestrator.status;
+    lines.push(alignRight(
+      `${statusIcon(plannerStatus, spinnerFrame)} [Workflow Planner] · ${orchestrator.pool} · ${orchestrator.model}`,
+      plannerStatus,
+      width,
+    ));
+    if (plannerWaiting) lines.push(`   Waiting for ${activeWorkers.length === 1 ? activeWorkers[0].stepId : `${activeWorkers.length} workers`}`);
+    else if (orchestrator.active) lines.push('   Choosing the next smallest useful action');
+    else lines.push(`   ${humanStatus(orchestrator.status)}`);
+    const plannerAction = orchestrator.active?.lastActions?.at(-1) ?? orchestrator.latestAttempt?.lastActions?.at(-1);
+    if (plannerAction) lines.push(`   ↳ ${friendlyActionKind(plannerAction.kind)}${plannerAction.summary ? ` · ${friendlyActionSummary(plannerAction)}` : ''}`);
+    else if (orchestrator.latestDecision) lines.push(`   ↳ Decision · ${decisionLabel(orchestrator.latestDecision.decision)}`);
+    const plannerStream = streamActivityLine(orchestrator.active);
+    if (plannerStream) lines.push(`   ${plannerStream}`);
+    lines.push('');
+  }
+  for (const agent of activeWorkers) {
+    const action = (state.actionLedger ?? []).find((entry) => entry.id === agent.stepId || agent.stepId?.startsWith(`${entry.id}[`));
+    lines.push(alignRight(
+      `${statusIcon(agent.status ?? 'running', spinnerFrame)} ${agent.stepId} · ${agent.pool ?? 'unassigned'} · ${agent.model ?? 'connector model'}`,
+      durationText(action?.startedAt ?? agent.startedAt),
+      width,
+    ));
+    const latest = agent.lastActions?.at(-1);
+    lines.push(latest
+      ? `   ↳ ${friendlyActionKind(latest.kind)}${latest.summary ? ` · ${friendlyActionSummary(latest)}` : ''}`
+      : '   ↳ waiting for the first semantic action event');
+    const stream = streamActivityLine(agent);
+    if (stream) lines.push(`   ${stream}`);
+    lines.push('');
+  }
+  if (!lines.length) lines.push(state.finishedAt ? '✓ No live agents · workflow is terminal' : '⧖ Waiting for the next dispatch');
+  return { lines, running, waiting };
+}
+
+function workflowNextLines(model, width) {
+  const { state, orchestrator } = model;
+  if (state.finishedAt) return [truncate(`${statusIcon(state.status)} Workflow terminal · obtain the stable result envelope`, width)];
+  const ledger = state.actionLedger ?? [];
+  const pending = ledger.find((action) => action.id !== 'scout'
+    && action.id !== orchestrator.actionId
+    && !TERMINAL_ACTIONS.has(effectiveActionStatus(action, state))
+    && effectiveActionStatus(action, state) !== 'running');
+  if (pending) {
+    const blockers = (pending.dependsOn ?? []).filter((id) => state.outputs?.[id]?.ok !== true);
+    const wait = blockers.length ? ` · waiting for ${blockers.join(', ')}` : '';
+    return [truncate(`○ [Phase: ${phaseLabel(pending.phase, orchestrator)}] · ${pending.id}${wait}`, width)];
+  }
+  if (Object.keys(state.activeAgents ?? {}).some((key) => state.activeAgents[key]?.stepId !== orchestrator.actionId)) {
+    return ['○ [Workflow Planner] will reassess when current work finishes'];
+  }
+  if (orchestrator.active) return ['○ Awaiting the next [Workflow Planner] decision'];
+  return ['○ Awaiting the next [Workflow Planner] decision'];
+}
+
+function workflowTechnicalLines(model, width) {
+  const { state, orchestrator } = model;
+  const lines = [
+    `Status · ${state.status ?? 'starting'}`,
+    `Current · ${state.currentStep?.id ?? '—'} · ${state.currentStep?.phase ?? state.currentPhase?.name ?? '—'}`,
+    `Started · ${state.startedAt ?? '—'}`,
+    `Usage · ${compactUsage(state.usage)}`,
+    '',
+    'Action ledger',
+  ];
+  for (const action of state.actionLedger ?? []) {
+    const control = orchestrator.autonomous && action.id === orchestrator.actionId && action.kind === 'decide';
+    lines.push(`${statusIcon(effectiveActionStatus(action, state))} ${control ? '[Workflow Planner]' : action.id} · ${action.kind} · ${action.status ?? 'pending'} · ${action.phase ?? '—'}`);
+  }
+  if (!(state.actionLedger ?? []).length) lines.push('· no actions recorded');
+  lines.push('', 'Recent durable events');
+  for (const event of model.events.slice(-12)) lines.push(`#${event.sequence} ${event.type}`);
+  if (!model.events.length) lines.push('· no events recorded');
+  return wrapLines(lines, width);
+}
+
+function timelineRow(at, label, right, width) {
+  return alignRight(`${clockText(at)}  ${label}`, right, width);
+}
+
+function timelineDetail(text, width) {
+  return truncate(`       ${text}`, width);
+}
+
+function alignRight(left, right, width) {
+  const suffix = right ? String(right) : '';
+  if (!suffix) return truncate(left, width);
+  const room = Math.max(1, width - suffix.length - 1);
+  const lhs = truncate(left, room);
+  return `${lhs}${' '.repeat(Math.max(1, width - lhs.length - suffix.length))}${suffix}`;
+}
+
+function clockText(value) {
+  const date = new Date(value ?? '');
+  if (!Number.isFinite(date.getTime())) return '--:--';
+  return `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
+}
+
+function earliestTimestamp(values) {
+  return values.filter(Boolean).sort((a, b) => Date.parse(a) - Date.parse(b))[0] ?? null;
+}
+
+function latestTimestamp(values) {
+  return values.filter(Boolean).sort((a, b) => Date.parse(b) - Date.parse(a))[0] ?? null;
+}
+
+function latestAttemptForAction(state, action) {
+  if (!action) return null;
+  return (action.attempts ?? []).map((index) => state.attempts?.[index]).filter(Boolean).at(-1) ?? null;
+}
+
+function actionStartedAt(state, action) {
+  if (!action) return null;
+  const attempts = (action.attempts ?? []).map((index) => state.attempts?.[index]).filter(Boolean);
+  return action.startedAt ?? earliestTimestamp(attempts.map((attempt) => attempt.startedAt));
+}
+
+function actionFinishedAt(state, action) {
+  if (!action) return null;
+  const attempts = (action.attempts ?? []).map((index) => state.attempts?.[index]).filter(Boolean);
+  return action.finishedAt ?? latestTimestamp(attempts.map((attempt) => attempt.finishedAt));
+}
+
+function streamActivityLine(agent) {
+  if (!agent) return '';
+  const at = agent.lastEventAt ?? agent.lastActivityAt;
+  if (!at) return 'stream waiting for the first provider event';
+  return `stream active ${durationText(at)} ago · ${formatBytes(agent.outputBytesObserved ?? 0)} observed`;
+}
+
+function formatBytes(value) {
+  const bytes = Math.max(0, Number(value) || 0);
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function humanStatus(value) {
+  return String(value ?? 'waiting').replaceAll('_', ' ').replace(/^./, (char) => char.toUpperCase());
+}
+
+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);
+  if (workers.length) return 'Waiting for workers';
+  if (orchestrator.status === 'reviewing evidence') return 'Reviewing evidence';
+  return humanStatus(orchestrator.status);
+}
+
+function plannerUsageSummary(model) {
+  const checkpoints = model.orchestrator.attempts.length;
+  const cost = model.state.usage?.cost?.estimatedUsd ?? model.state.usage?.cost?.knownSubtotalUsd;
+  return `Checkpoints ${checkpoints}${Number.isFinite(cost) ? ` · $${cost.toFixed(2)}` : ''}`;
+}
+
+function dimText(value, width) {
+  return `\x1b[2m${truncate(value, width)}\x1b[0m`;
+}
+
 function orchestratorDetailLines(model, width, spinnerFrame, { verbose = false } = {}) {
   const { orchestrator, state } = model;
   if (!orchestrator.autonomous) {
@@ -520,6 +893,7 @@ function orchestratorDetailLines(model, width, spinnerFrame, { verbose = false }
   const conversations = Object.entries(state.orchestration?.conversations ?? {});
   const decisions = state.decisions ?? [];
   const latestDecision = decisions.at(-1);
+  const latestLiveAction = liveActions.at(-1) ?? null;
   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 ?? {})
@@ -538,6 +912,14 @@ function orchestratorDetailLines(model, width, spinnerFrame, { verbose = false }
     `Now · ${stateLabel}`,
     `Progress · ${completedWorkers}/${workerAttempts.length} worker attempts finished · ${orchestrator.attempts.length} planning checkpoint${orchestrator.attempts.length === 1 ? '' : 's'}`,
   ];
+  if (active) {
+    lines.push(latestLiveAction
+      ? `Latest action · ${friendlyActionKind(latestLiveAction.kind)}${latestLiveAction.summary ? ` · ${friendlyActionSummary(latestLiveAction)}` : ''}`
+      : 'Latest action · waiting for the first semantic event');
+    lines.push(active.lastEventAt
+      ? `Live stream · event ${durationText(active.lastEventAt)} ago · ${active.outputBytesObserved ?? 0} bytes observed`
+      : 'Live stream · waiting for the first provider event');
+  }
   if (latestDecision) {
     lines.push(`Latest decision · ${decisionLabel(latestDecision.decision)}`);
     if (latestDecision.reason) lines.push(`Why · ${sentencePreview(latestDecision.reason)}`);
@@ -581,7 +963,7 @@ function orchestratorDetailLines(model, width, spinnerFrame, { verbose = false }
   lines.push('', 'Checkpoint turns');
   if (!orchestrator.attempts.length) lines.push('· waiting for the first planning turn');
   orchestrator.attempts.forEach((attempt, index) => {
-    const decision = (state.decisions ?? [])[index];
+    const decision = decisionForPlannerAttempt(state, attempt, index, orchestrator.attempts);
     lines.push(`#${index + 1} ${statusIcon(attempt.status, spinnerFrame)} ${attempt.status} · ${attempt.pool ?? '—'} · ${attempt.model ?? 'connector model'} · ${durationText(attempt.startedAt, attempt.finishedAt)}`);
     lines.push(`  ${compactUsage(attempt.usage)}`);
     if (decision) lines.push(`  decision: ${decision.decision} · ${decision.reason}`);
@@ -845,6 +1227,7 @@ export async function runDashboard(bullswarmDir, {
     controlSelected: false,
     orchestratorDetail: false,
     orchestratorVerbose: false,
+    workflowVerbose: false,
     spinnerFrame: 0,
   };
   const paintUnsafe = () => {
@@ -915,7 +1298,7 @@ export async function runDashboard(bullswarmDir, {
       }
       const row = detailRow(bullswarmDir, selectedRunId);
       const model = workflowPanelModel(row, { phaseIndex: ui.phaseIndex, agentIndex: ui.agentIndex });
-      if (ui.orchestratorDetail) {
+      if (ui.orchestratorDetail || ui.workflowVerbose) {
         ui.detailScroll = Math.max(0, ui.detailScroll + delta);
         return paint();
       }
@@ -979,27 +1362,32 @@ export async function runDashboard(bullswarmDir, {
           ui.focus = 0;
           ui.controlSelected = true;
           ui.detailScroll = 0;
+        } else if (ui.workflowVerbose) {
+          ui.workflowVerbose = false;
+          ui.detailScroll = 0;
         } else if (detail && ui.focus > 0) ui.focus -= 1;
         else if (detail && !token) detail = false;
         else message = 'At phase level · press q to detach while the workflow keeps running.';
         return paint();
       }
       if (key === '\t' || key === '\u001b[C' || key === 'l') {
-        if (detail) ui.focus = (ui.focus + 1) % 3;
+        if (detail) { ui.focus = (ui.focus + 1) % 3; ui.detailScroll = 0; }
         return paint();
       }
       if (key === '\u001b[D' || key === 'h') {
-        if (detail) ui.focus = (ui.focus + 2) % 3;
+        if (detail) { ui.focus = (ui.focus + 2) % 3; ui.detailScroll = 0; }
         return paint();
       }
       if (key === '\u001b[A' || key === 'k') return moveVertical(-1);
       if (key === '\u001b[B' || key === 'j') return moveVertical(1);
-      if (key === '\u001b[5~') { ui.detailScroll = Math.max(0, ui.detailScroll - 8); return paint(); }
-      if (key === '\u001b[6~') { ui.detailScroll += 8; return paint(); }
+      const timelineScroll = detail && ui.focus === 0 && !ui.orchestratorDetail && !ui.workflowVerbose;
+      if (key === '\u001b[5~') { ui.detailScroll = timelineScroll ? ui.detailScroll + 8 : Math.max(0, ui.detailScroll - 8); return paint(); }
+      if (key === '\u001b[6~') { ui.detailScroll = timelineScroll ? Math.max(0, ui.detailScroll - 8) : ui.detailScroll + 8; return paint(); }
       if (key === 'o' && detail) {
         const row = detailRow(bullswarmDir, selectedRunId);
         const model = workflowPanelModel(row, { phaseIndex: ui.phaseIndex, agentIndex: ui.agentIndex });
         if (model.orchestrator.autonomous) {
+          ui.workflowVerbose = false;
           ui.orchestratorDetail = true;
           ui.orchestratorVerbose = false;
           ui.controlSelected = true;
@@ -1011,8 +1399,9 @@ export async function runDashboard(bullswarmDir, {
       if (key === '1' && detail) { ui.focus = 0; return paint(); }
       if (key === '2' && detail) { ui.focus = 1; return paint(); }
       if (key === '3' && detail) { ui.focus = 2; return paint(); }
-      if (key === 'v' && ui.orchestratorDetail) {
-        ui.orchestratorVerbose = !ui.orchestratorVerbose;
+      if (key === 'v' && detail) {
+        if (ui.orchestratorDetail) ui.orchestratorVerbose = !ui.orchestratorVerbose;
+        else ui.workflowVerbose = !ui.workflowVerbose;
         ui.detailScroll = 0;
         message = null;
         return paint();
@@ -1025,6 +1414,7 @@ export async function runDashboard(bullswarmDir, {
           ui.followActiveAgent = true;
         } else if (ui.focus === 0) {
           if (ui.controlSelected) {
+            ui.workflowVerbose = false;
             ui.orchestratorDetail = true;
             ui.orchestratorVerbose = false;
             ui.detailScroll = 0;

package/src/workflow/goal.js

@@ -9,15 +9,15 @@ const NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
 
 export const PLANNER_RULES_SECTION = [
   '1. Compile the whole program in one decision: the runtime runs every proposed action and consults you only at a finished-or-blocked boundary, so deferred work costs a round trip.',
-  '2. Make every worker prompt self-contained: include the exact goal, absolute cwd, the owned files you assign (never an and/or choice, which blocks a parallel sibling) and a no-other-files boundary, expected artifact, acceptance command and report format: workers see only their own prompt.',
-  '3. A phase is a pipeline stage: one kebab-case name shared by its actions (implement, verify, report), never one per action; phases are forward-only, so recovery opens a new one and never repeats an identical failed plan. Wall-clock is the longest dependsOn chain, so depend only on real data or same-file ordering: a worker depends on the run that wrote its input files, never on that run\'s verify (a verdict is not data), so it starts as that verify runs.',
-  '4. Split to the width the tree allows: each file-disjoint unit (module, test file, doc) is its own concurrent run plus its own verify depending only on that run, then one suite verify depending on all; one worker for N independent files is N chains in series. A verify judges the artifact in review (default: its single or last dependency; with no dependsOn it audits the repository).',
+  '2. Make every worker prompt self-contained: include the exact goal, absolute cwd, the owned files you assign (never an and/or choice, which blocks a sibling) and a no-other-files boundary, expected artifact, acceptance command and report format: workers see only their own prompt.',
+  '3. A phase is a pipeline stage: one kebab-case name shared by its actions (implement, verify), never one per action; phases are forward-only, so recovery opens a new one and never repeats an identical failed plan. Wall-clock is the longest dependsOn chain, so depend only on real data or same-file ordering: a worker depends on the run that wrote its input files, never on that run\'s verify (a verdict is not data), so it starts as that verify runs.',
+  '4. Split to the width the tree allows: each file-disjoint unit (module, test file, doc) is its own concurrent run plus its own verify depending only on that run, then one suite verify depending on all; one worker for N independent files is N chains in series. A verify judges the artifact in review (default: its last dependency; none: the repository).',
   '5. For unknown items, create discovery ending with RETURN ONLY a JSON object containing an items array, then data-driven fan-out via itemsFrom outputs.<id>.outFile or outputs.<id>.data.<field>; the runtime extracts the list, retrying once read-only if needed.',
-  '6. Put outputSchema only on a worker whose object a LATER action reads via itemsFrom or outputs.<id>.data.<field>, and tell it to RETURN ONLY the object; a prose report or any answer containing fenced JSON gets no schema: the runtime parses the last {...} of the text, so a schema on prose costs a retry and a planner turn.',
-  '7. Put verify.repair on every verify and scope each verify to what can be true at its point in the graph: later-scheduled work is not a defect and cosmetic mismatches are concerns, not ok:false. ok:false is repaired and re-checked inside the program; the repair edits files and cannot rewrite the answer under review, so reject only what a file edit can fix and report a wrong claim as a concern with the true value; ok:true is accepted and its concerns are informational.',
-  '8. Add completion with all-actions-ok whenever a clean program finishes the goal; when its acceptance checks pass, return complete rather than adding polish actions. The program\'s LAST worker must be covered by a successful verify — never end on an unverified report or run. Return complete only on durable verified evidence, never proceed, never ask the user, and stop only for a concrete unresolved blocker with a qualified outcome.',
-  '9. Budgets (agents, duration, expansion rounds) are advisory targets, never hard stops; the dispatch budget counts this planner call plus workers, verifiers, retries and escalations. Converge as targets approach: skip optional work; exceed a target only for one essential action or a required verification.',
-  '10. Never propose pool, addDir, taskFile, shell authority, or unbounded work: routing is the runtime\'s. Set lane (analyze to read or judge, build to edit, chore for mechanical steps) and effort (low for checks and mechanical edits, high only where judgement decides) per action or repair; they pick the model tier (unset: build, medium).',
+  '6. Put outputSchema only on a worker whose object a LATER action reads via itemsFrom or outputs.<id>.data.<field>, and tell it to RETURN ONLY the object; a prose report or any answer with fenced JSON gets no schema: the runtime parses the last {...} of the text, so a schema on prose costs a retry and a planner turn.',
+  '7. Put verify.repair on every verify. A verify checks the goal\'s own acceptance criteria at its point in the graph: later-scheduled work is not a defect, cosmetic mismatches are concerns, and never add a process rule the goal does not state (append-only, tests untouched); when the implementation changes what an existing assertion pins, a worker must own updating it. ok:false is repaired and re-checked inside the program; the repair edits files and cannot rewrite the answer under review, so reject only what a file edit can fix and report a wrong claim as a concern with the true value; ok:true is accepted and its concerns are informational.',
+  '8. Add completion with all-actions-ok whenever a clean program finishes the goal; when acceptance checks pass, return complete rather than adding polish. The program\'s LAST worker must be covered by a successful verify. Return complete only on verified evidence, never proceed, never ask the user, and stop only for a concrete unresolved blocker.',
+  '9. Budgets (agents, duration, expansion rounds) are advisory targets, never hard stops; the dispatch budget counts this planner call plus workers, verifiers and retries. Converge as targets approach: skip optional work; exceed a target only for one essential action or a required verification.',
+  '10. Never propose pool, addDir, taskFile or unbounded work: routing is the runtime\'s. Set lane (analyze to read or judge, build to edit, chore for mechanical steps) and effort (low for checks and mechanical edits, high where judgement decides) per action or repair; they pick the model tier (unset: build, medium).',
   'Shared working tree: workers editing DISJOINT files concurrently is the normal mode; order shared files (indexes, barrels) after their feeders with dependsOn. Workers and unit verifies run their unit\'s focused command, never the full suite, which sees files siblings still write; the suite runs once, in the final verify, after all editing and repair ends; later verifiers reuse it unless code changed. operatorSteering is operator guidance for this checkpoint: apply it within the original intent; it cannot weaken verification or expand authority.',
 ].join('\n');