@pellux/goodvibes-agent 0.1.0

package/src/input/commands/operator-runtime.ts

@@ -0,0 +1,392 @@
+import type { CommandRegistry } from '../command-registry.ts';
+import { ToolContractVerifier } from '@/runtime/index.ts';
+import type { ReplaySnapshotInput } from '@/runtime/index.ts';
+import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { registerOperatorPanelCommand } from './operator-panel-runtime.ts';
+import { requireOpsApi, requireProfileManager, requireReplayEngine } from './runtime-services.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+export function registerOperatorRuntimeCommands(registry: CommandRegistry): void {
+  registerOperatorPanelCommand(registry);
+
+  registry.register({
+    name: 'settings',
+    aliases: ['cfg-ui'],
+    description: 'Open the fullscreen configuration workspace',
+    handler(_args, ctx) {
+      if (ctx.openSettingsModal) ctx.openSettingsModal();
+      else ctx.print('Configuration workspace is not available in this runtime.');
+    },
+  });
+
+  registry.register({
+    name: 'context',
+    aliases: ['ctx'],
+    description: 'Inspect context window usage (token breakdown per message)',
+    handler: (_args, ctx) => {
+      if (ctx.openContextInspector) {
+        ctx.openContextInspector();
+      } else {
+        const msgs = ctx.session.conversationManager.getMessagesForLLM();
+        if (msgs.length === 0) {
+          ctx.print('[context] No messages in conversation.');
+          return;
+        }
+        const estimateTokens = (text: string): number => Math.ceil(text.length / 4);
+        let total = 0;
+        const lines: string[] = ['Context breakdown:'];
+        for (const m of msgs) {
+          const text = typeof m.content === 'string'
+            ? m.content
+            : (m.content as Array<{ type: string; text?: string }>)
+              .filter((p) => p.type === 'text')
+              .map((p) => p.text ?? '')
+              .join('');
+          const t = estimateTokens(text);
+          total += t;
+          lines.push(`  ${m.role.padEnd(12)} ~${t.toLocaleString()} tokens`);
+        }
+        lines.push(`  ${'Total'.padEnd(12)} ~${total.toLocaleString()} tokens (${msgs.length} messages)`);
+        ctx.print(lines.join('\n'));
+      }
+    },
+  });
+
+  registry.register({
+    name: 'next-error',
+    aliases: ['ne'],
+    description: 'Jump to the next error message in the conversation',
+    handler(_args, ctx) {
+      const nextLine = ctx.session.conversationManager.nextErrorLine(ctx.getScrollTop?.() ?? 0);
+      if (nextLine < 0) ctx.print('[No error messages found in conversation]');
+      else ctx.scrollToLine?.(nextLine);
+    },
+  });
+
+  registry.register({
+    name: 'profiles',
+    aliases: ['profile'],
+    description: 'Browse and load config profiles',
+    handler(_args, ctx) {
+      if (ctx.openProfilePicker) {
+        ctx.openProfilePicker();
+      } else {
+        const profiles = requireProfileManager(ctx).list();
+        if (profiles.length === 0) ctx.print('No profiles saved. Open /profiles and press s to save the current settings as a profile.');
+        else ctx.print(['Saved profiles:', ...profiles.map(p => `  ${p.name}`)].join('\n'));
+      }
+    },
+  });
+
+  registry.register({
+    name: 'prev-error',
+    aliases: ['pe'],
+    description: 'Jump to the previous error message in the conversation',
+    handler(_args, ctx) {
+      const prevLine = ctx.session.conversationManager.prevErrorLine(ctx.getScrollTop?.() ?? 0);
+      if (prevLine < 0) ctx.print('[No error messages found in conversation]');
+      else ctx.scrollToLine?.(prevLine);
+    },
+  });
+
+  registry.register({
+    name: 'mode',
+    aliases: ['hitl'],
+    description: 'Manage HITL UX notification mode (quiet/balanced/operator)',
+    usage: '[quiet|balanced|operator|show|set-domain <domain> <verbosity>]',
+    argsHint: '[preset|show|set-domain]',
+    handler(args, ctx) {
+      const mgr = ctx.ops.modeManager;
+      if (!mgr) {
+        ctx.print('Interaction mode manager is not available in this runtime.');
+        return;
+      }
+      const sub = args[0] ?? 'show';
+
+      if (sub === 'quiet' || sub === 'balanced' || sub === 'operator') {
+        const newMode = sub as 'quiet' | 'balanced' | 'operator';
+        mgr.setHITLMode(newMode);
+        try {
+          ctx.platform.configManager.setDynamic('behavior.hitlMode' as import('@pellux/goodvibes-sdk/platform/config').ConfigKey, newMode);
+        } catch (e) {
+          logger.warn('[/mode] Failed to persist mode', { error: summarizeError(e) });
+        }
+        const preset = mgr.getHITLPreset();
+        ctx.print(`HITL mode set to: ${preset.name}\n${preset.description}`);
+        ctx.renderRequest();
+        return;
+      }
+
+      if (sub === 'show') {
+        const current = mgr.getHITLMode();
+        const preset = mgr.getHITLPreset();
+        const overrides = mgr.getDomainOverrides();
+        const lines: string[] = [
+          `HITL mode: ${current}`,
+          `  ${preset.description}`,
+          `  Default domain verbosity: ${preset.defaultDomainVerbosity}`,
+          `  Quiet-while-typing: ${preset.quietWhileTyping}`,
+          `  Batch window: ${preset.batchWindowMs}ms`,
+        ];
+        const overrideEntries = Object.entries(overrides);
+        if (overrideEntries.length > 0) {
+          lines.push('  Per-domain overrides:');
+          for (const [domain, verbosity] of overrideEntries) lines.push(`    ${domain}: ${verbosity}`);
+        } else {
+          lines.push('  No per-domain overrides.');
+        }
+        lines.push('');
+        lines.push('Available presets:');
+        for (const p of mgr.listHITLPresets()) {
+          const marker = p.name === current ? '\u25b6' : ' ';
+          lines.push(`  ${marker} ${p.name.padEnd(10)} ${p.description}`);
+        }
+        ctx.print(lines.join('\n'));
+        return;
+      }
+
+      if (sub === 'set-domain') {
+        const domain = args[1];
+        const verbosity = args[2];
+        if (!domain || !verbosity) {
+          ctx.print('Usage: /mode set-domain <domain> <minimal|normal|verbose>');
+          return;
+        }
+        if (verbosity !== 'minimal' && verbosity !== 'normal' && verbosity !== 'verbose') {
+          ctx.print(`Invalid verbosity "${verbosity}". Valid values: minimal, normal, verbose`);
+          return;
+        }
+        mgr.setDomainVerbosity(domain, verbosity as 'minimal' | 'normal' | 'verbose');
+        ctx.print(`Domain "${domain}" verbosity set to: ${verbosity}`);
+        return;
+      }
+
+      ctx.print(
+        'Usage: /mode [quiet|balanced|operator|show|set-domain <domain> <verbosity>]\n'
+        + '  /mode                          — show current mode and settings\n'
+        + '  /mode show                     — show current mode and settings\n'
+        + '  /mode quiet                    — suppress all non-critical notifications\n'
+        + '  /mode balanced                 — surface warnings, batch info noise (default)\n'
+        + '  /mode operator                 — full verbosity, no suppression\n'
+        + '  /mode set-domain <d> <v>       — per-domain verbosity override (minimal|normal|verbose)'
+      );
+    },
+  });
+
+  registry.register({
+    name: 'ops',
+    description: 'Operator Control Plane: view audit log, cancel/pause/resume/retry tasks and agents',
+    usage: 'view | task <cancel|pause|resume|retry> <id> [note] | agent cancel <id> [note]',
+    argsHint: '[view|task|agent]',
+    handler(args, ctx) {
+      const sub = args[0];
+
+      if (sub === 'view' || sub === undefined) {
+        if (ctx.openOpsPanel) ctx.openOpsPanel();
+        else ctx.print('Operator Control Plane panel is not available. Enable the operator-control-plane feature flag.');
+        return;
+      }
+
+      if (sub === 'task') {
+        const action = args[1];
+        const taskId = args[2];
+        const note = args.slice(3).join(' ') || undefined;
+        if (!action || !taskId) {
+          ctx.print('Usage: /ops task <cancel|pause|resume|retry> <task-id> [note]');
+          return;
+        }
+        const opsApi = requireOpsApi(ctx);
+        try {
+          switch (action) {
+            case 'cancel': opsApi.tasks.cancel(taskId, note); break;
+            case 'pause': opsApi.tasks.pause(taskId, note); break;
+            case 'resume': opsApi.tasks.resume(taskId, note); break;
+            case 'retry': opsApi.tasks.retry(taskId, note); break;
+            default:
+              ctx.print(`Unknown task action "${action}". Use: cancel, pause, resume, retry`);
+              return;
+          }
+          ctx.print(`[Ops] Task ${taskId}: ${action} dispatched.`);
+        } catch (e) {
+          ctx.print(`[Ops] Error: ${summarizeError(e)}`);
+        }
+        return;
+      }
+
+      if (sub === 'agent') {
+        const action = args[1];
+        const agentId = args[2];
+        const note = args.slice(3).join(' ') || undefined;
+        if (action !== 'cancel' || !agentId) {
+          ctx.print('Usage: /ops agent cancel <agent-id> [note]');
+          return;
+        }
+        const opsApi = requireOpsApi(ctx);
+        try {
+          opsApi.agents.cancel(agentId, note);
+          ctx.print(`[Ops] Agent ${agentId}: cancel dispatched.`);
+        } catch (e) {
+          ctx.print(`[Ops] Error: ${summarizeError(e)}`);
+        }
+        return;
+      }
+
+      ctx.print(
+        'Usage: /ops <subcommand>\n'
+        + '  /ops view                              — open the Ops Control panel (Ctrl+O)\n'
+        + '  /ops task cancel <id> [note]           — cancel a task\n'
+        + '  /ops task pause  <id> [note]           — pause a task\n'
+        + '  /ops task resume <id> [note]           — resume a blocked task\n'
+        + '  /ops task retry  <id> [note]           — retry a failed task\n'
+        + '  /ops agent cancel <id> [note]          — cancel a running agent'
+      );
+    },
+  });
+
+  registry.register({
+    name: 'tool',
+    description: 'Tool contract verification — verify registered tool contracts',
+    usage: 'verify <name> | verify-all | contract show <name>',
+    argsHint: 'verify <name> | verify-all | contract show <name>',
+    handler(args, ctx) {
+      const sub = args[0];
+      if (sub === 'verify' && args[1]) {
+        const result = ctx.extensions.toolRegistry.verifyContract(args[1]);
+        if (!result) {
+          ctx.print(`[tool verify] Tool '${args[1]}' is not registered.`);
+          return;
+        }
+        ctx.print(ToolContractVerifier.formatResult(result));
+        return;
+      }
+      if (sub === 'verify-all') {
+        ctx.print(ToolContractVerifier.formatAllResults(ctx.extensions.toolRegistry.verifyAllContracts()));
+        return;
+      }
+      if (sub === 'contract' && args[1] === 'show' && args[2]) {
+        const toolName = args[2];
+        const result = ctx.extensions.toolRegistry.verifyContract(toolName);
+        if (!result) {
+          ctx.print(`[tool contract show] Tool '${toolName}' is not registered.`);
+          return;
+        }
+        const lines: string[] = [ToolContractVerifier.formatResult(result)];
+        const tool = ctx.extensions.toolRegistry.list().find((t) => t.definition.name === toolName);
+        if (tool) {
+          lines.push('');
+          lines.push('Tool Definition:');
+          lines.push(`  Name:        ${tool.definition.name}`);
+          lines.push(`  Description: ${tool.definition.description}`);
+          lines.push(`  Parameters:  ${JSON.stringify(tool.definition.parameters, null, 2).replace(/\n/g, '\n               ')}`);
+        }
+        ctx.print(lines.join('\n'));
+        return;
+      }
+
+      ctx.print(
+        'Usage: /tool <subcommand>\n'
+        + '  /tool verify <name>             — verify contract for a specific registered tool\n'
+        + '  /tool verify-all                — verify contracts for all registered tools\n'
+        + '  /tool contract show <name>      — show full contract details for a tool'
+      );
+    },
+  });
+
+  registry.register({
+    name: 'forensics',
+    aliases: ['foren'],
+    description: 'Failure Forensics: view, inspect, and export auto-classified failure reports',
+    usage: '[latest | show <id> | export <id>]',
+    argsHint: '[latest|show|export]',
+    handler(args, ctx) {
+      const sub = args[0];
+      if (sub === undefined || sub === 'view') {
+        if (ctx.openForensicsPanel) ctx.openForensicsPanel();
+        else ctx.print('Forensics panel is not available.');
+        return;
+      }
+      if (sub === 'latest') {
+        if (!ctx.extensions.forensicsRegistry) {
+          ctx.print('[Forensics] Registry not active.');
+          return;
+        }
+        const report = ctx.extensions.forensicsRegistry.latest();
+        if (!report) {
+          ctx.print('[Forensics] No failure reports recorded this session.');
+          return;
+        }
+        const lines: string[] = [
+          `[Forensics] Latest failure report (id: ${report.id})`,
+          `  Time:           ${new Date(report.generatedAt).toISOString()}`,
+          `  Classification: ${report.classification}`,
+          `  Summary:        ${report.summary}`,
+        ];
+        if (report.errorMessage) lines.push(`  Error:          ${report.errorMessage}`);
+        if (report.stopReason) lines.push(`  Stop reason:    ${report.stopReason}`);
+        if (report.taskId) lines.push(`  Task ID:        ${report.taskId}`);
+        if (report.turnId) lines.push(`  Turn ID:        ${report.turnId}`);
+        if (report.causalChain.length > 0) {
+          lines.push('  Causal chain:');
+          for (const entry of report.causalChain) {
+            const marker = entry.isRootCause ? '  ● ' : '  · ';
+            lines.push(`  ${marker}${entry.description}`);
+          }
+        }
+        if (report.jumpLinks.length > 0) {
+          lines.push('  Jump links:');
+          for (const link of report.jumpLinks) {
+            lines.push(`    [${link.kind}] ${link.label} → ${link.target}${link.args ? ` (${link.args})` : ''}`);
+          }
+        }
+        lines.push(`  Use "/forensics show ${report.id}" for full JSON.`);
+        ctx.print(lines.join('\n'));
+        return;
+      }
+      if (sub === 'show') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /forensics show <id>');
+          return;
+        }
+        if (!ctx.extensions.forensicsRegistry) {
+          ctx.print('[Forensics] Registry not active.');
+          return;
+        }
+        const json = ctx.extensions.forensicsRegistry.exportAsJson(id);
+        if (!json) {
+          ctx.print(`[Forensics] No report found with id "${id}". Use /forensics latest to see the most recent.`);
+          return;
+        }
+        ctx.print(json);
+        return;
+      }
+      if (sub === 'export') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /forensics export <id>');
+          return;
+        }
+        if (!ctx.extensions.forensicsRegistry) {
+          ctx.print('[Forensics] Registry not active.');
+          return;
+        }
+        const json = ctx.extensions.forensicsRegistry.exportBundleAsJson(id, {
+          replaySnapshot: requireReplayEngine(ctx).getSnapshot() as ReplaySnapshotInput,
+        });
+        if (!json) {
+          ctx.print(`[Forensics] No report found with id "${id}".`);
+          return;
+        }
+        ctx.print(`[Forensics] Incident bundle ${id}:\n${json}`);
+        return;
+      }
+      ctx.print(
+        'Usage: /forensics <subcommand>\n'
+        + '  /forensics             — open the Forensics panel\n'
+        + '  /forensics latest      — print the most recent failure report summary\n'
+        + '  /forensics show <id>   — show full JSON for a specific report\n'
+        + '  /forensics export <id> — export incident bundle JSON to the conversation'
+      );
+    },
+  });
+}

