@pellux/goodvibes-tui 0.19.84 → 0.19.86

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.84",
+  "version": "0.19.86",
   "description": "Terminal-native GoodVibes product for coding, operations, automation, knowledge, channels, and daemon-backed control-plane workflows.",
   "type": "module",
   "main": "src/main.ts",
@@ -97,7 +97,7 @@
     "@anthropic-ai/vertex-sdk": "^0.16.0",
     "@ast-grep/napi": "^0.42.0",
     "@aws/bedrock-token-generator": "^1.1.0",
-    "@pellux/goodvibes-sdk": "0.33.19",
+    "@pellux/goodvibes-sdk": "0.33.21",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

package/src/input/command-registry.ts

@@ -144,6 +144,7 @@ export interface CommandWorkspaceUiServices {
   bookmarkManager?: import('@pellux/goodvibes-sdk/platform/bookmarks').BookmarkManager;
   projectPlanningService?: import('@pellux/goodvibes-sdk/platform/knowledge').ProjectPlanningService;
   projectPlanningProjectId?: string;
+  workPlanStore?: import('../work-plans/work-plan-store.ts').WorkPlanStore;
 }
 
 export interface CommandWorkspaceServices

package/src/input/commands/work-plan-runtime.ts

@@ -0,0 +1,169 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import type { WorkPlanItemStatus, WorkPlanStore } from '../../work-plans/work-plan-store.ts';
+import { WORK_PLAN_STATUSES } from '../../work-plans/work-plan-store.ts';
+import { requirePanelManager } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+const STATUS_COMMANDS: Record<string, WorkPlanItemStatus> = {
+  pending: 'pending',
+  todo: 'pending',
+  start: 'in_progress',
+  active: 'in_progress',
+  progress: 'in_progress',
+  block: 'blocked',
+  blocked: 'blocked',
+  done: 'done',
+  complete: 'done',
+  fail: 'failed',
+  failed: 'failed',
+  cancel: 'cancelled',
+  cancelled: 'cancelled',
+};
+
+function getStore(ctx: import('../command-registry.ts').CommandContext): WorkPlanStore | null {
+  return ctx.workspace.workPlanStore ?? null;
+}
+
+function openPanel(ctx: import('../command-registry.ts').CommandContext): void {
+  if (ctx.showPanel) {
+    ctx.showPanel('work-plan');
+    return;
+  }
+  const panelManager = requirePanelManager(ctx);
+  panelManager.open('work-plan');
+  panelManager.show();
+  ctx.renderRequest();
+}
+
+function formatList(store: WorkPlanStore): string {
+  const items = store.listItems();
+  if (items.length === 0) return 'Work plan is empty. Add one with /workplan add <title>.';
+  return [
+    `Work Plan (${items.length})`,
+    ...items.map((item) => {
+      const owner = item.owner ? ` @${item.owner}` : '';
+      return `  ${item.id}  ${item.status.padEnd(11)} ${item.title}${owner}`;
+    }),
+  ].join('\n');
+}
+
+function parseAddArgs(args: string[]): { title: string; owner?: string; source?: string; notes?: string } {
+  const titleParts: string[] = [];
+  let owner: string | undefined;
+  let source: string | undefined;
+  let notes: string | undefined;
+  for (let i = 0; i < args.length; i++) {
+    const part = args[i] ?? '';
+    if (part === '--owner' && args[i + 1]) {
+      owner = args[++i];
+      continue;
+    }
+    if (part === '--source' && args[i + 1]) {
+      source = args[++i];
+      continue;
+    }
+    if (part === '--notes' && args[i + 1]) {
+      notes = args.slice(i + 1).join(' ').trim();
+      break;
+    }
+    titleParts.push(part);
+  }
+  return {
+    title: titleParts.join(' ').trim(),
+    ...(owner ? { owner } : {}),
+    ...(source ? { source } : {}),
+    ...(notes ? { notes } : {}),
+  };
+}
+
+export function registerWorkPlanRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'workplan',
+    aliases: ['wp', 'todo'],
+    description: 'Track a persistent workspace-scoped work plan',
+    usage: '[panel|list|show|add <title> [--owner name] [--source label] [--notes text]|done <id>|start <id>|block <id>|fail <id>|cancel <id>|pending <id>|remove <id>|clear-done]',
+    argsHint: '[panel|add|list|done]',
+    handler(args, ctx) {
+      const store = getStore(ctx);
+      if (!store) {
+        ctx.print('Work plan store is not available in this runtime.');
+        return;
+      }
+      const subcommand = (args[0] ?? 'panel').toLowerCase();
+      try {
+        if (subcommand === 'panel' || subcommand === 'open') {
+          openPanel(ctx);
+          ctx.print('Opened work plan panel.');
+          return;
+        }
+        if (subcommand === 'list') {
+          ctx.print(formatList(store));
+          return;
+        }
+        if (subcommand === 'show' || subcommand === 'markdown') {
+          ctx.print(store.toMarkdown());
+          return;
+        }
+        if (subcommand === 'add') {
+          const parsed = parseAddArgs(args.slice(1));
+          if (!parsed.title) {
+            ctx.print('Usage: /workplan add <title> [--owner name] [--source label] [--notes text]');
+            return;
+          }
+          const addOptions = {
+            ...(parsed.owner ? { owner: parsed.owner } : {}),
+            source: parsed.source ?? 'manual',
+            ...(parsed.notes ? { notes: parsed.notes } : {}),
+          };
+          const item = store.addItem(parsed.title, addOptions);
+          openPanel(ctx);
+          ctx.print(`Added work plan item ${item.id}.`);
+          return;
+        }
+        if (subcommand === 'remove' || subcommand === 'delete' || subcommand === 'rm') {
+          const id = args[1];
+          if (!id) {
+            ctx.print(`Usage: /workplan ${subcommand} <id>`);
+            return;
+          }
+          const item = store.removeItem(id);
+          ctx.print(`Removed work plan item ${item.id}: ${item.title}`);
+          return;
+        }
+        if (subcommand === 'clear-done' || subcommand === 'clear-completed') {
+          const count = store.clearCompleted();
+          ctx.print(`Cleared ${count} completed/cancelled work plan item${count === 1 ? '' : 's'}.`);
+          return;
+        }
+        if (subcommand === 'cycle' || subcommand === 'toggle') {
+          const id = args[1];
+          if (!id) {
+            ctx.print(`Usage: /workplan ${subcommand} <id>`);
+            return;
+          }
+          const item = store.cycleItemStatus(id);
+          ctx.print(`Updated ${item.id}: ${item.status}.`);
+          return;
+        }
+        const status = STATUS_COMMANDS[subcommand];
+        if (status) {
+          const id = args[1];
+          if (!id) {
+            ctx.print(`Usage: /workplan ${subcommand} <id>`);
+            return;
+          }
+          const item = store.setItemStatus(id, status);
+          ctx.print(`Updated ${item.id}: ${item.status}.`);
+          return;
+        }
+        if (WORK_PLAN_STATUSES.includes(subcommand as WorkPlanItemStatus)) {
+          ctx.print(`Usage: /workplan ${subcommand} <id>`);
+          return;
+        }
+        ctx.print(`Unknown workplan subcommand: ${subcommand}`);
+      } catch (error) {
+        ctx.print(summarizeError(error));
+      }
+    },
+  });
+}

