@pellux/goodvibes-tui 0.19.81 → 0.19.82

package/CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.19.82] — 2026-05-09
+
+### Changes
+- e13b0885 Update SDK and repair planning flow
+
 ## [0.19.81] — 2026-05-08
 
 ### 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.81-blue.svg)](https://github.com/mgd34msu/goodvibes-tui)
+[![Version](https://img.shields.io/badge/version-0.19.82-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.18"
+    "version": "0.33.19"
   },
   "auth": {
     "modes": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.81",
+  "version": "0.19.82",
   "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.18",
+    "@pellux/goodvibes-sdk": "0.33.19",
     "bash-language-server": "^5.6.0",
     "fuse.js": "^7.1.0",
     "graphql": "^16.13.2",

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

@@ -1,6 +1,52 @@
+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',
@@ -25,17 +71,24 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
 
       if (args.length === 0) {
         if (projectPlanningService && projectId) {
-          const [status, evaluation] = await Promise.all([
+          const [status, stateResult] = await Promise.all([
             projectPlanningService.status({ projectId }),
-            projectPlanningService.evaluate({ 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` +
-            (evaluation.nextQuestion ? `Next question: ${evaluation.nextQuestion.prompt}` : 'No next question recorded.'),
+            formatNextQuestion(evaluation.nextQuestion),
           );
           return;
         }
@@ -132,14 +185,20 @@ export function registerPlanningRuntimeCommands(registry: CommandRegistry): void
           },
         },
       });
-      const evaluation = await projectPlanningService.evaluate({ projectId });
+      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: "${result.state?.goal ?? taskDescription}"\n` +
+        `Project planning seeded: "${state?.goal ?? taskDescription}"\n` +
         `Readiness: ${evaluation.readiness}\n` +
-        (evaluation.nextQuestion ? `Next question: ${evaluation.nextQuestion.prompt}` : 'No next question recorded.'),
+        formatNextQuestion(evaluation.nextQuestion),
       );
     },
   });

package/src/panels/builtin/agent.ts

@@ -90,6 +90,7 @@ export function registerAgentPanels(manager: PanelManager, deps: ResolvedBuiltin
       service: deps.projectPlanningService,
       projectId: deps.projectPlanningProjectId,
       requestRender: deps.requestRender,
+      submitAnswer: deps.submitPlanningAnswer,
     }),
   });
 

package/src/panels/builtin/shared.ts

@@ -55,6 +55,8 @@ export interface BuiltinPanelDeps {
   resumeSession?: (sessionId: string) => void;
   /** Request a shell repaint directly rather than routing through a retired event path. */
   requestRender?: () => void;
+  /** Submit a Planning panel answer through the normal TUI chat/planning coordinator path. */
+  submitPlanningAnswer?: (answer: string) => void;
   /** ForensicsRegistry for the Forensics panel. */
   forensicsRegistry?: import('@/runtime/index.ts').ForensicsRegistry;
   /** EvalRegistry for the Eval panel. */

package/src/panels/panel-manager.ts

@@ -553,7 +553,12 @@ export class PanelManager {
   private _activateByIdInPane(panelId: string, which: 'top' | 'bottom'): void {
     const p = this._getPane(which);
     const index = p.panels.findIndex(panel => panel.id === panelId);
-    if (index >= 0 && index !== p.activeIndex) {
+    if (index < 0) return;
+    if (index === p.activeIndex) {
+      p.panels[index]?.onActivate();
+      return;
+    }
+    if (index !== p.activeIndex) {
       const oldPanel = p.panels[p.activeIndex];
       if (oldPanel) oldPanel.onDeactivate();
       p.activeIndex = index;

package/src/panels/project-planning-panel.ts

@@ -2,6 +2,7 @@ import type {
   ProjectPlanningDecision,
   ProjectPlanningEvaluation,
   ProjectPlanningLanguageArtifact,
+  ProjectPlanningQuestion,
   ProjectPlanningService,
   ProjectPlanningState,
   ProjectPlanningStatus,
@@ -13,6 +14,7 @@ import {
   buildEmptyState,
   buildKeyValueLine,
   buildPanelLine,
+  buildPanelListRow,
   buildPanelWorkspace,
   DEFAULT_PANEL_PALETTE,
   extendPalette,
@@ -39,21 +41,35 @@ export interface ProjectPlanningPanelOptions {
   readonly service: ProjectPlanningService;
   readonly projectId: string;
   readonly requestRender?: () => void;
+  readonly submitAnswer?: (answer: string) => void;
+}
+
+interface PlanningAnswerAction {
+  readonly id: string;
+  readonly label: string;
+  readonly detail: string;
+  readonly answer: string;
+  readonly kind?: 'answer' | 'approve';
+  readonly disabled?: boolean;
 }
 
 export class ProjectPlanningPanel extends BasePanel {
   private readonly service: ProjectPlanningService;
   private readonly projectId: string;
   private readonly requestRender: () => void;
+  private readonly submitAnswer: ((answer: string) => void) | undefined;
   private snapshot: ProjectPlanningPanelSnapshot | null = null;
   private loading = false;
   private scrollOffset = 0;
+  private selectedActionIndex = 0;
+  private draftAnswer = '';
 
   public constructor(options: ProjectPlanningPanelOptions) {
     super('project-planning', 'Planning', 'P', 'agent');
     this.service = options.service;
     this.projectId = options.projectId;
     this.requestRender = options.requestRender ?? (() => {});
+    this.submitAnswer = options.submitAnswer;
   }
 
   public override onActivate(): void {
@@ -62,6 +78,58 @@ export class ProjectPlanningPanel extends BasePanel {
   }
 
   public handleInput(key: string): boolean {
+    if (this.lastError !== null) this.clearError();
+    const question = this.getCurrentQuestion();
+    if (question) {
+      const actions = this.getAnswerActions(question);
+      this.selectedActionIndex = this.clampActionIndex(actions.length);
+      if (key === 'up') {
+        this.selectedActionIndex = Math.max(0, this.selectedActionIndex - 1);
+        this.markDirty();
+        return true;
+      }
+      if (key === 'down') {
+        this.selectedActionIndex = Math.min(Math.max(0, actions.length - 1), this.selectedActionIndex + 1);
+        this.markDirty();
+        return true;
+      }
+      if (key === 'enter' || key === 'return') {
+        this.submitSelectedAction(question, actions);
+        return true;
+      }
+      if (key === 'backspace') {
+        this.draftAnswer = this.draftAnswer.slice(0, -1);
+        this.markDirty();
+        return true;
+      }
+      if (key === 'delete') {
+        this.draftAnswer = '';
+        this.markDirty();
+        return true;
+      }
+      if (key === 'space') {
+        this.draftAnswer += ' ';
+        this.markDirty();
+        return true;
+      }
+      if (key === 'pageup') {
+        this.scrollOffset = Math.max(0, this.scrollOffset - 6);
+        this.markDirty();
+        return true;
+      }
+      if (key === 'pagedown') {
+        this.scrollOffset += 6;
+        this.markDirty();
+        return true;
+      }
+      if (this.isPrintableKey(key)) {
+        this.draftAnswer += key;
+        this.markDirty();
+        return true;
+      }
+      return false;
+    }
+
     if (key === 'r' || key === 'R') {
       this.refresh(true);
       return true;
@@ -121,6 +189,8 @@ export class ProjectPlanningPanel extends BasePanel {
         });
       } else {
         sections.push(this.buildStateSection(width, state, evaluation));
+        const question = this.getCurrentQuestion();
+        if (question) sections.push(this.buildQuestionSection(width, question));
         sections.push(this.buildGapsSection(width, evaluation));
         sections.push(this.buildTasksSection(width, state));
         sections.push(this.buildDecisionsSection(width, state, decisions));
@@ -161,6 +231,21 @@ export class ProjectPlanningPanel extends BasePanel {
   }
 
   private footerLines(width: number): Line[] {
+    const hasQuestion = this.getCurrentQuestion() !== null;
+    if (hasQuestion) {
+      return [
+        buildPanelLine(width, [
+          [' Up/Down', C.info],
+          [' choose answer  ', C.dim],
+          ['type', C.info],
+          [' draft  ', C.dim],
+          ['Backspace/Delete', C.info],
+          [' edit  ', C.dim],
+          ['Enter', C.info],
+          [' submit  Esc close panel focus', C.dim],
+        ]),
+      ];
+    }
     return [
       buildPanelLine(width, [
         [' Up/Down', C.info],
@@ -173,6 +258,41 @@ export class ProjectPlanningPanel extends BasePanel {
     ];
   }
 
+  private buildQuestionSection(width: number, question: ProjectPlanningQuestion): PanelWorkspaceSection {
+    const actions = this.getAnswerActions(question);
+    this.selectedActionIndex = this.clampActionIndex(actions.length);
+    const lines: Line[] = [
+      ...buildBodyText(width, question.prompt, C, C.planning),
+    ];
+    if (question.whyItMatters) {
+      lines.push(...buildBodyText(width, `Why this matters: ${question.whyItMatters}`, C, C.dim));
+    }
+    if (question.recommendedAnswer) {
+      lines.push(...buildBodyText(width, `Recommendation: ${question.recommendedAnswer}`, C, C.good));
+    }
+    lines.push(...buildBodyText(
+      width,
+      `Typed answer: ${this.draftAnswer || '(type here while this panel is focused)'}`,
+      C,
+      this.draftAnswer ? C.value : C.dim,
+    ));
+    lines.push(buildPanelLine(width, [[
+      ' Select an answer below or type your own. Enter sends it through the normal planning chat path.',
+      C.dim,
+    ]]));
+    actions.forEach((action, index) => {
+      const selected = index === this.selectedActionIndex;
+      lines.push(buildPanelListRow(width, [
+        { text: action.label, fg: action.disabled ? C.dim : C.value, bold: selected },
+        { text: `  ${action.detail}`, fg: C.dim },
+      ], C, {
+        selected,
+        marker: selected ? '▶' : ' ',
+      }));
+    });
+    return { title: 'Answer Current Question', lines };
+  }
+
   private buildStateSection(
     width: number,
     state: ProjectPlanningState,
@@ -339,6 +459,124 @@ export class ProjectPlanningPanel extends BasePanel {
     })();
   }
 
+  private getCurrentQuestion(): ProjectPlanningQuestion | null {
+    const state = this.snapshot?.state;
+    const open = state?.openQuestions.find((question) => (question.status ?? 'open') === 'open');
+    return open ?? this.snapshot?.evaluation?.nextQuestion ?? null;
+  }
+
+  private getAnswerActions(question: ProjectPlanningQuestion): PlanningAnswerAction[] {
+    const actions: PlanningAnswerAction[] = [];
+    const prompt = question.prompt.toLowerCase();
+    const isScopeQuestion = prompt.includes('scope') || prompt.includes('in or out');
+    const isApprovalQuestion = prompt.includes('approved') || prompt.includes('approve') || prompt.includes('execution');
+    if (isApprovalQuestion) {
+      actions.push({
+        id: 'approve-execution',
+        label: 'Approve execution',
+        detail: 'Mark this plan approved so execution may proceed.',
+        answer: 'Approve this planning state for execution.',
+        kind: 'approve',
+      });
+    }
+    if (question.recommendedAnswer?.trim()) {
+      actions.push({
+        id: 'recommended',
+        label: 'Use recommended answer',
+        detail: this.compact(question.recommendedAnswer),
+        answer: question.recommendedAnswer,
+      });
+    }
+    if (isScopeQuestion) {
+      actions.push({
+        id: 'scope-end-to-end',
+        label: 'End-to-end required scope',
+        detail: 'Let the plan include every component needed to make this work, but avoid unrelated cleanup.',
+        answer: 'Scope is everything required to make the requested outcome work end-to-end. Include TUI, daemon composition, configuration, docs, and tests if they are required. Do not include unrelated cleanup or broad refactors unless they are necessary for this task.',
+      });
+      actions.push({
+        id: 'scope-tui-first',
+        label: 'TUI-first scope',
+        detail: 'Fix TUI behavior here; report SDK blockers instead of patching around SDK-owned bugs.',
+        answer: 'Scope is TUI-owned behavior first. If a blocker is SDK-owned, report the exact SDK contract/runtime issue instead of patching around it in the TUI. Include daemon composition only where the TUI owns the wiring.',
+      });
+    }
+    actions.push({
+      id: 'ask-narrower',
+      label: 'I am not sure yet',
+      detail: 'Break this into smaller concrete choices with examples and a recommended default.',
+      answer: `I do not know enough to answer "${question.prompt}" as asked. Break it into smaller concrete questions with 2-4 specific choices, explain the tradeoffs, recommend a default, and ask me the first one.`,
+    });
+    actions.push({
+      id: 'custom',
+      label: 'Submit typed answer',
+      detail: this.draftAnswer ? this.compact(this.draftAnswer) : 'Type an answer first; this row becomes the custom answer.',
+      answer: this.draftAnswer.trim(),
+      disabled: !this.draftAnswer.trim(),
+    });
+    return actions;
+  }
+
+  private submitSelectedAction(question: ProjectPlanningQuestion, actions: readonly PlanningAnswerAction[]): void {
+    const action = actions[this.clampActionIndex(actions.length)];
+    if (!action || action.disabled || !action.answer.trim()) {
+      this.setError('Type an answer or choose a non-empty answer option.');
+      this.requestRender();
+      return;
+    }
+    if (action.kind === 'approve') {
+      this.approveExecution();
+      return;
+    }
+    if (!this.submitAnswer) {
+      this.setError('Planning answer submission is not wired in this runtime.');
+      this.requestRender();
+      return;
+    }
+    void (async () => {
+      try {
+        await this.persistQuestionIfNeeded(question);
+        this.draftAnswer = '';
+        this.submitAnswer?.(action.answer.trim());
+        this.refresh(true);
+        this.registerTimer(setTimeout(() => this.refresh(true), 250));
+      } catch (err) {
+        this.setError(err instanceof Error ? err.message : String(err));
+        this.requestRender();
+      }
+    })();
+  }
+
+  private async persistQuestionIfNeeded(question: ProjectPlanningQuestion): Promise<void> {
+    const state = this.snapshot?.state;
+    if (!state) return;
+    if (state.openQuestions.some((entry) => entry.id === question.id)) return;
+    await this.service.upsertState({
+      projectId: this.projectId,
+      state: {
+        ...state,
+        openQuestions: [
+          { ...question, status: question.status ?? 'open' },
+          ...state.openQuestions,
+        ],
+      },
+    });
+  }
+
+  private clampActionIndex(count: number): number {
+    if (count <= 0) return 0;
+    return Math.max(0, Math.min(count - 1, this.selectedActionIndex));
+  }
+
+  private isPrintableKey(key: string): boolean {
+    return key.length === 1 && key >= ' ';
+  }
+
+  private compact(text: string): string {
+    const normalized = text.replace(/\s+/g, ' ').trim();
+    return normalized.length > 86 ? `${normalized.slice(0, 83)}...` : normalized;
+  }
+
   private approveExecution(): void {
     const state = this.snapshot?.state;
     if (!state) {

package/src/planning/project-planning-coordinator.ts

@@ -205,12 +205,16 @@ export class ProjectPlanningCoordinator {
     const tasks = state.tasks
       .map((task) => `- ${task.id}: ${task.title}`)
       .join('\n') || '- none recorded yet';
+    const recentAnswers = state.answeredQuestions
+      .slice(-3)
+      .map((question) => `- ${question.prompt}\n  Answer: ${question.answer ?? '(no answer recorded)'}`)
+      .join('\n') || '- none recorded yet';
 
     return [
       'TUI-owned project planning loop is active for this turn.',
       'Do not execute code changes, spawn agents, or claim implementation is complete unless the user explicitly approves execution after the plan is structurally ready.',
       'Be relentless and thorough: challenge vague wording, inspect relevant context before proposing execution, and ask exactly one focused question when information is missing.',
-      'Prefer concrete examples and recommended answers so the user can answer quickly.',
+      'Do not ask broad questions like "what is in scope?" without examples. Break broad planning gaps into concrete choices, explain tradeoffs, and recommend a default the user can accept or correct.',
       '',
       `Project id: ${this.projectId}`,
       `Knowledge space: ${state.knowledgeSpaceId}`,
@@ -222,11 +226,14 @@ export class ProjectPlanningCoordinator {
       'Readiness gaps:',
       gaps,
       '',
+      'Recent answered planning questions:',
+      recentAnswers,
+      '',
       'Recorded tasks:',
       tasks,
       '',
       nextQuestion
-        ? `Ask this exact next planning question unless the user already answered it: ${nextQuestion.prompt}`
+        ? `Resolve this next planning gap. If this wording is broad, turn it into a smaller concrete multiple-choice question before asking: ${nextQuestion.prompt}`
         : 'If the plan is structurally ready, summarize the plan and ask for explicit execution approval. Do not start execution yourself.',
     ].join('\n');
   }

package/src/runtime/bootstrap-shell.ts

@@ -103,6 +103,7 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     providerRegistry: services.providerRegistry,
   });
 
+  let commandContextRef: CommandContext | null = null;
   registerBuiltinPanels(services.panelManager, {
     configManager,
     getOrchestratorUsage: () => orchestrator.usage as { input: number; output: number; cacheRead: number; cacheWrite: number; model?: string },
@@ -113,6 +114,12 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     getCtxWindow: () => services.providerRegistry.getContextWindowForModel(services.providerRegistry.getCurrentModel()),
     resumeSession,
     requestRender,
+    submitPlanningAnswer: (answer) => {
+      if (!commandContextRef?.submitInput) {
+        throw new Error('Planning answer submission is not wired yet.');
+      }
+      commandContextRef.submitInput(answer);
+    },
     forensicsRegistry,
     policyRuntimeState,
     approvalBroker: services.approvalBroker,
@@ -243,6 +250,7 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     completeModelSelectionSideEffect,
     componentHealthMonitor: services.componentHealthMonitor,
   });
+  commandContextRef = commandContext;
 
   const gitStatusProvider = new GitStatusProvider(services.workingDirectory);
   const lastGitInfoRef = { value: undefined as GitHeaderInfo | undefined };

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.81';
+let _version = '0.19.82';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;