package/src/input/commands/planning-runtime.ts

@@ -0,0 +1,205 @@
+import type {
+  ProjectPlanningEvaluation,
+  ProjectPlanningQuestion,
+  ProjectPlanningService,
+  ProjectPlanningState,
+} from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { CommandRegistry } from '../command-registry.ts';
+import { requirePlanManager, requireSessionLineageTracker } from './runtime-services.ts';
+
+function recordNextQuestion(
+  state: Partial<ProjectPlanningState>,
+  question: ProjectPlanningQuestion | undefined,
+): Partial<ProjectPlanningState> {
+  if (!question) return state;
+  const answered = new Set((state.answeredQuestions ?? []).map((entry) => entry.id));
+  if (answered.has(question.id)) return state;
+  const openQuestions = [...(state.openQuestions ?? [])];
+  const existingIndex = openQuestions.findIndex((entry) => entry.id === question.id);
+  const normalized = { ...question, status: question.status ?? 'open' } satisfies ProjectPlanningQuestion;
+  if (existingIndex >= 0) openQuestions[existingIndex] = normalized;
+  else openQuestions.unshift(normalized);
+  return { ...state, openQuestions };
+}
+
+async function persistEvaluatedNextQuestion(
+  service: ProjectPlanningService,
+  projectId: string,
+  state: ProjectPlanningState,
+  evaluation: ProjectPlanningEvaluation,
+): Promise<{ state: ProjectPlanningState; evaluation: ProjectPlanningEvaluation }> {
+  if (!evaluation.nextQuestion) return { state, evaluation };
+  if (state.openQuestions.some((question) => question.id === evaluation.nextQuestion?.id)) {
+    return { state, evaluation };
+  }
+  const withQuestion = recordNextQuestion(evaluation.state ?? state, evaluation.nextQuestion);
+  const saved = await service.upsertState({ projectId, state: withQuestion });
+  const nextState = saved.state ?? state;
+  const nextEvaluation = await service.evaluate({ projectId, state: nextState });
+  return { state: nextState, evaluation: nextEvaluation };
+}
+
+function formatNextQuestion(question: ProjectPlanningQuestion | undefined): string {
+  if (!question) return 'No next question recorded.';
+  const lines = [`Next question: ${question.prompt}`];
+  if (question.recommendedAnswer) lines.push(`Recommended answer: ${question.recommendedAnswer}`);
+  lines.push('Answer in the prompt, or focus the Planning panel to choose/type an answer.');
+  return lines.join('\n');
+}
+
+export function registerPlanningRuntimeCommands(registry: CommandRegistry): void {
+  registry.register({
+    name: 'plan',
+    description: 'Inspect or seed TUI-owned project planning state',
+    usage: '[panel | approve | list | show <id> | mode | explain | override <strategy> | status | clear | <planning goal>]',
+    argsHint: '[panel|approve|status|<goal>]',
+    async handler(args, ctx) {
+      const planManager = requirePlanManager(ctx);
+      const sessionLineageTracker = requireSessionLineageTracker(ctx);
+      const plannerSubs = ['mode', 'explain', 'override', 'status', 'clear'];
+      if (args.length > 0 && plannerSubs.includes(args[0].toLowerCase())) {
+        const result = ctx.ops.planRuntime
+          ? ctx.ops.planRuntime(args[0], args.slice(1))
+          : { ok: false, output: 'Plan runtime bridge is not available in this runtime.' };
+        ctx.print(result.output);
+        return;
+      }
+
+      const projectPlanningService = ctx.workspace.projectPlanningService;
+      const projectId = ctx.workspace.projectPlanningProjectId;
+      const openProjectPlanningPanel = () => ctx.showPanel?.('project-planning');
+
+      if (args.length === 0) {
+        if (projectPlanningService && projectId) {
+          const [status, stateResult] = await Promise.all([
+            projectPlanningService.status({ projectId }),
+            projectPlanningService.getState({ projectId }),
+          ]);
+          const initialEvaluation = await projectPlanningService.evaluate({
+            projectId,
+            ...(stateResult.state ? { state: stateResult.state } : {}),
+          });
+          const { evaluation } = stateResult.state
+            ? await persistEvaluatedNextQuestion(projectPlanningService, projectId, stateResult.state, initialEvaluation)
+            : { evaluation: initialEvaluation };
+          openProjectPlanningPanel();
+          ctx.print(
+            `Project planning: ${evaluation.readiness}\n` +
+            `Project: ${status.projectId}\n` +
+            `Knowledge space: ${status.knowledgeSpaceId}\n` +
+            `Artifacts: ${status.counts.states} state, ${status.counts.decisions} decisions, ${status.counts.languageArtifacts} language\n` +
+            formatNextQuestion(evaluation.nextQuestion),
+          );
+          return;
+        }
+        const active = planManager.getActive(ctx.session.runtime.sessionId);
+        if (!active) {
+          ctx.print('No active execution plan.');
+          return;
+        }
+        const summary = planManager.getSummary(active);
+        ctx.print(`Active plan: "${active.title}" [${active.status.toUpperCase()}]\n${summary}`);
+        return;
+      }
+
+      if (args[0] === 'panel') {
+        openProjectPlanningPanel();
+        ctx.print('Opened project planning panel.');
+        return;
+      }
+
+      if (args[0] === 'approve') {
+        if (!projectPlanningService || !projectId) {
+          ctx.print('Project planning service is not available in this runtime.');
+          return;
+        }
+        const current = await projectPlanningService.getState({ projectId });
+        if (!current.state) {
+          ctx.print('No project planning state exists to approve.');
+          return;
+        }
+        const result = await projectPlanningService.upsertState({
+          projectId,
+          state: {
+            ...current.state,
+            executionApproved: true,
+            metadata: {
+              ...(current.state.metadata ?? {}),
+              approvedFrom: 'plan-command',
+              approvedAt: Date.now(),
+            },
+          },
+        });
+        const evaluation = await projectPlanningService.evaluate({ projectId });
+        openProjectPlanningPanel();
+        ctx.print(`Project planning approved. Readiness: ${evaluation.readiness}. State: ${result.state?.id ?? 'current'}.`);
+        return;
+      }
+
+      if (args[0] === 'list') {
+        const plans = planManager.list();
+        if (plans.length === 0) {
+          ctx.print('No plans found.');
+          return;
+        }
+        ctx.print(`Plans (${plans.length}):\n${plans.map((plan) => {
+          const marker = plan.status === 'active' ? '▶' : ' ';
+          return `  ${marker} ${plan.id.slice(0, 8)}  [${plan.status.padEnd(8)}]  ${plan.title}`;
+        }).join('\n')}`);
+        return;
+      }
+
+      if (args[0] === 'show') {
+        const id = args[1];
+        if (!id) {
+          ctx.print('Usage: /plan show <plan-id>');
+          return;
+        }
+        const plans = planManager.list();
+        const plan = plans.find((entry) => entry.id === id || entry.id.startsWith(id));
+        if (!plan) {
+          ctx.print(`Plan not found: ${id}`);
+          return;
+        }
+        ctx.print(planManager.toMarkdown(plan));
+        return;
+      }
+
+      const taskDescription = args.join(' ');
+      if (!projectPlanningService || !projectId) {
+        ctx.print('Project planning service is not available in this runtime.');
+        return;
+      }
+      const result = await projectPlanningService.upsertState({
+        projectId,
+        state: {
+          goal: taskDescription,
+          knownContext: [
+            `Workspace planning was seeded from the TUI /plan command.`,
+          ],
+          metadata: {
+            active: true,
+            owner: 'tui',
+            source: 'plan-command',
+            lastPromptAt: Date.now(),
+          },
+        },
+      });
+      const initialEvaluation = await projectPlanningService.evaluate({
+        projectId,
+        ...(result.state ? { state: result.state } : {}),
+      });
+      const { state, evaluation } = result.state
+        ? await persistEvaluatedNextQuestion(projectPlanningService, projectId, result.state, initialEvaluation)
+        : { state: result.state, evaluation: initialEvaluation };
+      sessionLineageTracker.setOriginalTask(taskDescription.slice(0, 200));
+      openProjectPlanningPanel();
+
+      ctx.print(
+        `Project planning seeded: "${state?.goal ?? taskDescription}"\n` +
+        `Readiness: ${evaluation.readiness}\n` +
+        formatNextQuestion(evaluation.nextQuestion),
+      );
+    },
+  });
+}