package/src/input/commands.ts

@@ -55,6 +55,7 @@ import { registerQrcodeRuntimeCommands } from './commands/qrcode-runtime.ts';
 import { registerOnboardingRuntimeCommands } from './commands/onboarding-runtime.ts';
 import { registerTtsRuntimeCommands } from './commands/tts-runtime.ts';
 import { registerCloudflareRuntimeCommands } from './commands/cloudflare-runtime.ts';
+import { registerWorkPlanRuntimeCommands } from './commands/work-plan-runtime.ts';
 
 /**
  * registerBuiltinCommands - Register all built-in slash commands into the registry.
@@ -104,6 +105,7 @@ export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerOnboardingRuntimeCommands(registry);
   registerTtsRuntimeCommands(registry);
   registerCloudflareRuntimeCommands(registry);
+  registerWorkPlanRuntimeCommands(registry);
   registerLocalRuntimeCommands(registry);
   registerSessionWorkflowCommands(registry);
   registerDiscoveryRuntimeCommands(registry);

package/src/main.ts

@@ -16,7 +16,6 @@ import { PermissionPromptUI } from './permissions/prompt.ts';
 import { CommandRegistry } from './input/command-registry.ts';
 import type { CommandContext } from './input/command-registry.ts';
 import { renderProcessIndicator } from './renderer/process-indicator.ts';
-import { WrfcController } from '@pellux/goodvibes-sdk/platform/agents';
 import { registerBuiltinCommands } from './input/commands.ts';
 import { ScheduleManager } from '@pellux/goodvibes-sdk/platform/tools';
 import { InputHistory } from './input/input-history.ts';
@@ -54,6 +53,7 @@ import { attachSpokenTurnModelRouting, createSpokenTurnInputOptions } from './au
 import { allowTerminalWrite, installTuiTerminalOutputGuard } from './runtime/terminal-output-guard.ts';
 import { ProjectPlanningCoordinator } from './planning/project-planning-coordinator.ts';
 import { buildCommandArgsHint } from './input/command-args-hint.ts';
+import { summarizeRunningAgents } from './renderer/process-summary.ts';
 
 const ALT_SCREEN_ENTER = '\x1b[?1049h';
 const ALT_SCREEN_EXIT  = '\x1b[?1049l';
@@ -483,17 +483,8 @@ async function main() {
       (a) => a.status === 'running' || a.status === 'pending',
     );
     const runtimeAgents = agentSnapshot.active;
-    const runningAgentIds = new Set<string>();
-    let runningAgentProgress: string | undefined;
-    for (const agent of managerAgents) {
-      runningAgentIds.add(agent.id);
-      if (!runningAgentProgress && agent.progress) runningAgentProgress = agent.progress;
-    }
-    for (const agent of runtimeAgents) {
-      runningAgentIds.add(agent.id);
-      if (!runningAgentProgress && agent.latestProgress) runningAgentProgress = agent.latestProgress;
-    }
-    const runningAgentCount = runningAgentIds.size;
+    const runningAgentSummary = summarizeRunningAgents(managerAgents, runtimeAgents, ctx.services.wrfcController.listChains());
+    const runningAgentCount = runningAgentSummary.count;
     const runningProcessCount = processManager.list().filter((p) => !p.status.startsWith('done')).length;
     const cw = getPromptContentWidth();
     const promptInfo = input.getWrappedPromptInfo(cw);
@@ -540,7 +531,7 @@ async function main() {
       runningAgentCount,
       runningProcessCount,
       indicatorFocused: input.indicatorFocused,
-      runningAgentProgress,
+      runningAgentProgress: runningAgentSummary.progress,
       composerMode: composerState.modeLabel,
       composerStatus: composerState.statusLabel,
       composerFlags: composerState.flags,

package/src/panels/builtin/agent.ts

@@ -6,6 +6,7 @@ import { ToolInspectorPanel } from '../tool-inspector-panel.ts';
 import { WrfcPanel } from '../wrfc-panel.ts';
 import { SchedulePanel } from '../schedule-panel.ts';
 import { ProjectPlanningPanel } from '../project-planning-panel.ts';
+import { WorkPlanPanel } from '../work-plan-panel.ts';
 import type { ResolvedBuiltinPanelDeps } from './shared.ts';
 import { requireAutomationManager, requireUiServices } from './shared.ts';
 
@@ -79,6 +80,16 @@ export function registerAgentPanels(manager: PanelManager, deps: ResolvedBuiltin
     },
   });
 
+  manager.registerType({
+    id: 'work-plan',
+    name: 'Work Plan',
+    icon: 'L',
+    category: 'agent',
+    description: 'Persistent workspace checklist for multi-step work and cross-session task tracking',
+    preload: true,
+    factory: () => new WorkPlanPanel(deps.workPlanStore),
+  });
+
   manager.registerType({
     id: 'project-planning',
     name: 'Planning',

package/src/panels/builtin/shared.ts

@@ -96,6 +96,8 @@ export interface BuiltinPanelDeps {
   projectPlanningService?: ProjectPlanningService;
   /** Stable workspace project id for project:<projectId> planning spaces. */
   projectPlanningProjectId?: string;
