@pellux/goodvibes-tui 0.28.0 → 1.0.0

package/src/panels/ops-control-panel.ts

@@ -9,37 +9,30 @@
  */
 import type { Line } from '../types/grid.ts';
 import { fitDisplay, truncateDisplay } from '../utils/terminal-width.ts';
-import type { OpsEvent } from '@/runtime/index.ts';
+import type { OpsApi, OpsEvent } from '@/runtime/index.ts';
 import type { UiEventFeed } from '../runtime/ui-events.ts';
 import type { OpsAuditEntry } from '../runtime/diagnostics/panels/ops.ts';
 import { OpsPanel } from '../runtime/diagnostics/panels/ops.ts';
 import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import {
   buildKeyValueLine,
   buildKeyboardHints,
   buildPanelLine,
   DEFAULT_PANEL_PALETTE,
+  extendPalette,
   type PanelPalette,
 } from './polish.ts';
 
 // ── Colour palette ──────────────────────────────────────────────────────────
-const C = {
-  ...DEFAULT_PANEL_PALETTE,
-  header:     '#94a3b8',
-  headerBg:   '#1e293b',
-  success:    '#22c55e',
-  rejected:   '#f97316',
-  error:      '#ef4444',
-  dim:        '#4b5563',
-  label:      '#64748b',
-  value:      '#cbd5e1',
-  note:       '#eab308',
-  seq:        '#475569',
-  taskColor:  '#22d3ee',
-  agentColor: '#a78bfa',
-  empty:      '#334155',
-  selectBg:   '#0f172a',
-} as const;
+// Domain accents only; base chrome (header/headerBg/dim/label/value/good/bad/
+// warn/empty/selectBg) comes from DEFAULT_PANEL_PALETTE.
+const C = extendPalette(DEFAULT_PANEL_PALETTE, {
+  rejected:   '#f97316',   // rejected-outcome badge — distinct from success/error
+  taskColor:  '#22d3ee',   // task-target tag
+  agentColor: '#a78bfa',   // agent-target tag
+} as const);
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -53,9 +46,9 @@ function fmtTime(ts: number): string {
 
 function outcomeColor(outcome: OpsAuditEntry['outcome']): string {
   switch (outcome) {
-    case 'success':  return C.success;
+    case 'success':  return C.good;
     case 'rejected': return C.rejected;
-    case 'error':    return C.error;
+    case 'error':    return C.bad;
   }
 }
 
@@ -71,18 +64,41 @@ function targetColor(kind: OpsAuditEntry['targetKind']): string {
   return kind === 'task' ? C.taskColor : C.agentColor;
 }
 
+// ── Operator intervention actions ───────────────────────────────────────────
+// Target-entry mode: c/p/u/y act on the currently *selected* audit row's
+// target (task or agent) rather than requiring a typed id, mirroring the
+// `/ops task <action> <id>` / `/ops agent cancel <id>` slash commands.
+
+type OpsAction = 'cancel' | 'pause' | 'resume' | 'retry';
+
+interface OpsActionSubject {
+  readonly action: OpsAction;
+  readonly targetKind: OpsAuditEntry['targetKind'];
+  readonly targetId: string;
+}
+
+const ACTION_VERB: Record<OpsAction, string> = {
+  cancel: 'Cancel',
+  pause: 'Pause',
+  resume: 'Resume',
+  retry: 'Retry',
+};
+
 // ── OpsControlPanel ──────────────────────────────────────────────────────────
 
 export class OpsControlPanel extends ScrollableListPanel<OpsAuditEntry> {
   private readonly _opsPanel: OpsPanel;
+  private readonly _opsApi: OpsApi | undefined;
   private _unsub: (() => void) | null = null;
+  private _confirm: ConfirmState<OpsActionSubject> | null = null;
 
-  public constructor(eventFeed: UiEventFeed<OpsEvent>) {
-    super('ops-control', 'Ops Control', 'Q', 'agent');
+  public constructor(eventFeed: UiEventFeed<OpsEvent>, opsApi?: OpsApi) {
+    super('ops-control', 'Ops Control', '◓', 'runtime-ops');
     this.showSelectionGutter = true; // I5: non-color selection affordance
     this.filterEnabled = true;
     this.filterLabel = 'Filter audit';
     this._opsPanel = new OpsPanel(eventFeed);
+    this._opsApi = opsApi;
     this._unsub = this._opsPanel.subscribe(() => this.markDirty());
   }
 
@@ -115,6 +131,94 @@ export class OpsControlPanel extends ScrollableListPanel<OpsAuditEntry> {
       || entry.outcome.toLowerCase().includes(q);
   }
 
+  // -------------------------------------------------------------------------
+  // Input — target-entry mode dispatch (acts on the selected audit row)
+  // -------------------------------------------------------------------------
+
+  public override handleInput(key: string): boolean {
+    if (this.lastError !== null) this.clearError();
+
+    if (this._confirm) {
+      const result = handleConfirmInput(this._confirm, key);
+      if (result === 'confirmed') {
+        this._executeConfirmed(this._confirm.subject);
+        this._confirm = null;
+        this.markDirty();
+        return true;
+      }
+      if (result === 'cancelled') {
+        this._confirm = null;
+        this.markDirty();
+      }
+      return true;
+    }
+
+    if (!this.filterActive) {
+      switch (key) {
+        case 'c': this._requestAction('cancel'); return true;
+        case 'p': this._requestAction('pause'); return true;
+        case 'u': this._requestAction('resume'); return true;
+        case 'y': this._requestAction('retry'); return true;
+        default: break;
+      }
+    }
+
+    return super.handleInput(key);
+  }
+
+  private _requestAction(action: OpsAction): void {
+    const selected = this.getSelectedItem();
+    if (!selected) return;
+    if (action !== 'cancel' && selected.targetKind === 'agent') {
+      this.setError(`Only cancel is supported for agent targets ("${action}" is task-only).`);
+      return;
+    }
+    this._confirm = {
+      subject: { action, targetKind: selected.targetKind, targetId: selected.targetId },
+      label: `${selected.targetKind} ${selected.targetId}`,
+      verb: ACTION_VERB[action],
+    };
+    this.markDirty();
+  }
+
+  private _executeConfirmed(subject: OpsActionSubject): void {
+    if (!this._opsApi) {
+      this.setError('Ops API is not wired for this runtime.');
+      return;
+    }
+    try {
+      if (subject.targetKind === 'agent') {
+        this._opsApi.agents.cancel(subject.targetId);
+      } else {
+        switch (subject.action) {
+          case 'cancel': this._opsApi.tasks.cancel(subject.targetId); break;
+          case 'pause':  this._opsApi.tasks.pause(subject.targetId); break;
+          case 'resume': this._opsApi.tasks.resume(subject.targetId); break;
+          case 'retry':  this._opsApi.tasks.retry(subject.targetId); break;
+        }
+      }
+    } catch (err) {
+      // Dispatched actions re-appear as OPS_AUDIT rows regardless of legality
+      // (OpsControlPlane audits rejections too); this surfaces the rare case
+      // where the target vanished before the audit event was emitted.
+      this.setError(summarizeError(err));
+    }
+  }
+
+  /** Live posture: tasks currently eligible for intervention, independent of the audit log. */
+  private _postureCounts(): { running: number; blocked: number; retryable: number } {
+    const tasks = this._opsApi?.tasks.snapshot().tasks ?? [];
+    let running = 0;
+    let blocked = 0;
+    let retryable = 0;
+    for (const task of tasks) {
+      if (task.status === 'running') running++;
+      else if (task.status === 'blocked') blocked++;
+      else if (task.status === 'failed' || task.status === 'cancelled') retryable++;
+    }
+    return { running, blocked, retryable };
+  }
+
   protected renderItem(entry: OpsAuditEntry, _index: number, _selected: boolean, width: number): Line {
     const seqStr   = String(entry.seq).padStart(4, ' ');
     const timeStr  = fmtTime(entry.ts);
@@ -127,13 +231,13 @@ export class OpsControlPanel extends ScrollableListPanel<OpsAuditEntry> {
     const noteRaw  = truncateDisplay(entry.note ?? entry.errorMessage ?? '', Math.max(0, width - 63));
 
     const segs: Array<[string, string, string?]> = [
-      [` ${seqStr} `, C.seq],
+      [` ${seqStr} `, C.dim],
       [`${timeStr} `, C.dim],
       [`${action} `, C.value],
       [`${target}  `, targetColor(entry.targetKind)],
       [outLabel, outcomeColor(entry.outcome)],
     ];
-    if (noteRaw) segs.push([` ${noteRaw}`, C.note]);
+    if (noteRaw) segs.push([` ${noteRaw}`, C.warn]);
     return buildPanelLine(width, segs);
   }
 
@@ -142,7 +246,9 @@ export class OpsControlPanel extends ScrollableListPanel<OpsAuditEntry> {
   }
 
   protected override getEmptyStateActions(): Array<{ command: string; summary: string }> {
-    return [{ command: '/cockpit', summary: 'open the cockpit and drive runtime interventions from the control rooms' }];
+    // No signpost — the live posture row in the header (running/blocked/retryable
+    // task counts) already tells the operator whether there is anything to act on.
+    return [];
   }
 
   public render(width: number, height: number): Line[] {
@@ -159,17 +265,24 @@ export class OpsControlPanel extends ScrollableListPanel<OpsAuditEntry> {
       else errored++;
     }
 
+    const posture = this._postureCounts();
+
     const headerLines: Line[] = [
       buildKeyValueLine(width, [
         { label: 'logged', value: String(entries.length), valueColor: entries.length > 0 ? C.value : C.dim },
-        { label: 'ok', value: String(ok), valueColor: ok > 0 ? C.success : C.dim },
+        { label: 'ok', value: String(ok), valueColor: ok > 0 ? C.good : C.dim },
         { label: 'rejected', value: String(rejected), valueColor: rejected > 0 ? C.rejected : C.dim },
-        { label: 'errors', value: String(errored), valueColor: errored > 0 ? C.error : C.dim },
+        { label: 'errors', value: String(errored), valueColor: errored > 0 ? C.bad : C.dim },
+      ], C),
+      buildKeyValueLine(width, [
+        { label: 'running', value: String(posture.running), valueColor: posture.running > 0 ? C.warn : C.dim },
+        { label: 'blocked', value: String(posture.blocked), valueColor: posture.blocked > 0 ? C.warn : C.dim },
+        { label: 'retryable', value: String(posture.retryable), valueColor: posture.retryable > 0 ? C.info : C.dim },
       ], C),
       buildPanelLine(width, [['  SEQ  TIME      ACTION          TARGET             OUT    NOTE', C.label]]),
     ];
 
-    const selected = entries[this.selectedIndex];
+    const selected = this.getSelectedItem();
     const footerLines: Line[] = [];
     if (selected) {
       const detail = selected.note ?? selected.errorMessage ?? '(no note)';
@@ -186,10 +299,13 @@ export class OpsControlPanel extends ScrollableListPanel<OpsAuditEntry> {
         ]),
         buildPanelLine(width, [
           ['  ', C.label],
-          [truncateDisplay(detail, Math.max(0, width - 4)), C.note],
+          [truncateDisplay(detail, Math.max(0, width - 4)), C.warn],
         ]),
       );
     }
+    if (this._confirm) {
+      footerLines.push(...renderConfirmLines(width, this._confirm));
+    }
     footerLines.push(
       this.filterActive
         ? buildKeyboardHints(width, [
@@ -199,6 +315,7 @@ export class OpsControlPanel extends ScrollableListPanel<OpsAuditEntry> {
           ], C)
         : buildKeyboardHints(width, [
             { keys: 'Up/Down', label: 'browse log' },
+            { keys: 'c/p/u/y', label: 'cancel/pause/resume/retry selected' },
             { keys: '/', label: 'filter' },
           ], C),
     );

package/src/panels/ops-strategy-panel.ts

@@ -11,7 +11,7 @@ import { BasePanel } from './base-panel.ts';
 import type { Line } from '../types/grid.ts';
 import { getDisplayWidth } from '../utils/terminal-width.ts';
 import type { PlannerDecision, ExecutionStrategy } from '@pellux/goodvibes-sdk/platform/core';
-import type { PlannerEvent } from '@/runtime/index.ts';
+import type { PlannerEvent, PlanRuntimeService } from '@/runtime/index.ts';
 import type { UiEventFeed } from '../runtime/ui-events.ts';
 import type { OpsStrategyQuery } from '../runtime/ui-service-queries.ts';
 import {
@@ -50,6 +50,15 @@ const STRATEGY_ICON: Record<ExecutionStrategy, string> = {
   remote:     '▸',
 };
 
+// Cycle order for the o (override) and m (mode) keys — mirrors /plan's
+// documented strategy list (planner-command-handler.ts VALID_STRATEGIES).
+const STRATEGY_CYCLE: readonly ExecutionStrategy[] = ['auto', 'single', 'cohort', 'background', 'remote'];
+
+function nextStrategy(current: ExecutionStrategy): ExecutionStrategy {
+  const idx = STRATEGY_CYCLE.indexOf(current);
+  return STRATEGY_CYCLE[(idx + 1) % STRATEGY_CYCLE.length]!;
+}
+
 // ---------------------------------------------------------------------------
 // OpsStrategyPanel
 // ---------------------------------------------------------------------------
@@ -59,13 +68,16 @@ export class OpsStrategyPanel extends BasePanel {
   private scrollOffset = 0;
   private history: PlannerDecision[] = [];
   private readonly adaptivePlanner: OpsStrategyQuery;
+  private readonly planRuntime: PlanRuntimeService | undefined;
 
   constructor(
     private readonly plannerEvents: UiEventFeed<PlannerEvent>,
     adaptivePlanner: OpsStrategyQuery,
+    planRuntime?: PlanRuntimeService,
   ) {
-    super('ops', 'Ops', 'O', 'agent');
+    super('ops', 'Ops', '◫', 'runtime-ops');
     this.adaptivePlanner = adaptivePlanner;
+    this.planRuntime = planRuntime;
   }
 
   override onActivate(): void {
@@ -89,6 +101,8 @@ export class OpsStrategyPanel extends BasePanel {
   }
 
   handleInput(key: string): boolean {
+    if (this.lastError !== null) this.clearError();
+
     if (key === 'up' || key === 'k') {
       this.scrollOffset = Math.max(0, this.scrollOffset - 1);
       this.markDirty();
@@ -109,18 +123,72 @@ export class OpsStrategyPanel extends BasePanel {
       this.markDirty();
       return true;
     }
+    if (key === 'o') {
+      this._cycleOverride();
+      return true;
+    }
+    if (key === 'c') {
+      this._clearOverride();
+      return true;
+    }
+    if (key === 'm') {
+      this._cycleMode();
+      return true;
+    }
     return false;
   }
 
+  // -------------------------------------------------------------------------
+  // Override verbs — o=cycle override, c=clear, m=cycle mode, all dispatched
+  // through the same /plan subcommand bridge the slash command uses
+  // (planning-runtime.ts), so panel and slash-command behavior stay identical.
+  // -------------------------------------------------------------------------
+
+  private _cycleOverride(): void {
+    if (!this.planRuntime) {
+      this.setError('Plan runtime is not wired for this runtime.');
+      return;
+    }
+    const current = this.adaptivePlanner.getOverride() ?? this.adaptivePlanner.getMode();
+    const result = this.planRuntime('override', [nextStrategy(current)]);
+    if (!result.ok) this.setError(result.output);
+    this.markDirty();
+  }
+
+  private _clearOverride(): void {
+    if (!this.planRuntime) {
+      this.setError('Plan runtime is not wired for this runtime.');
+      return;
+    }
+    const result = this.planRuntime('clear', []);
+    if (!result.ok) this.setError(result.output);
+    this.markDirty();
+  }
+
+  private _cycleMode(): void {
+    if (!this.planRuntime) {
+      this.setError('Plan runtime is not wired for this runtime.');
+      return;
+    }
+    const result = this.planRuntime('mode', [nextStrategy(this.adaptivePlanner.getMode())]);
+    if (!result.ok) this.setError(result.output);
+    this.markDirty();
+  }
+
   render(width: number, height: number): Line[] {
     const latest   = this.adaptivePlanner.getLatest();
     const mode     = this.adaptivePlanner.getMode();
     const override = this.adaptivePlanner.getOverride();
     const intro = 'Review adaptive execution planner decisions, overrides, and recent strategy history.';
+    const errorLine = this.renderErrorLine(width);
     const footerLines = [
+      ...(errorLine ? [errorLine] : []),
       buildKeyboardHints(width, [
         { keys: 'Up/Down', label: 'scroll history' },
         { keys: 'g/G', label: 'top/bottom' },
+        { keys: 'o', label: 'cycle override' },
+        { keys: 'c', label: 'clear override' },
+        { keys: 'm', label: 'cycle mode' },
       ], C),
     ];
     const statusLines: Line[] = [
@@ -153,8 +221,8 @@ export class OpsStrategyPanel extends BasePanel {
             lines: buildEmptyState(
               width,
               ' No decisions recorded yet',
-              'Adaptive planner decisions appear here once the planner begins selecting strategies. Run agents or use /ops to drive runtime activity.',
-              [{ command: '/ops', summary: 'open the operator control room to drive planner activity' }],
+              'Adaptive planner decisions appear here once the planner begins selecting strategies. Seed or inspect an execution plan to drive runtime activity.',
+              [{ command: '/plan', summary: 'seed or inspect an execution plan; strategy decisions start appearing here once it runs' }],
               C,
             ),
           },