@pellux/goodvibes-tui 2.0.14 → 2.0.15

package/src/panels/diff-review-model.ts

@@ -1,11 +1,11 @@
 // ---------------------------------------------------------------------------
-// Diff review model — pure parsing + steering-payload helpers for the
+// Diff review model, pure parsing + steering-payload helpers for the
 // comment-on-hunk review loop (see diff-review-panel.ts).
 //
 // The diff this operates on is the git working tree vs a base ref (HEAD),
 // filtered to the files the current session actually edited (the SDK's
 // SessionChangeTracker). That is the honest source: it is CURRENT working-tree
-// content, not a turn-start snapshot — the panel labels it exactly that way.
+// content, not a turn-start snapshot, the panel labels it exactly that way.
 // ---------------------------------------------------------------------------
 
 /** One hunk of one file's diff, with enough structure to steer a comment at it. */
@@ -126,7 +126,7 @@ export function hunkExcerpt(hunk: ReviewHunk, maxLines = 8): string {
   return [hunk.header, ...body, ...truncated].join('\n');
 }
 
-/** The full unified-diff hunk text (header + body) for one ReviewHunk — the input checkpoints.revertHunk takes. */
+/** The full unified-diff hunk text (header + body) for one ReviewHunk, the input checkpoints.revertHunk takes. */
 export function hunkPatchText(hunk: ReviewHunk): string {
   return [hunk.header, ...hunk.bodyLines].join('\n');
 }