+  /** TUI-owned persistent work plan store. */
+  workPlanStore?: import('../../work-plans/work-plan-store.ts').WorkPlanStore;
   /** Shared system-messages panel instance attached from boot so low-priority chatter stays out of conversation. */
   systemMessagesPanel?: import('../system-messages-panel.ts').SystemMessagesPanel;
   /** Explicit UI-facing runtime services for agent/process/WRFC/remote panels and modals. */
@@ -124,6 +126,7 @@ export type ResolvedBuiltinPanelDeps = Omit<
   | 'adaptivePlanner'
   | 'projectPlanningService'
   | 'projectPlanningProjectId'
+  | 'workPlanStore'
   | 'policyRuntimeState'
   | 'systemMessagesPanel'
 > & {
@@ -137,6 +140,7 @@ export type ResolvedBuiltinPanelDeps = Omit<
   readonly adaptivePlanner: AdaptivePlanner;
   readonly projectPlanningService: ProjectPlanningService;
   readonly projectPlanningProjectId: string;
+  readonly workPlanStore: import('../../work-plans/work-plan-store.ts').WorkPlanStore;
   readonly policyRuntimeState: PolicyRuntimeState;
   readonly systemMessagesPanel: import('../system-messages-panel.ts').SystemMessagesPanel;
 };
