@pellux/goodvibes-tui 0.19.84 → 0.19.85

package/CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.19.85] — 2026-05-09
+
+### Changes
+- 72733e04 feat: add persistent work plan tracking
+
 ## [0.19.84] — 2026-05-09
 
 ### Changes

package/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml/badge.svg)](https://github.com/mgd34msu/goodvibes-tui/actions/workflows/ci.yml)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Version](https://img.shields.io/badge/version-0.19.84-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.19.85-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
 
 A terminal-native AI coding, operations, automation, knowledge, and integration console with a typed runtime, omnichannel surfaces, structured memory/knowledge, and a raw ANSI renderer.
 

package/docs/foundation-artifacts/operator-contract.json

@@ -3,7 +3,7 @@
   "product": {
     "id": "goodvibes",
     "surface": "operator",
-    "version": "0.33.19"
+    "version": "0.33.20"
   },
   "auth": {
     "modes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.84",
+  "version": "0.19.85",
   "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.20",
     "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/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' }),
+    ];
+  }
+}

package/src/runtime/bootstrap-command-context.ts

@@ -74,6 +74,7 @@ export type CreateBootstrapCommandContextOptions = {
   knowledgeService?: KnowledgeService;
   projectPlanningService?: import('@pellux/goodvibes-sdk/platform/knowledge').ProjectPlanningService;
   projectPlanningProjectId?: string;
+  workPlanStore?: import('../work-plans/work-plan-store.ts').WorkPlanStore;
   providerOptimizer?: import('@pellux/goodvibes-sdk/platform/providers').ProviderOptimizer;
   pluginManager?: PluginManager;
   hookWorkbench?: HookWorkbench;
@@ -142,6 +143,7 @@ export function createBootstrapCommandContext(
     knowledgeService,
     projectPlanningService,
     projectPlanningProjectId,
+    workPlanStore,
     providerOptimizer,
     pluginManager,
     hookWorkbench,
@@ -233,6 +235,7 @@ export function createBootstrapCommandContext(
     bookmarkManager,
     projectPlanningService,
     projectPlanningProjectId,
+    workPlanStore,
   }, shellServices);
   const platform = createBootstrapCommandPlatformSection({ configManager, voiceProviderRegistry, voiceService }, shellServices);
   const extensions = createBootstrapCommandExtensionsSection({

package/src/runtime/bootstrap-command-parts.ts

@@ -87,6 +87,7 @@ export interface BootstrapCommandSectionOptions {
   readonly knowledgeService?: KnowledgeService;
   readonly projectPlanningService?: import('@pellux/goodvibes-sdk/platform/knowledge').ProjectPlanningService;
   readonly projectPlanningProjectId?: string;
+  readonly workPlanStore?: import('../work-plans/work-plan-store.ts').WorkPlanStore;
   readonly pluginManager?: PluginManager;
   readonly hookWorkbench?: HookWorkbench;
   readonly providerOptimizer?: import('@pellux/goodvibes-sdk/platform/providers').ProviderOptimizer;
@@ -313,7 +314,7 @@ export function createBootstrapCommandWorkspaceSection(
   options: Pick<
     BootstrapCommandSectionOptions,
     'keybindingsManager' | 'fileUndoManager' | 'panelManager' | 'profileManager' | 'bookmarkManager'
-    | 'projectPlanningService' | 'projectPlanningProjectId'
+    | 'projectPlanningService' | 'projectPlanningProjectId' | 'workPlanStore'
   >,
   shellServices: BootstrapCommandShellServices,
 ): BootstrapCommandWorkspaceSection {
@@ -325,6 +326,7 @@ export function createBootstrapCommandWorkspaceSection(
     bookmarkManager: options.bookmarkManager,
     projectPlanningService: options.projectPlanningService,
     projectPlanningProjectId: options.projectPlanningProjectId,
+    workPlanStore: options.workPlanStore,
     ...shellServices.workspace,
   };
 }

package/src/runtime/bootstrap-shell.ts

@@ -205,6 +205,7 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     knowledgeService: services.knowledgeService,
     projectPlanningService: services.projectPlanningService,
     projectPlanningProjectId: services.projectPlanningProjectId,
+    workPlanStore: services.workPlanStore,
     providerOptimizer: services.providerOptimizer,
     pluginManager: services.pluginManager,
     hookWorkbench: services.hookWorkbench,

package/src/runtime/services.ts

@@ -84,6 +84,7 @@ import {
   createWorkflowServices,
   type WorkflowServices,
 } from '@pellux/goodvibes-sdk/platform/tools';
+import { WorkPlanStore } from '../work-plans/work-plan-store.ts';
 
 const REGULAR_KNOWLEDGE_DB_FILE = 'knowledge-wiki.sqlite';
 const HOME_GRAPH_KNOWLEDGE_DB_FILE = 'knowledge-home-graph.sqlite';
@@ -171,6 +172,7 @@ export interface RuntimeServices {
   readonly homeGraphService: HomeGraphService;
   readonly projectPlanningService: ProjectPlanningService;
   readonly projectPlanningProjectId: string;
+  readonly workPlanStore: WorkPlanStore;
   readonly memoryStore: MemoryStore;
   readonly memoryRegistry: MemoryRegistry;
   readonly serviceRegistry: ServiceRegistry;
@@ -447,6 +449,11 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
   const projectPlanningService = new ProjectPlanningService(knowledgeStore, {
     defaultProjectId: projectPlanningProjectId,
   });
+  const workPlanStore = new WorkPlanStore({
+    homeDirectory,
+    projectId: projectPlanningProjectId,
+    projectRoot: workingDirectory,
+  });
   const voiceProviders = new VoiceProviderRegistry();
   ensureBuiltinVoiceProviders(voiceProviders);
   const voiceService = new VoiceService(voiceProviders);
@@ -596,6 +603,7 @@ export function createRuntimeServices(options: RuntimeServicesOptions): RuntimeS
     homeGraphService,
     projectPlanningService,
     projectPlanningProjectId,
+    workPlanStore,
     memoryStore,
     memoryRegistry,
     serviceRegistry,

package/src/runtime/ui-services.ts

@@ -81,6 +81,7 @@ export interface UiPlanningServices {
   readonly adaptivePlanner: RuntimeServices['adaptivePlanner'];
   readonly projectPlanningService: RuntimeServices['projectPlanningService'];
   readonly projectPlanningProjectId: RuntimeServices['projectPlanningProjectId'];
+  readonly workPlanStore: RuntimeServices['workPlanStore'];
 }
 
 export interface UiCoordinationServices {
@@ -173,6 +174,7 @@ export function createUiRuntimeServices(
       adaptivePlanner: runtimeServices.adaptivePlanner,
       projectPlanningService: runtimeServices.projectPlanningService,
       projectPlanningProjectId: runtimeServices.projectPlanningProjectId,
+      workPlanStore: runtimeServices.workPlanStore,
     },
     coordination: {
       approvalBroker: runtimeServices.approvalBroker,

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.19.84';
+let _version = '0.19.85';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;

package/src/work-plans/work-plan-store.ts

@@ -0,0 +1,373 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+export const WORK_PLAN_STATUSES = [
+  'pending',
+  'in_progress',
+  'blocked',
+  'done',
+  'failed',
+  'cancelled',
+] as const;
+
+export type WorkPlanItemStatus = typeof WORK_PLAN_STATUSES[number];
+
+export interface WorkPlanLinkTargets {
+  readonly agentId?: string;
+  readonly wrfcId?: string;
+  readonly taskId?: string;
+  readonly sessionId?: string;
+}
+
+export interface WorkPlanItem {
+  readonly id: string;
+  readonly title: string;
+  readonly status: WorkPlanItemStatus;
+  readonly owner?: string;
+  readonly source?: string;
+  readonly notes?: string;
+  readonly linked?: WorkPlanLinkTargets;
+  readonly createdAt: number;
+  readonly updatedAt: number;
+  readonly completedAt?: number;
+}
+
+export interface WorkPlan {
+  readonly id: string;
+  readonly projectId: string;
+  readonly projectRoot: string;
+  readonly title: string;
+  readonly items: readonly WorkPlanItem[];
+  readonly activeItemId?: string;
+  readonly source?: string;
+  readonly createdAt: number;
+  readonly updatedAt: number;
+}
+
+export interface WorkPlanStoreOptions {
+  readonly homeDirectory: string;
+  readonly projectId: string;
+  readonly projectRoot: string;
+}
+
+export interface AddWorkPlanItemOptions {
+  readonly status?: WorkPlanItemStatus;
+  readonly owner?: string;
+  readonly source?: string;
+  readonly notes?: string;
+  readonly linked?: WorkPlanLinkTargets;
+}
+
+export interface UpdateWorkPlanItemPatch {
+  readonly title?: string;
+  readonly status?: WorkPlanItemStatus;
+  readonly owner?: string | null;
+  readonly source?: string | null;
+  readonly notes?: string | null;
+  readonly linked?: WorkPlanLinkTargets | null;
+}
+
+function nowMs(): number {
+  return Date.now();
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+
+function isWorkPlanStatus(value: unknown): value is WorkPlanItemStatus {
+  return typeof value === 'string' && WORK_PLAN_STATUSES.includes(value as WorkPlanItemStatus);
+}
+
+function safeFileId(projectId: string, projectRoot: string): string {
+  const normalized = projectId.trim() || 'project';
+  const safe = normalized.replace(/[^A-Za-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '');
+  if (safe.length > 0 && safe.length <= 96) return safe;
+  const hash = createHash('sha256').update(`${projectId}\0${projectRoot}`).digest('hex').slice(0, 16);
+  return `${safe.slice(0, 80) || 'project'}-${hash}`;
+}
+
+function createPlanId(projectId: string, projectRoot: string): string {
+  const hash = createHash('sha256').update(`${projectId}\0${projectRoot}`).digest('hex').slice(0, 12);
+  return `wp-${hash}`;
+}
+
+function createItemId(): string {
+  return `wpi-${randomUUID().slice(0, 8)}`;
+}
+
+function normalizeLinked(value: unknown): WorkPlanLinkTargets | undefined {
+  if (!isObject(value)) return undefined;
+  const agentId = readString(value.agentId);
+  const wrfcId = readString(value.wrfcId);
+  const taskId = readString(value.taskId);
+  const sessionId = readString(value.sessionId);
+  const linked: WorkPlanLinkTargets = {
+    ...(agentId ? { agentId } : {}),
+    ...(wrfcId ? { wrfcId } : {}),
+    ...(taskId ? { taskId } : {}),
+    ...(sessionId ? { sessionId } : {}),
+  };
+  return Object.keys(linked).length > 0 ? linked : undefined;
+}
+
+function normalizeItem(value: unknown, fallbackCreatedAt: number): WorkPlanItem | null {
+  if (!isObject(value)) return null;
+  const title = readString(value.title);
+  if (!title) return null;
+  const status = isWorkPlanStatus(value.status) ? value.status : 'pending';
+  const createdAt = typeof value.createdAt === 'number' ? value.createdAt : fallbackCreatedAt;
+  const updatedAt = typeof value.updatedAt === 'number' ? value.updatedAt : createdAt;
+  const completedAt = typeof value.completedAt === 'number' ? value.completedAt : undefined;
+  const owner = readString(value.owner);
+  const source = readString(value.source);
+  const notes = readString(value.notes);
+  const linked = normalizeLinked(value.linked);
+  return {
+    id: readString(value.id) ?? createItemId(),
+    title,
+    status,
+    ...(owner ? { owner } : {}),
+    ...(source ? { source } : {}),
+    ...(notes ? { notes } : {}),
+    ...(linked ? { linked } : {}),
+    createdAt,
+    updatedAt,
+    ...(completedAt !== undefined ? { completedAt } : {}),
+  };
+}
+
+function formatStatus(status: WorkPlanItemStatus): string {
+  return status.replace(/_/g, ' ');
+}
+
+export function nextWorkPlanStatus(status: WorkPlanItemStatus): WorkPlanItemStatus {
+  switch (status) {
+    case 'pending':
+      return 'in_progress';
+    case 'in_progress':
+      return 'done';
+    case 'done':
+      return 'pending';
+    case 'blocked':
+    case 'failed':
+    case 'cancelled':
+      return 'pending';
+  }
+}
+
+export class WorkPlanStore {
+  readonly filePath: string;
+
+  constructor(private readonly options: WorkPlanStoreOptions) {
+    const fileName = `${safeFileId(options.projectId, options.projectRoot)}.json`;
+    this.filePath = join(options.homeDirectory, '.goodvibes', 'tui', 'work-plans', fileName);
+  }
+
+  getActivePlan(): WorkPlan {
+    return this.readPlan();
+  }
+
+  listItems(): readonly WorkPlanItem[] {
+    return this.getActivePlan().items;
+  }
+
+  addItem(title: string, options: AddWorkPlanItemOptions = {}): WorkPlanItem {
+    const normalizedTitle = title.trim();
+    if (!normalizedTitle) throw new Error('Work plan item title is required.');
+    const plan = this.readPlan();
+    const time = nowMs();
+    const item: WorkPlanItem = {
+      id: createItemId(),
+      title: normalizedTitle,
+      status: options.status ?? 'pending',
+      ...(options.owner ? { owner: options.owner } : {}),
+      ...(options.source ? { source: options.source } : {}),
+      ...(options.notes ? { notes: options.notes } : {}),
+      ...(options.linked ? { linked: options.linked } : {}),
+      createdAt: time,
+      updatedAt: time,
+      ...(options.status === 'done' ? { completedAt: time } : {}),
+    };
+    this.writePlan({
+      ...plan,
+      items: [...plan.items, item],
+      activeItemId: item.id,
+      updatedAt: time,
+    });
+    return item;
+  }
+
+  updateItem(idOrPrefix: string, patch: UpdateWorkPlanItemPatch): WorkPlanItem {
+    const plan = this.readPlan();
+    const item = this.resolveItem(plan, idOrPrefix);
+    const time = nowMs();
+    const nextStatus = patch.status ?? item.status;
+    const next: WorkPlanItem = this.pruneItem({
+      ...item,
+      ...(patch.title !== undefined ? { title: patch.title.trim() } : {}),
+      status: nextStatus,
+      ...(patch.owner !== undefined ? { owner: patch.owner || undefined } : {}),
+      ...(patch.source !== undefined ? { source: patch.source || undefined } : {}),
+      ...(patch.notes !== undefined ? { notes: patch.notes || undefined } : {}),
+      ...(patch.linked !== undefined ? { linked: patch.linked || undefined } : {}),
+      updatedAt: time,
+      ...(nextStatus === 'done' ? { completedAt: item.completedAt ?? time } : { completedAt: undefined }),
+    });
+    if (!next.title) throw new Error('Work plan item title is required.');
+    this.writePlan({
+      ...plan,
+      items: plan.items.map((candidate) => candidate.id === item.id ? next : candidate),
+      activeItemId: next.id,
+      updatedAt: time,
+    });
+    return next;
+  }
+
+  setItemStatus(idOrPrefix: string, status: WorkPlanItemStatus): WorkPlanItem {
+    return this.updateItem(idOrPrefix, { status });
+  }
+
+  cycleItemStatus(idOrPrefix: string): WorkPlanItem {
+    const item = this.resolveItem(this.readPlan(), idOrPrefix);
+    return this.setItemStatus(item.id, nextWorkPlanStatus(item.status));
+  }
+
+  removeItem(idOrPrefix: string): WorkPlanItem {
+    const plan = this.readPlan();
+    const item = this.resolveItem(plan, idOrPrefix);
+    const time = nowMs();
+    const remaining = plan.items.filter((candidate) => candidate.id !== item.id);
+    this.writePlan({
+      ...plan,
+      items: remaining,
+      activeItemId: remaining[0]?.id,
+      updatedAt: time,
+    });
+    return item;
+  }
+
+  clearCompleted(): number {
+    const plan = this.readPlan();
+    const remaining = plan.items.filter((item) => item.status !== 'done' && item.status !== 'cancelled');
+    const removed = plan.items.length - remaining.length;
+    if (removed === 0) return 0;
+    this.writePlan({
+      ...plan,
+      items: remaining,
+      activeItemId: remaining[0]?.id,
+      updatedAt: nowMs(),
+    });
+    return removed;
+  }
+
+  toMarkdown(plan: WorkPlan = this.readPlan()): string {
+    const lines = [
+      `# ${plan.title}`,
+      '',
+      `Project: ${plan.projectRoot}`,
+      `Project ID: ${plan.projectId}`,
+      `Updated: ${new Date(plan.updatedAt).toISOString()}`,
+      '',
+    ];
+    if (plan.items.length === 0) {
+      lines.push('No work plan items recorded.');
+      return lines.join('\n');
+    }
+    for (const item of plan.items) {
+      const marker = item.status === 'done' ? 'x' : ' ';
+      const suffix = item.status === 'pending' ? '' : ` (${formatStatus(item.status)})`;
+      lines.push(`- [${marker}] ${item.title}${suffix}`);
+      if (item.owner) lines.push(`  - Owner: ${item.owner}`);
+      if (item.source) lines.push(`  - Source: ${item.source}`);
+      if (item.notes) lines.push(`  - Notes: ${item.notes}`);
+    }
+    return lines.join('\n');
+  }
+
+  private readPlan(): WorkPlan {
+    if (!existsSync(this.filePath)) return this.createEmptyPlan();
+    const raw = readFileSync(this.filePath, 'utf8');
+    const parsed = JSON.parse(raw) as unknown;
+    if (!isObject(parsed)) return this.createEmptyPlan();
+    const time = nowMs();
+    const createdAt = typeof parsed.createdAt === 'number' ? parsed.createdAt : time;
+    const updatedAt = typeof parsed.updatedAt === 'number' ? parsed.updatedAt : createdAt;
+    const items = Array.isArray(parsed.items)
+      ? parsed.items.map((item) => normalizeItem(item, createdAt)).filter((item): item is WorkPlanItem => item !== null)
+      : [];
+    const activeItemId = readString(parsed.activeItemId);
+    const source = readString(parsed.source);
+    return {
+      id: readString(parsed.id) ?? createPlanId(this.options.projectId, this.options.projectRoot),
+      projectId: readString(parsed.projectId) ?? this.options.projectId,
+      projectRoot: readString(parsed.projectRoot) ?? this.options.projectRoot,
+      title: readString(parsed.title) ?? 'Work Plan',
+      items,
+      ...(activeItemId && items.some((item) => item.id === activeItemId) ? { activeItemId } : {}),
+      ...(source ? { source } : {}),
+      createdAt,
+      updatedAt,
+    };
+  }
+
+  private createEmptyPlan(): WorkPlan {
+    const time = nowMs();
+    return {
+      id: createPlanId(this.options.projectId, this.options.projectRoot),
+      projectId: this.options.projectId,
+      projectRoot: this.options.projectRoot,
+      title: 'Work Plan',
+      items: [],
+      source: 'tui',
+      createdAt: time,
+      updatedAt: time,
+    };
+  }
+
+  private writePlan(plan: WorkPlan): void {
+    mkdirSync(dirname(this.filePath), { recursive: true });
+    const tmp = `${this.filePath}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmp, `${JSON.stringify(plan, null, 2)}\n`, { mode: 0o600 });
+    renameSync(tmp, this.filePath);
+  }
+
+  private resolveItem(plan: WorkPlan, idOrPrefix: string): WorkPlanItem {
+    const needle = idOrPrefix.trim();
+    if (!needle) throw new Error('Work plan item id is required.');
+    const exact = plan.items.find((item) => item.id === needle);
+    if (exact) return exact;
+    const matches = plan.items.filter((item) => item.id.startsWith(needle));
+    if (matches.length === 1) return matches[0]!;
+    if (matches.length > 1) {
+      throw new Error(`Work plan item id "${needle}" is ambiguous: ${matches.map((item) => item.id).join(', ')}`);
+    }
+    throw new Error(`Work plan item not found: ${needle}`);
+  }
+
+  private pruneItem(item: WorkPlanItem & {
+    owner?: string | undefined;
+    source?: string | undefined;
+    notes?: string | undefined;
+    linked?: WorkPlanLinkTargets | undefined;
+    completedAt?: number | undefined;
+  }): WorkPlanItem {
+    return {
+      id: item.id,
+      title: item.title,
+      status: item.status,
+      ...(item.owner ? { owner: item.owner } : {}),
+      ...(item.source ? { source: item.source } : {}),
+      ...(item.notes ? { notes: item.notes } : {}),
+      ...(item.linked ? { linked: item.linked } : {}),
+      createdAt: item.createdAt,
+      updatedAt: item.updatedAt,
+      ...(item.completedAt !== undefined ? { completedAt: item.completedAt } : {}),
+    };
+  }
+}