@@ -148,10 +148,10 @@ export interface HunkRevertReceiptInput {
 export function buildHunkRevertReceiptBlock(receipt: HunkRevertReceiptInput): string {
   const plural = (n: number, word: string): string => `${n} ${word}${n === 1 ? '' : 's'}`;
   const lines = [
-    `[Revert] Receipt — reverted one hunk in ${receipt.path} (${receipt.hunkHeader}).`,
+    `[Revert] Receipt: reverted one hunk in ${receipt.path} (${receipt.hunkHeader}).`,
     `  Restored ${plural(receipt.removedLinesRestored, 'deleted line')}, removed ${plural(receipt.addedLinesRemoved, 'added line')}.`,
     receipt.safetyCheckpointId
-      ? `  Reversible: a pre-revert checkpoint was taken — /checkpoints restore ${receipt.safetyCheckpointId} undoes it.`
+      ? `  Reversible: a pre-revert checkpoint was taken; /checkpoints restore ${receipt.safetyCheckpointId} undoes it.`
       : '  Reversible: the working tree already matched the latest checkpoint (nothing extra to snapshot).',
   ];
   return lines.join('\n');

package/src/panels/diff-review-panel.ts

@@ -1,5 +1,5 @@
 // ---------------------------------------------------------------------------
-// DiffReviewPanel — comment-on-hunk review loop.
+// DiffReviewPanel, comment-on-hunk review loop.
 //
 // Shows the current session's file changes per-file and hunk-boundaried, lets
 // the user select a hunk, attach a comment, and submit that comment to the
@@ -9,7 +9,7 @@
 //
 // Data source (labelled honestly in the panel): `git diff <base> -- <files>`,
 // where <files> is the set the SDK SessionChangeTracker recorded this session.
-// That is CURRENT working-tree content vs the base ref — not a turn-start
+// That is CURRENT working-tree content vs the base ref, not a turn-start
 // snapshot. The panel never presents a stale diff as current.
 // ---------------------------------------------------------------------------
 
@@ -88,7 +88,7 @@ export class DiffReviewPanel extends BasePanel {
   }
 
   // -------------------------------------------------------------------------
-  // Public API — driven by the /review command
+  // Public API, driven by the /review command
   // -------------------------------------------------------------------------
 
   /** Wire the steering submit path (the /review command passes ctx.submitInput). */
@@ -108,7 +108,7 @@ export class DiffReviewPanel extends BasePanel {
     this.requestRender();
   }
 
-  /** Re-load the session diff — used after a revert mutates the working tree. */
+  /** Re-load the session diff, used after a revert mutates the working tree. */
   async refresh(): Promise<void> {
     await this.loadSessionReview();
     this.requestRender();
@@ -143,7 +143,7 @@ export class DiffReviewPanel extends BasePanel {
    */
   async loadSessionReview(ref = 'HEAD'): Promise<void> {
     if (!GitService.isGitRepo(this.workingDirectory)) {
-      this.status = 'Not a git repository — no working-tree diff to review.';
+      this.status = 'Not a git repository: no working-tree diff to review.';
       this.loaded = true;
       this.markDirty();
       return;

package/src/panels/eval-registry.ts

@@ -1,8 +1,8 @@
 /**
- * EvalRegistry — holds the latest evaluation harness run state.
+ * EvalRegistry, holds the latest evaluation harness run state.
  *
  * (the purge): extracted out of eval-panel.ts. 'eval' was
- * DELETE-disposition (no surviving human surface — the evaluation harness
+ * DELETE-disposition (no surviving human surface, the evaluation harness
  * is driven and reviewed via the `/eval` CLI command, input/commands/eval.ts)
  * but this registry is still a live consumer of `/eval run` output, so it
  * survives as a standalone read-model rather than being deleted with the

package/src/panels/expandable-list-panel.ts

@@ -20,12 +20,12 @@ import {
  * detail view for that item, and Esc/← returns to the list.
  *
  * Subclasses implement (in addition to the `ScrollableListPanel` contract):
- *   - `getDetailLines(item, width)` — the detail body for the expanded item.
+ *   - `getDetailLines(item, width)`, the detail body for the expanded item.
  *
  * Optionally override:
- *   - `getDetailTitle(item)` — detail-view title (defaults to `this.name`).
- *   - `getListHints()` / `getDetailHints()` — footer keyboard hints per mode.
- *   - `renderListView(width, height)` — the list-mode body (defaults to
+ *   - `getDetailTitle(item)`, detail-view title (defaults to `this.name`).
+ *   - `getListHints()` / `getDetailHints()`, footer keyboard hints per mode.
+ *   - `renderListView(width, height)`, the list-mode body (defaults to
  *     `renderList` with the list hints footer).
  *
  * Do NOT override `render()`; it dispatches between list and detail modes.
@@ -160,7 +160,7 @@ export abstract class ExpandableListPanel<T> extends ScrollableListPanel<T> {
     return this.renderList(width, height, { hints: this.getListHints() });
   }
 
-  /** Detail-mode body — scrollable detail lines + standardized chrome. */
+  /** Detail-mode body, scrollable detail lines + standardized chrome. */
   protected renderDetailView(width: number, height: number, item: T): Line[] {
     this.needsRender = false;
     const palette = this.getPalette();

package/src/panels/fleet-acts.ts

@@ -4,22 +4,22 @@
 // The Fleet panel's waiting-on-human ACTS: the flagged pick row, the flagged
 // conflict row, and the worktree discard all act from the panel selection with
 // no id ever typed. This controller owns that flow so fleet-panel.ts stays under
-// the 800-line architecture cap — the panel delegates the trigger keys, the
+// the 800-line architecture cap, the panel delegates the trigger keys, the
 // pick-mode input, and the pick-mode render here.
 //
-//   • Pick  — the flagged workstream row (needsAttention 'pick') opens a
+//   • Pick , the flagged workstream row (needsAttention 'pick') opens a
 //     candidate picker (best-of-N held attempts, from fleet.attempts.list);
 //     ↑↓ chooses the winner, its diff shows in the shared DiffPanel, and Enter
 //     drives fleet.attempts.pick preview (confirm:false) -> confirm (confirm:true)
 //     through the DiffPanel's existing confirm overlay. No group/candidate id is
-//     ever typed — the panel derives them from the node and the selection.
-//   • Conflict — the flagged work-item row (needsAttention 'conflict') runs
+//     ever typed, the panel derives them from the node and the selection.
+//   • Conflict, the flagged work-item row (needsAttention 'conflict') runs
 //     fleet.conflicts.resolve and hands the STAMPED resolution session id to the
 //     shared one-key jump/attach affordance (the CI fix-session machinery). On
 //     resolution the SDK reclaims the tree and the row clears on the next tick.
-//   • Discard — a worktree-owning work-item row runs worktrees.discard behind a
+//   • Discard, a worktree-owning work-item row runs worktrees.discard behind a
 //     confirm and renders the honest receipt (branch KEPT, dirty state preserved
-//     as a commit) — no path retyping.
+//     as a commit), no path retyping.
 // ---------------------------------------------------------------------------
 
 import type { ProcessNode } from '@pellux/goodvibes-sdk/platform/runtime/fleet';
@@ -91,7 +91,7 @@ function shortId(id: string): string {
   return id.length > 10 ? `${id.slice(0, 10)}…` : id;
 }
 
-/** The held (pick-ready) candidates of a group, in attempt order — the only ones a winner can be chosen from. */
+/** The held (pick-ready) candidates of a group, in attempt order, the only ones a winner can be chosen from. */
 export function heldCandidates(group: FleetHeldMergeGroup): FleetAttemptCandidate[] {
   return group.candidates.filter((c) => c.state === 'held-merge').slice().sort((a, b) => a.attemptIndex - b.attemptIndex);
 }
@@ -147,7 +147,7 @@ export class FleetActs {
     return this.observedSteer !== null;
   }
 
-  /** The active observed-steer draft for `nodeId`, or null — the detail renderer shows the compose line only for the composing row. */
+  /** The active observed-steer draft for `nodeId`, or null, the detail renderer shows the compose line only for the composing row. */
   public observedSteerDraftFor(nodeId: string): string | null {
     return this.observedSteer && this.observedSteer.nodeId === nodeId ? this.observedSteer.draft : null;
   }
@@ -161,7 +161,7 @@ export class FleetActs {
   public openObservedSteer(node: ObservedNode): boolean {
     const channel = node.observed.steer;
     if (channel.kind !== 'tmux') {
-      this.deps.notify(`Cannot steer this ${observedKindLabel(node.observed.externalKind)} session — ${channel.reason}.`);
+      this.deps.notify(`Cannot steer this ${observedKindLabel(node.observed.externalKind)} session: ${channel.reason}.`);
       return true;
     }
     this.observedSteer = { nodeId: node.id, draft: '' };
@@ -246,7 +246,7 @@ export class FleetActs {
       this.deps.notify(`Could not read the best-of-N candidates: ${summarizeError(err)}`);
       return;
     }
-    if (!group) { this.deps.notify('No ready best-of-N group on this workstream — every attempt must settle first.'); return; }
+    if (!group) { this.deps.notify('No ready best-of-N group on this workstream; every attempt must settle first.'); return; }
     this.pick = { workstreamNodeId: node.id, group, selectedHeldIndex: 0 };
     this.showSelectedDiff();
     this.deps.markDirty();
@@ -284,7 +284,7 @@ export class FleetActs {
 
   /**
    * Drive fleet.attempts.pick preview (confirm:false) then, behind the DiffPanel
-   * confirm overlay, confirm (confirm:true). No id is typed — the group id and
+   * confirm overlay, confirm (confirm:true). No id is typed, the group id and
    * the winner item id both come from the picker state.
    */
   private async confirmSelectedPick(): Promise<void> {
@@ -307,7 +307,7 @@ export class FleetActs {
     this.deps.diffSurface.armConfirm({
       id: `${group.groupId}:${cand.itemId}`,
       verb: 'Pick',
-      label: `Pick attempt ${cand.attemptIndex + 1} ("${cand.title}") — merge it, clean the ${losers} other worktree(s)`,
+      label: `Pick attempt ${cand.attemptIndex + 1} ("${cand.title}"): merge it, clean the ${losers} other worktree(s)`,
       onConfirm: async () => {
         try {
           const result = await gateway.pick({ groupId: group.groupId, winnerItemId: cand.itemId, confirm: true });
@@ -315,7 +315,7 @@ export class FleetActs {
             const losersCleaned = result.loserItemIds?.length ?? losers;
             this.deps.notify(`[Fleet] Winner picked for group ${shortId(group.groupId)}: attempt ${cand.attemptIndex + 1} merged, ${losersCleaned} loser worktree(s) cleaned.`);
           } else {
-            this.deps.notify(`[Fleet] Pick not applied for group ${shortId(group.groupId)} — the daemon still requires confirmation.`);
+            this.deps.notify(`[Fleet] Pick not applied for group ${shortId(group.groupId)}: the daemon still requires confirmation.`);
           }
         } catch (err) {
           this.deps.notify(`Pick failed: ${summarizeError(err)}`);
@@ -327,7 +327,7 @@ export class FleetActs {
       onCancel: () => {
         this.deps.diffSurface.close();
         this.pick = null;
-        this.deps.notify('Pick cancelled — nothing merged, no worktree cleaned.');
+        this.deps.notify('Pick cancelled: nothing merged, no worktree cleaned.');
         this.deps.markDirty();
       },
     });
@@ -344,7 +344,7 @@ export class FleetActs {
     try {
       const result = await gateway.resolveConflict(itemId);
       const files = result.files.length > 0 ? ` over ${result.files.length} conflicted file(s)` : '';
-      this.deps.notify(`[Fleet] Conflict resolution session started for ${shortId(itemId)}${files} — press j to jump to it.`);
+      this.deps.notify(`[Fleet] Conflict resolution session started for ${shortId(itemId)}${files}; press j to jump to it.`);
       // Reuse the CI fix-session machinery: hand the STAMPED session id to the
       // shared one-key jump affordance. The kept tree is reclaimed by the SDK on
       // a successful re-merge, and the flagged row clears on the next snapshot.
@@ -370,12 +370,12 @@ export class FleetActs {
     this.deps.diffSurface.armConfirm({
       id: `discard:${path}`,
       verb: 'Discard',
-      label: `Discard worktree ${path} — the branch is KEPT and dirty state preserved as a commit`,
+      label: `Discard worktree ${path}: the branch is KEPT and dirty state preserved as a commit`,
       onConfirm: async () => {
         try {
           const receipt = await gateway.discardWorktree(path);
           if (receipt.ok) {
-            this.deps.notify(`[Fleet] Worktree discarded: ${receipt.path}\n  branch kept: ${receipt.branch || '(unknown)'}\n  preservation commit: ${receipt.preservedCommit || '(none — nothing to preserve)'}\n  ${receipt.detail}`);
+            this.deps.notify(`[Fleet] Worktree discarded: ${receipt.path}\n  branch kept: ${receipt.branch || '(unknown)'}\n  preservation commit: ${receipt.preservedCommit || '(none; nothing to preserve)'}\n  ${receipt.detail}`);
           } else {
             this.deps.notify(`[Fleet] Worktree discard refused for ${receipt.path}: ${receipt.detail}`);
           }
@@ -387,7 +387,7 @@ export class FleetActs {
       },
       onCancel: () => {
         this.deps.diffSurface.close();
-        this.deps.notify('Discard cancelled — the worktree is untouched.');
+        this.deps.notify('Discard cancelled: the worktree is untouched.');
         this.deps.markDirty();
       },
     });
@@ -404,7 +404,7 @@ export class FleetActs {
     const held = heldCandidates(group);
     const lines: Line[] = [];
     lines.push(buildPanelLine(width, [
-      [' Best-of-N winner pick — ', P.label],
+      [' Best-of-N winner pick: ', P.label],
       [group.sourceTitle, P.value],
     ]));
     lines.push(buildPanelLine(width, [[' Choose the winner; its diff shows in the diff panel. No id is typed.', P.dim]]));
@@ -435,7 +435,7 @@ export class FleetActs {
       { keys: 'Enter', label: 'pick (confirm)' },
       { keys: 'Esc', label: 'cancel' },
     ], P)];
-    return buildPanelWorkspace(width, height, { title: 'Fleet — Pick winner', sections: [{ lines }], footerLines, palette: P });
+    return buildPanelWorkspace(width, height, { title: 'Fleet: Pick winner', sections: [{ lines }], footerLines, palette: P });
   }
 
   private requireGateway(): FleetGateway | null {

package/src/panels/fleet-deep-link.ts

@@ -1,5 +1,5 @@
 // ---------------------------------------------------------------------------
-// fleet-deep-link.ts — item 4.
+// fleet-deep-link.ts, item 4.
 //
 // PanelManager.open('fleet', pane, target) hands FleetPanel a
 // PanelDeepLinkTarget (a process id + optional ProcessKind) so a cross-panel
@@ -10,13 +10,13 @@
 //
 // `kind`, when given, must also match: ProcessNode ids are unique per the
 // SDK's own contract, so this is a cheap extra honesty check, not the
-// primary lookup key. Reveal is "free" once selectedIndex is set —
+// primary lookup key. Reveal is "free" once selectedIndex is set,
 // ScrollableListPanel's render-time scroll-window resolution keeps the
 // selected row visible, so FleetPanel.receiveDeepLink does not need its own
 // scroll math.
 //
-// A target that isn't found (pruned, killed, never existed, or a domain —
-// like the docs Tools tab's static tool definitions — that has no
+// A target that isn't found (pruned, killed, never existed, or a domain,
+// like the docs Tools tab's static tool definitions, that has no
 // corresponding fleet node at all) resolves to -1; the caller degrades
 // honestly (FleetPanel.setError('node no longer present.')) rather than
 // silently landing on an unrelated row.
@@ -25,7 +25,7 @@
 import type { PanelDeepLinkTarget } from './types.ts';
 import type { FleetTreeRow } from './fleet-read-model.ts';
 
-/** The row index matching `target`'s id (+ kind, if given), or -1. Pure — no I/O, no mutation. */
+/** The row index matching `target`'s id (+ kind, if given), or -1. Pure, no I/O, no mutation. */
 export function resolveFleetDeepLinkIndex(rows: readonly FleetTreeRow[], target: PanelDeepLinkTarget): number {
   return rows.findIndex((row) => row.node.id === target.id && (!target.kind || row.node.kind === target.kind));
 }

package/src/panels/fleet-gateway.ts

@@ -2,10 +2,10 @@
 // fleet-gateway.ts
 //
 // The async, daemon-backed verb surface the Fleet panel's waiting-on-human acts
-// drive — a best-of-N winner pick (fleet.attempts.list / fleet.attempts.pick),
+// drive, a best-of-N winner pick (fleet.attempts.list / fleet.attempts.pick),
 // a merge-conflict resolution (fleet.conflicts.resolve), and a worktree discard
 // (worktrees.discard). These are gateway verbs with no named facade on the
-// in-process OperatorClient, so — exactly like /ci and /worktree setup — they
+// in-process OperatorClient, so, exactly like /ci and /worktree setup, they
 // go over the generic operator invoke path (operator-rpc.ts's resolveOperatorRpc
 // -> sdk.operator.invoke), reaching the SAME daemon the command layer does.
 //
@@ -20,27 +20,27 @@ import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import type { OperatorMethodOutput } from '@pellux/goodvibes-sdk';
 import { resolveOperatorRpc } from '../input/commands/operator-rpc.ts';
 
-/** fleet.attempts.list output — the held-merge groups awaiting a winner pick. */
+/** fleet.attempts.list output, the held-merge groups awaiting a winner pick. */
 export type FleetAttemptsList = OperatorMethodOutput<'fleet.attempts.list'>;
 /** One held-merge group (candidates + their diffs + optional model judgment). */
 export type FleetHeldMergeGroup = FleetAttemptsList['groups'][number];
 /** One candidate attempt within a group. */
 export type FleetAttemptCandidate = FleetHeldMergeGroup['candidates'][number];
-/** fleet.attempts.pick output — the confirm preview (applied:false) OR the applied receipt (applied:true). */
+/** fleet.attempts.pick output, the confirm preview (applied:false) OR the applied receipt (applied:true). */
 export type FleetPickResult = OperatorMethodOutput<'fleet.attempts.pick'>;
-/** fleet.conflicts.resolve output — the seeded resolution session stamped on the kept tree. */
+/** fleet.conflicts.resolve output, the seeded resolution session stamped on the kept tree. */
 export type FleetConflictResolution = OperatorMethodOutput<'fleet.conflicts.resolve'>;
-/** worktrees.discard output — the honest receipt: dir removed, branch KEPT, dirty state preserved as a commit. */
+/** worktrees.discard output, the honest receipt: dir removed, branch KEPT, dirty state preserved as a commit. */
 export type FleetWorktreeDiscardReceipt = OperatorMethodOutput<'worktrees.discard'>;
-/** fleet.graph.get output — the surface-facing task graph of one workstream (nodes/edges/pool). */
+/** fleet.graph.get output, the surface-facing task graph of one workstream (nodes/edges/pool). */
 export type FleetGraphSnapshot = OperatorMethodOutput<'fleet.graph.get'>;
-/** fleet.observed.steer output — queued:true with a messageId, or queued:false with an honest reason. */
+/** fleet.observed.steer output, queued:true with a messageId, or queued:false with an honest reason. */
 export type FleetObservedSteerResult = OperatorMethodOutput<'fleet.observed.steer'>;
 
 /**
  * The narrow async verb surface the Fleet panel's acts drive. Every method is a
  * real daemon round-trip in production (createFleetGateway) and a mocked shape
- * in tests. `armFixSessionAttach` is the ONLY sync member — it hands a spawned
+ * in tests. `armFixSessionAttach` is the ONLY sync member, it hands a spawned
  * session id to the shared one-key jump affordance (the CI fix-session
  * machinery), never a separate attach path.
  */
@@ -57,7 +57,7 @@ export interface FleetGateway {
   resolveConflict(itemId: string): Promise<FleetConflictResolution>;
   /** Discard a worktree directory (branch kept, dirty state preserved as a commit). */
   discardWorktree(path: string): Promise<FleetWorktreeDiscardReceipt>;
-  /** Fetch the task graph (nodes/edges/pool) for one workstream — the observability graph view. */
+  /** Fetch the task graph (nodes/edges/pool) for one workstream, the observability graph view. */
   getGraph(workstreamId: string): Promise<FleetGraphSnapshot>;
   /** Steer an observed foreign agent over its own channel (tmux send-keys); the daemon honestly refuses a channel-less row. */
   steerObserved(input: { readonly id: string; readonly text: string }): Promise<FleetObservedSteerResult>;
@@ -81,7 +81,7 @@ export function workItemIdFromNodeId(nodeId: string): string | null {
 /**
  * Why the gateway could not be built (daemon disabled / no control-plane URL),
  * surfaced verbatim so an act can print an honest "not available" line rather
- * than guessing — mirrors OperatorRpcUnavailable.reason.
+ * than guessing, mirrors OperatorRpcUnavailable.reason.
  */
 export type FleetGatewayResolution =
   | { readonly available: true; readonly gateway: FleetGateway }
@@ -95,7 +95,7 @@ export interface FleetGatewayDeps {
 }
 
 /**
- * Build the live Fleet gateway over the generic operator invoke path — the same
+ * Build the live Fleet gateway over the generic operator invoke path, the same
  * daemon resolution the command layer uses (resolveOperatorRpc). Returns an
  * honest unavailable reason when no daemon is reachable, so the panel acts can
  * refuse cleanly instead of throwing into the render loop.

package/src/panels/fleet-observed-render.ts

@@ -1,8 +1,8 @@
 // ---------------------------------------------------------------------------
-// fleet-observed-render.ts — the fleet-pane rows for observed FOREIGN coding
+// fleet-observed-render.ts, the fleet-pane rows for observed FOREIGN coding
 // agents (kind 'observed-external').
 //
-// goodvibes did NOT spawn these — they are externally-launched Claude Code /
+// goodvibes did NOT spawn these, they are externally-launched Claude Code /
 // Codex / opencode sessions, detected read-only from OS signals. The row's
 // FIRST job is visibility ("it's in claude or codex"): goodvibes never presents
 // itself as the foreign session's cockpit. So an observed row:
@@ -44,7 +44,7 @@ function livenessGlyph(state: ProcessObserved['liveness']['state']): string {
 /**
  * One observed-external row. Deliberately NOT the standard fleet row: no cost/
  * token/steer-badge columns (a foreign session has no LLM turn we account for),
- * no stop marker — just the glyph, an "observed" tag, the session label, its
+ * no stop marker, just the glyph, an "observed" tag, the session label, its
  * external kind, and its liveness state.
  */
 export function renderObservedRowLine(node: ObservedNode, width: number, palette: PanelPalette = DEFAULT_PANEL_PALETTE): Line {
@@ -53,7 +53,7 @@ export function renderObservedRowLine(node: ObservedNode, width: number, palette
   const glyph = livenessGlyph(observed.liveness.state);
   const kindLabel = observedKindLabel(observed.externalKind);
   // The label is width-budgeted so the trailing "kind · state" tell never
-  // overflows the row (the tell is the honesty signal — it must survive).
+  // overflows the row (the tell is the honesty signal, it must survive).
   const tell = `${kindLabel} · ${observed.liveness.state}`;
   const labelBudget = Math.max(4, width - tell.length - 14);
   return buildPanelLine(width, [
@@ -68,15 +68,15 @@ export function renderObservedRowLine(node: ObservedNode, width: number, palette
 
 /**
  * The detail block for a selected observed-external row. States the foreign
- * facts (external kind, pid, cwd, liveness meaning), then the steer affordance —
+ * facts (external kind, pid, cwd, liveness meaning), then the steer affordance,
  * a DRILL-IN: where a real channel exists it names the action; where steer.kind
- * is 'none' it states the honest reason. It NEVER shows a stop affordance —
+ * is 'none' it states the honest reason. It NEVER shows a stop affordance,
  * observing a foreign session is not owning its lifecycle.
  */
 /**
  * Render the observed-row detail. When `steerDraft` is a string the drill-in
  * steer composer is open on THIS row: an active input line replaces the passive
- * "s: steer" hint. A channel-less row never shows an input (owner ruling) — its
+ * "s: steer" hint. A channel-less row never shows an input (owner ruling), its
  * detail states the honest reason and stops there.
  */
 export function renderObservedDetailLines(node: ObservedNode, width: number, palette: PanelPalette = DEFAULT_PANEL_PALETTE, steerDraft: string | null = null): Line[] {
@@ -96,17 +96,17 @@ export function renderObservedDetailLines(node: ObservedNode, width: number, pal
   if (observed.cwd) {
     lines.push(buildPanelLine(width, [[' cwd ', C.label], [truncateDisplay(observed.cwd, Math.max(0, width - 6)), C.dim]]));
   }
-  // Liveness meaning, verbatim — honest about what 'quiet' can and cannot tell.
+  // Liveness meaning, verbatim, honest about what 'quiet' can and cannot tell.
   for (const segment of wrapText(observed.liveness.detail, Math.max(1, width - 2))) {
     lines.push(buildPanelLine(width, [[' ', C.dim], [segment, C.dim]]));
   }
   // Steer is a drill-in: a real channel is named here (a message sent from this
-  // detail travels over it — fleet.observed.steer), and where none exists the
+  // detail travels over it, fleet.observed.steer), and where none exists the
   // honest reason is stated instead of a dead action. Wrapped so a long reason
   // is never clipped at a narrow width.
   const steerText = observed.steer.kind === 'tmux'
     ? `available via tmux pane ${observed.steer.paneId} (send-keys)`
-    : `unavailable — ${observed.steer.reason}`;
+    : `unavailable: ${observed.steer.reason}`;
   const steerFg = observed.steer.kind === 'tmux' ? (C.info ?? DEFAULT_PANEL_PALETTE.info) : C.dim;
   const steerSegments = wrapText(steerText, Math.max(1, width - 8));
   steerSegments.forEach((segment, i) => {
@@ -123,6 +123,6 @@ export function renderObservedDetailLines(node: ObservedNode, width: number, pal
     }
   }
   // Visibility, not a cockpit: there is no stop here, by design.
-  lines.push(buildPanelLine(width, [[' stop ', C.label], ['not offered — goodvibes only observes this foreign session', C.dim]]));
+  lines.push(buildPanelLine(width, [[' stop ', C.label], ['not offered: goodvibes only observes this foreign session', C.dim]]));
   return lines;
 }

package/src/panels/fleet-panel-format.ts

@@ -29,7 +29,7 @@ import { renderPoolSummary, type WorkstreamGraphSnapshot } from './workstream-gr
 // left over after the fixed columns + gaps; on hostile (narrow) widths the
 // trailing columns simply clip (buildAlignedRow/buildSelectablePanelLine stop
 // writing once a cell would overflow the row) rather than throwing or
-// wrapping — the tree stays readable, just denser.
+// wrapping, the tree stays readable, just denser.
 const KIND_W = 8;
 const ELAPSED_W = 7;
 const TOKENS_W = 7;
@@ -67,7 +67,7 @@ export function formatFleetTokens(usage: ProcessUsage | undefined): string {
   return total >= 1000 ? `${(total / 1000).toFixed(1)}k` : String(total);
 }
 
-/** Honest cost display: never a fabricated $0.00 — 'unpriced' when costState says so. */
+/** Honest cost display: never a fabricated $0.00, 'unpriced' when costState says so. */
 export function formatFleetCost(costUsd: number | null | undefined, costState: ProcessCostState): string {
   if (!hasFleetCost(costUsd, costState)) return 'unpriced';
   const formatted = formatAgentCost(costUsd as number);
@@ -92,7 +92,7 @@ export function renderFleetRowLine(
   const C = palette;
   const node = row.node;
   // Observed foreign agents render as their own visibility row (no cost/steer
-  // columns, no stop marker) — see fleet-observed-render.ts.
+  // columns, no stop marker), see fleet-observed-render.ts.
   if (isObservedExternalNode(node)) return renderObservedRowLine(node, width, palette);
   const disp = fleetStateDisplay(node.state, stopping, blocked);
   const color = toneColor(disp.tone, C);
@@ -104,7 +104,7 @@ export function renderFleetRowLine(
   const label = `${row.treePrefix}${node.label}${attemptBadge}`;
   // Activity column doubles as the badge slot, in priority order:
   //   stopping > waiting-on-human text ('blocked on you' / 'needs your input')
-  //   > the read-model HEADLINE (derived from task/phase identity only —
+  //   > the read-model HEADLINE (derived from task/phase identity only,
   //   replaced in place, never a scrolling feed) with the stall marker
   //   ('quiet Nm') appended when the node has gone observably silent.
   // Nodes without a headline fall back to the live currentActivity text.
@@ -155,14 +155,14 @@ export function renderFleetRowLine(
  * The selected-node detail block under the fleet tree. Pure (extracted from
  * FleetPanel.renderDetail to hold that file under the 800-line architecture
  * cap). `stopping`/`blocked` are display-only overrides the caller derives from
- * the stop tracker + node state — mirror the tree row exactly so the literal
+ * the stop tracker + node state, mirror the tree row exactly so the literal
  * 'state' text never claims a past-tense outcome mid-write, and a
  * blocked-on-user node reads 'blocked on you' here too.
  */
 /**
  * The reviewer's acceptance checklist + verdict, from the fleet node's served
  * `review` field (ProcessReviewSummary, rides fleet.snapshot/list). Rendered
- * only when a review has completed — never an empty shell. Each item shows
+ * only when a review has completed, never an empty shell. Each item shows
  * whether it was verified, the evidence, and (when present) how it was
  * exercised, matching what the webui's review detail surfaces.
  */
@@ -180,8 +180,8 @@ export function renderReviewLines(review: ProcessReviewSummary, width: number, p
     ]),
   ];
   if (review.checklist.length === 0) {
-    // Empty checklist is itself a gate failure — say so honestly, don't hide it.
-    lines.push(buildPanelLine(width, [['   ', C.dim], ['(the reviewer emitted no acceptance checklist — a gate failure)', failTone]]));
+    // Empty checklist is itself a gate failure, say so honestly, don't hide it.
+    lines.push(buildPanelLine(width, [['   ', C.dim], ['(the reviewer emitted no acceptance checklist; a gate failure)', failTone]]));
     return lines;
   }
   for (const it of review.checklist) {
@@ -209,7 +209,7 @@ export function renderReviewLines(review: ProcessReviewSummary, width: number, p
 /**
  * The task graph's edges + elastic-pool posture for a workstream row, rendered
  * IN the fleet detail (the tree shows nodes; edges/pool used to be reachable
- * only via /graph — /graph still works). Fetched lazily and cached by fleet-acts;
+ * only via /graph, /graph still works). Fetched lazily and cached by fleet-acts;
  * rendered only once a snapshot is in hand. An empty graph states so honestly.
  */
 export function renderGraphPostureLines(graph: WorkstreamGraphSnapshot, width: number, palette: PanelPalette = DEFAULT_PANEL_PALETTE): Line[] {
@@ -244,7 +244,7 @@ export function renderFleetDetailLines(
 ): Line[] {
   const C = palette;
   // Observed foreign agents drill into their own detail (facts + steer-or-reason,
-  // never a stop) — see fleet-observed-render.ts. The drill-in steer draft (when
+  // never a stop), see fleet-observed-render.ts. The drill-in steer draft (when
   // the composer is open on this row) renders an input line in that detail.
   if (isObservedExternalNode(node)) return renderObservedDetailLines(node, width, palette, observedSteerDraft);
   const disp = fleetStateDisplay(node.state, stopping, blocked);
@@ -277,7 +277,7 @@ export function renderFleetDetailLines(
     [formatFleetCost(node.costUsd, node.costState), C.value],
   ]);
   // The headline (task/phase identity, replaced in place) gets its own row
-  // when present, with the stall marker appended — the detail block mirrors
+  // when present, with the stall marker appended, the detail block mirrors
   // exactly what the tree row's steady slot shows.
   const stallMarker = fleetStallMarker(node);
   const headlineText = node.headline
@@ -300,12 +300,12 @@ export function renderFleetDetailLines(
   const line4 = buildPanelLine(width, [[' approvals ', C.label], ['—', C.dim]]);
   const isolationDetail = node.kind === 'work-item' ? formatWorkItemIsolationDetailFromRaw(node.raw) : null;
   // A merge-conflict row shows its STRUCTURED conflicting-path list, wrapped so a
-  // long path is fully readable — never clipped (STEP 4: the conflict row acts,
+  // long path is fully readable, never clipped (STEP 4: the conflict row acts,
   // and the operator sees exactly which files need resolving before pressing Enter).
   const conflictFiles = node.kind === 'work-item' ? conflictFilesFromRaw(node.raw) : null;
   const conflictLines: Line[] = conflictFiles
     ? [
-      buildPanelLine(width, [[' conflicts ', C.label], [`${conflictFiles.length} file(s) — press Enter to resolve`, C.warn ?? DEFAULT_PANEL_PALETTE.warn]]),
+      buildPanelLine(width, [[' conflicts ', C.label], [`${conflictFiles.length} file(s): press Enter to resolve`, C.warn ?? DEFAULT_PANEL_PALETTE.warn]]),
       // Prefix is 3 spaces of indent + a 2-col bullet/continuation marker, so
       // wrap the path at width-5 to keep the composed line within `width`
       // (a hard-wrapped long path is fully readable, never clipped).
@@ -317,7 +317,7 @@ export function renderFleetDetailLines(
     ]
     : [];
   // The reviewer's acceptance checklist + verdict, when a review has completed
-  // (served on node.review; absent before any review — never an empty shell).
+  // (served on node.review; absent before any review, never an empty shell).
   const reviewLines = node.review ? renderReviewLines(node.review, width, C) : [];
   // The task graph's edges/pool posture for a workstream row (fetched + cached
   // by fleet-acts); rendered in-panel under the chain, /graph still available.

package/src/panels/fleet-panel-worktree-detail.ts

@@ -1,7 +1,7 @@
 // ---------------------------------------------------------------------------
 // fleet-panel-worktree-detail.ts
 //
-// NET-NEW helper (not moved code — it was authored here because fleet-panel.ts
+// NET-NEW helper (not moved code, it was authored here because fleet-panel.ts
 // sits at the architecture check's 800-line cap, scripts/check-architecture.ts):
 // a single pure helper for the Fleet panel's per-work-item detail view, so a
 // new panel feature doesn't have to fight that cap inline.
@@ -14,7 +14,7 @@ import type { WorkItem } from '@pellux/goodvibes-sdk/platform/orchestration';
  * node detail (fleet-panel.ts renderDetail), or null for a shared-isolation
  * item (or any node that isn't a work item). Inferred from the item's OWN
  * fields (worktreePath/worktreeBranch/mergeState) rather than a
- * workstream-level flag — adaptWorkItem's ProcessNode.raw carries
+ * workstream-level flag, adaptWorkItem's ProcessNode.raw carries
  * `{ item, workstreamId }`, not the full Workstream, and these fields are
  * set ONLY when the owning workstream's isolation is 'worktree'
  * (engine.ts/worktree-isolation.ts, SDK), so they are a reliable
@@ -26,22 +26,22 @@ export function formatWorkItemIsolationDetail(item: WorkItem): string | null {
   switch (item.mergeState) {
     case 'merged':
       // Papercut sweep item 3: worktree-isolation items whose integration had
-      // no changes to merge (mergeState 'merged', mergeHash undefined — a
+      // no changes to merge (mergeState 'merged', mergeHash undefined, a
       // documented cosmetic case, not an error) used to read as a bare/awkward
       // "merged (nothing to merge)". "merged (no changes)" says the same thing
       // in the same shape as the other merge-state phrases below.
-      return item.mergeHash ? `worktree — merged ${item.mergeHash.slice(0, 12)}` : 'worktree — merged (no changes)';
+      return item.mergeHash ? `worktree: merged ${item.mergeHash.slice(0, 12)}` : 'worktree: merged (no changes)';
     case 'conflict':
-      return 'worktree — merge-conflict (kept for inspection)';
+      return 'worktree: merge-conflict (kept for inspection)';
     case 'pending':
-      return 'worktree — merge pending';
+      return 'worktree: merge pending';
     case 'n-a':
     default:
-      return item.worktreeKept ? 'worktree — kept' : 'worktree — not yet integrated';
+      return item.worktreeKept ? 'worktree: kept' : 'worktree: not yet integrated';
   }
 }
 
-/** `node.raw` for a 'work-item' ProcessNode is `{ item, workstreamId }` (unknown to the panel's own types) — this narrows without fleet-panel.ts needing its own WorkItem import at the call site. Non-work-item nodes (raw is undefined/some other shape) fall through to null. */
+/** `node.raw` for a 'work-item' ProcessNode is `{ item, workstreamId }` (unknown to the panel's own types), this narrows without fleet-panel.ts needing its own WorkItem import at the call site. Non-work-item nodes (raw is undefined/some other shape) fall through to null. */
 export function formatWorkItemIsolationDetailFromRaw(raw: unknown): string | null {
   const item = (raw as { item?: WorkItem } | undefined)?.item;
   return item ? formatWorkItemIsolationDetail(item) : null;