@@ -198,6 +202,10 @@ export function resolveBuiltinPanelDeps(deps: BuiltinPanelDeps): ResolvedBuiltin
       uiServices.planning.projectPlanningProjectId,
       'Project planning project id must be wired at bootstrap for builtin panels.',
     ),
+    workPlanStore: requireBuiltinPanelDep(
+      uiServices.planning.workPlanStore,
+      'Work plan store must be wired at bootstrap for builtin panels.',
+    ),
     policyRuntimeState: requireBuiltinPanelDep(
       uiServices.platform.policyRuntimeState,
       'Policy runtime state must be wired at bootstrap for builtin panels.',

package/src/panels/work-plan-panel.ts

@@ -0,0 +1,175 @@
+import type { Line } from '../types/grid.ts';
+import { UIFactory } from '../renderer/ui-factory.ts';
+import { ScrollableListPanel } from './scrollable-list-panel.ts';
+import type { WorkPlanItem, WorkPlanItemStatus, WorkPlanStore } from '../work-plans/work-plan-store.ts';
+
+const STATUS_LABEL: Record<WorkPlanItemStatus, string> = {
+  pending: '[ ]',
+  in_progress: '[>]',
+  blocked: '[!]',
+  done: '[x]',
+  failed: '[x]',
+  cancelled: '[-]',
+};
+
+const STATUS_COLOR: Record<WorkPlanItemStatus, string> = {
+  pending: '#94a3b8',
+  in_progress: '#38bdf8',
+  blocked: '#f59e0b',
+  done: '#22c55e',
+  failed: '#ef4444',
+  cancelled: '#64748b',
+};
+
+function line(text: string, width: number, style: Parameters<typeof UIFactory.stringToLine>[2] = {}): Line {
+  return UIFactory.stringToLine(text.padEnd(width).slice(0, width), width, style);
+}
+
+function compactDate(value: number): string {
+  return new Date(value).toISOString().replace('T', ' ').slice(0, 16);
+}
+
+function statusName(status: WorkPlanItemStatus): string {
+  return status.replace(/_/g, ' ');
+}
+
+export class WorkPlanPanel extends ScrollableListPanel<WorkPlanItem> {
+  private items: readonly WorkPlanItem[] = [];
+  private lastPlanUpdatedAt = 0;
+
+  constructor(private readonly store: WorkPlanStore) {
+    super('work-plan', 'Work Plan', 'L', 'agent');
+    this.showSelectionGutter = true;
+  }
+
+  onActivate(): void {
+    super.onActivate();
+    this.refresh();
+  }
+
+  render(width: number, height: number): Line[] {
+    this.refresh();
+    return this.renderList(width, height, {
+      title: 'Work Plan',
+      header: this.renderHeader(width),
+      footer: this.renderFooter(width),
+      emptyMessage: 'No work plan items yet',
+    });
+  }
+
+  handleInput(key: string): boolean {
+    if (this.lastError !== null) this.clearError();
+    const item = this.items[this.selectedIndex];
+    try {
+      switch (key) {
+        case ' ':
+        case 'return':
+        case 'enter':
+          if (!item) return false;
+          this.store.cycleItemStatus(item.id);
+          this.refresh();
+          return true;
+        case '1':
+          return this.setSelectedStatus('pending');
+        case '2':
+          return this.setSelectedStatus('in_progress');
+        case '3':
+          return this.setSelectedStatus('blocked');
+        case '4':
+          return this.setSelectedStatus('done');
+        case '5':
+          return this.setSelectedStatus('failed');
+        case '6':
+          return this.setSelectedStatus('cancelled');
+        case 'd':
+        case 'delete':
+          if (!item) return false;
+          this.store.removeItem(item.id);
+          this.refresh();
+          return true;
+        case 'c':
+          this.store.clearCompleted();
+          this.refresh();
+          return true;
+        case 'r':
+          this.refresh(true);
+          return true;
+        default:
+          return super.handleInput(key);
+      }
+    } catch (error) {
+      this.setError(error instanceof Error ? error.message : String(error));
+      return true;
+    }
+  }
+
+  protected getItems(): readonly WorkPlanItem[] {
+    return this.items;
+  }
+
+  protected getEmptyStateActions(): Array<{ command: string; summary: string }> {
+    return [
+      { command: '/workplan add <title>', summary: 'add a persistent item' },
+      { command: '/workplan list', summary: 'print the current plan' },
+    ];
+  }
+
+  protected renderItem(item: WorkPlanItem, _index: number, selected: boolean, width: number): Line {
+    const status = STATUS_LABEL[item.status];
+    const owner = item.owner ? ` @${item.owner}` : '';
+    const source = item.source ? ` (${item.source})` : '';
+    const text = `${status} ${item.title}${owner}${source}`;
+    return line(text, width, {
+      fg: selected ? '#e2e8f0' : STATUS_COLOR[item.status],
+      bg: selected ? '#1e293b' : undefined,
+      bold: selected || item.status === 'in_progress',
+    });
+  }
+
+  private setSelectedStatus(status: WorkPlanItemStatus): boolean {
+    const item = this.items[this.selectedIndex];
+    if (!item) return false;
+    this.store.setItemStatus(item.id, status);
+    this.refresh();
+    return true;
+  }
+
+  private refresh(force = false): void {
+    const plan = this.store.getActivePlan();
+    if (!force && plan.updatedAt === this.lastPlanUpdatedAt && this.items.length === plan.items.length) return;
+    this.items = plan.items;
+    this.lastPlanUpdatedAt = plan.updatedAt;
+    this.clampSelection();
+    this.needsRender = true;
+  }
+
+  private renderHeader(width: number): Line[] {
+    const plan = this.store.getActivePlan();
+    const counts = new Map<WorkPlanItemStatus, number>();
+    for (const status of Object.keys(STATUS_LABEL) as WorkPlanItemStatus[]) counts.set(status, 0);
+    for (const item of plan.items) counts.set(item.status, (counts.get(item.status) ?? 0) + 1);
+    const active = this.items[this.selectedIndex];
+    const header = [
+      line(`Persistent Work Plan`, width, { fg: '#22d3ee', bold: true }),
+      line(`Project: ${plan.projectRoot}`, width, { fg: '#cbd5e1' }),
+      line(
+        `Items: ${plan.items.length}  pending ${counts.get('pending') ?? 0}  active ${counts.get('in_progress') ?? 0}  blocked ${counts.get('blocked') ?? 0}  done ${counts.get('done') ?? 0}`,
+        width,
+        { fg: '#94a3b8' },
+      ),
+      line(`Saved: ${this.store.filePath}`, width, { fg: '#64748b' }),
+    ];
+    if (active) {
+      header.push(line('', width));
+      header.push(line(`Selected: ${active.id}  ${statusName(active.status)}  updated ${compactDate(active.updatedAt)}`, width, { fg: '#a5b4fc' }));
+      if (active.notes) header.push(line(`Notes: ${active.notes}`, width, { fg: '#cbd5e1' }));
+    }
+    return header;
+  }
+
+  private renderFooter(width: number): Line[] {
+    return [
+      line('Enter/Space cycle  1 pending  2 active  3 blocked  4 done  5 failed  6 cancelled  d delete  c clear done  r refresh', width, { fg: '#94a3b8' }),
+    ];
+  }
+}