@pellux/goodvibes-tui 0.19.81 → 0.19.83

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to GoodVibes TUI.
 
 ---
 
+## [0.19.83] — 2026-05-09
+
+### Changes
+- debd3a93 Fix planning loop and WRFC root spawning
+
+## [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.83-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.83",
   "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/main.ts

@@ -311,6 +311,11 @@ async function main() {
           try {
             const planning = await projectPlanningCoordinator.prepareTurn(processedText);
             if (planning) {
+              if (planning.handledLocally) {
+                systemMessageRouter.high(planning.statusMessage);
+                render();
+                return;
+              }
               conversation.addSystemMessage(planning.systemMessage);
               inputOptions = {
                 origin: {

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 && !this.isGenericRecommendation(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,
@@ -201,7 +321,7 @@ export class ProjectPlanningPanel extends BasePanel {
       if (evaluation.nextQuestion.whyItMatters) {
         lines.push(...buildBodyText(width, `Why it matters: ${evaluation.nextQuestion.whyItMatters}`, C, C.dim));
       }
-      if (evaluation.nextQuestion.recommendedAnswer) {
+      if (evaluation.nextQuestion.recommendedAnswer && !this.isGenericRecommendation(evaluation.nextQuestion.recommendedAnswer)) {
         lines.push(...buildBodyText(width, `Recommended answer: ${evaluation.nextQuestion.recommendedAnswer}`, C, C.good));
       }
     }
@@ -339,6 +459,157 @@ 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 isTaskQuestion = prompt.includes('task') || prompt.includes('dependency') || prompt.includes('work breakdown');
+    const isVerificationQuestion = prompt.includes('verification') || prompt.includes('test') || prompt.includes('prove');
+    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 (isScopeQuestion) {
+      actions.push({
+        id: 'scope-focused-first-pass',
+        label: 'Use focused first-pass scope',
+        detail: 'Fill a concrete end-to-end scope for this goal and keep unrelated work out.',
+        answer: 'Use a focused first-pass scope for this goal.',
+      });
+    }
+    if (isTaskQuestion) {
+      actions.push({
+        id: 'tasks-default-breakdown',
+        label: 'Create default task breakdown',
+        detail: 'Create inspect, implement, wire, and verify tasks with dependencies.',
+        answer: 'Create the default task breakdown for this goal.',
+      });
+    }
+    if (isVerificationQuestion) {
+      actions.push({
+        id: 'verification-default-gates',
+        label: 'Use standard verification gates',
+        detail: 'Require focused regression coverage, typecheck/build validation, and a runtime smoke where feasible.',
+        answer: 'Use standard verification gates for this goal.',
+      });
+    }
+    if (question.recommendedAnswer?.trim() && !this.isGenericRecommendation(question.recommendedAnswer)) {
+      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 isGenericRecommendation(value: string): boolean {
+    return /\bdefine the first-pass scope\b/i.test(value)
+      || /\bcreate task records\b/i.test(value)
+      || /\brecord concrete tests\b/i.test(value)
+      || /\bseparate out-of-scope work\b/i.test(value);
+  }
+
+  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

@@ -1,8 +1,12 @@
 import type {
+  ProjectPlanningAgentAssignment,
+  ProjectPlanningDependency,
   ProjectPlanningEvaluation,
   ProjectPlanningQuestion,
   ProjectPlanningService,
   ProjectPlanningState,
+  ProjectPlanningTask,
+  ProjectPlanningVerificationGate,
 } from '@pellux/goodvibes-sdk/platform/knowledge';
 
 export interface ProjectPlanningCoordinatorOptions {
@@ -18,6 +22,8 @@ export interface ProjectPlanningTurnPreparation {
   readonly systemMessage: string;
   readonly state: ProjectPlanningState;
   readonly evaluation: ProjectPlanningEvaluation;
+  readonly handledLocally: boolean;
+  readonly statusMessage: string;
 }
 
 const PLANNING_INTENT_PATTERNS: readonly RegExp[] = [
@@ -42,6 +48,24 @@ const APPROVAL_PATTERNS: readonly RegExp[] = [
   /\b(go ahead|execute this plan|start execution|ready to execute)\b/i,
 ];
 
+const ACCEPT_DEFAULT_PATTERNS: readonly RegExp[] = [
+  /^(ok|okay|yes|y|yep|yeah|sure|fine|default|continue|go|go ahead|let'?s go|looks good|sounds good)\.?$/i,
+  /\bok\b.*\blet'?s go\b/i,
+  /\blet'?s go\b/i,
+  /\b(use|accept|take) (the )?(default|recommended|recommendation)\b/i,
+  /\b(create|use) (the )?default task breakdown\b/i,
+  /\bfocused first-pass scope\b/i,
+  /\bstandard verification gates?\b/i,
+];
+
+const GENERIC_RECOMMENDATION_PATTERNS: readonly RegExp[] = [
+  /\bdefine the first-pass scope\b/i,
+  /\bseparate out-of-scope work\b/i,
+  /\bcreate task records\b/i,
+  /\brecord concrete tests\b/i,
+  /\bverification gates?\b/i,
+];
+
 export function hasProjectPlanningIntent(text: string): boolean {
   const trimmed = text.trim();
   if (!trimmed || trimmed.startsWith('/')) return false;
@@ -125,6 +149,8 @@ export class ProjectPlanningCoordinator {
       systemMessage: this.buildSystemMessage(state, evaluation),
       state,
       evaluation,
+      handledLocally: true,
+      statusMessage: this.buildStatusMessage(state, evaluation),
     };
   }
 
@@ -143,12 +169,14 @@ export class ProjectPlanningCoordinator {
     if (options.answeredQuestion) {
       const idx = openQuestions.findIndex((question) => question.id === options.answeredQuestion?.id);
       if (idx >= 0) openQuestions.splice(idx, 1);
-      answeredQuestions.push({
-        ...options.answeredQuestion,
-        status: 'answered',
-        answer: prompt,
-        answeredAt: now,
-      });
+      if (!answeredQuestions.some((question) => question.id === options.answeredQuestion?.id && question.answer === prompt)) {
+        answeredQuestions.push({
+          ...options.answeredQuestion,
+          status: 'answered',
+          answer: prompt,
+          answeredAt: now,
+        });
+      }
     }
 
     const knownContext = new Set(existing?.knownContext ?? []);
@@ -157,7 +185,7 @@ export class ProjectPlanningCoordinator {
       knownContext.add(`Latest planning request: ${prompt}`);
     }
 
-    return {
+    const draft: Partial<ProjectPlanningState> = {
       ...(existing ?? {}),
       projectId: this.projectId,
       goal: existing?.goal?.trim() ? existing.goal : prompt,
@@ -173,6 +201,236 @@ export class ProjectPlanningCoordinator {
         lastPromptAt: now,
       },
     };
+    return this.applyPlanningAnswer(draft, prompt, options.answeredQuestion, {
+      startsPlanning: options.startsPlanning,
+      approved: options.approved,
+    });
+  }
+
+  private applyPlanningAnswer(
+    state: Partial<ProjectPlanningState>,
+    prompt: string,
+    question: ProjectPlanningQuestion | null,
+    options: {
+      readonly startsPlanning: boolean;
+      readonly approved: boolean;
+    },
+  ): Partial<ProjectPlanningState> {
+    if (!question) return state;
+
+    const acceptDefault = this.acceptsDefault(prompt);
+    const questionId = question.id.toLowerCase();
+    const questionText = question.prompt.toLowerCase();
+    const existingGoal = (state.goal ?? prompt).trim();
+    const generic = acceptDefault || this.isGenericPlanningRecommendation(prompt);
+    let next: Partial<ProjectPlanningState> = { ...state };
+
+    if (questionId.includes('scope') || questionText.includes('scope') || questionText.includes('in or out')) {
+      next = {
+        ...next,
+        scope: generic ? this.defaultScope(existingGoal) : this.normalizeScopeAnswer(existingGoal, prompt),
+      };
+    }
+
+    if (
+      questionId.includes('task') ||
+      questionText.includes('task') ||
+      questionId.includes('dependency') ||
+      questionText.includes('dependency') ||
+      questionId.includes('verification') ||
+      questionText.includes('verification') ||
+      (acceptDefault && this.hasStructuralPlanningGaps(next))
+    ) {
+      next = this.withDefaultExecutionPlan(next, existingGoal);
+      if (!generic && !questionId.includes('scope')) {
+        next = this.addKnownContext(next, `Planning answer: ${prompt}`);
+      }
+    }
+
+    if (questionId.includes('approve') || questionText.includes('approve') || questionText.includes('execution')) {
+      next = {
+        ...next,
+        executionApproved: true,
+        metadata: {
+          ...(next.metadata ?? {}),
+          approvedAt: this.now(),
+          approvedFrom: 'planning-answer',
+        },
+      };
+    }
+
+    if (acceptDefault && this.isGoAhead(prompt)) {
+      next = this.withDefaultExecutionPlan({
+        ...next,
+        scope: next.scope ?? this.defaultScope(existingGoal),
+        executionApproved: true,
+        metadata: {
+          ...(next.metadata ?? {}),
+          approvedAt: this.now(),
+          approvedFrom: 'planning-go-ahead',
+        },
+      }, existingGoal);
+    }
+
+    return next;
+  }
+
+  private normalizeScopeAnswer(goal: string, answer: string): string {
+    const trimmed = answer.trim();
+    if (!trimmed) return this.defaultScope(goal);
+    if (/^scope\s+is\b/i.test(trimmed)) return trimmed;
+    return `Scope for "${goal}": ${trimmed}`;
+  }
+
+  private defaultScope(goal: string): string {
+    const cleanGoal = goal.trim() || 'the requested change';
+    return [
+      `First pass: make "${cleanGoal}" work end-to-end for the primary local TUI workflow.`,
+      'Include the minimum TUI, daemon wiring, configuration persistence, documentation, and verification required for the feature to actually work.',
+      'Exclude unrelated cleanup, broad refactors, polish-only changes, third-party integrations, and advanced distributed behavior unless they directly block the primary workflow.',
+    ].join(' ');
+  }
+
+  private withDefaultExecutionPlan(
+    state: Partial<ProjectPlanningState>,
+    goal: string,
+  ): Partial<ProjectPlanningState> {
+    const tasks = state.tasks && state.tasks.length > 0 ? [...state.tasks] : this.defaultTasks(goal);
+    const verificationGates = state.verificationGates && state.verificationGates.length > 0
+      ? [...state.verificationGates]
+      : this.defaultVerificationGates(goal);
+    const dependencies = state.dependencies && state.dependencies.length > 0
+      ? [...state.dependencies]
+      : this.defaultDependencies();
+    const agentAssignments = state.agentAssignments && state.agentAssignments.length > 0
+      ? [...state.agentAssignments]
+      : this.defaultAgentAssignments();
+    return {
+      ...state,
+      scope: state.scope ?? this.defaultScope(goal),
+      tasks,
+      verificationGates,
+      dependencies,
+      agentAssignments,
+    };
+  }
+
+  private defaultTasks(goal: string): ProjectPlanningTask[] {
+    const cleanGoal = goal.trim() || 'requested change';
+    return [
+      {
+        id: 'inspect-current-flow',
+        title: `Inspect the current paths for ${cleanGoal}`,
+        why: 'Planning must start from the actual code and runtime behavior, not assumptions.',
+        status: 'pending',
+        verification: ['Identify the relevant files, commands, config keys, and runtime path before editing.'],
+        canRunConcurrently: false,
+        needsReview: false,
+        recommendedAgent: 'explorer',
+      },
+      {
+        id: 'implement-core-behavior',
+        title: `Implement the core ${cleanGoal} behavior`,
+        why: 'This is the minimum product behavior required for the requested outcome to work.',
+        status: 'pending',
+        dependencies: ['inspect-current-flow'],
+        verification: ['Focused tests cover the changed behavior and fail without the implementation.'],
+        canRunConcurrently: false,
+        needsReview: true,
+        recommendedAgent: 'worker',
+      },
+      {
+        id: 'wire-user-surface',
+        title: `Wire the user-facing path for ${cleanGoal}`,
+        why: 'The feature must be reachable through the intended TUI/daemon/config surface, not just internal code.',
+        status: 'pending',
+        dependencies: ['implement-core-behavior'],
+        verification: ['A command, panel, route, or setting path exercises the behavior from the user-facing entry point.'],
+        canRunConcurrently: false,
+        needsReview: true,
+        recommendedAgent: 'worker',
+      },
+      {
+        id: 'verify-release-readiness',
+        title: `Verify ${cleanGoal} end-to-end`,
+        why: 'The plan is not complete until the user-facing path and regression tests prove it works.',
+        status: 'pending',
+        dependencies: ['implement-core-behavior', 'wire-user-surface'],
+        verification: ['Run focused tests plus the relevant type/build/smoke checks for the touched area.'],
+        canRunConcurrently: false,
+        needsReview: false,
+        recommendedAgent: 'none',
+      },
+    ];
+  }
+
+  private defaultDependencies(): ProjectPlanningDependency[] {
+    return [
+      { fromTaskId: 'inspect-current-flow', toTaskId: 'implement-core-behavior', reason: 'Implementation depends on knowing the current code path.' },
+      { fromTaskId: 'implement-core-behavior', toTaskId: 'wire-user-surface', reason: 'The user-facing surface should call the implemented behavior.' },
+      { fromTaskId: 'implement-core-behavior', toTaskId: 'verify-release-readiness', reason: 'Verification needs the implementation in place.' },
+      { fromTaskId: 'wire-user-surface', toTaskId: 'verify-release-readiness', reason: 'Verification must include the reachable user path.' },
+    ];
+  }
+
+  private defaultVerificationGates(goal: string): ProjectPlanningVerificationGate[] {
+    const cleanGoal = goal.trim() || 'requested change';
+    return [
+      {
+        id: 'focused-regression',
+        description: `Focused regression coverage proves "${cleanGoal}" works and prevents the observed failure from returning.`,
+        status: 'pending',
+        required: true,
+      },
+      {
+        id: 'typecheck',
+        description: 'TypeScript/build validation passes for the touched code.',
+        command: 'bunx tsc --noEmit',
+        status: 'pending',
+        required: true,
+      },
+      {
+        id: 'runtime-smoke',
+        description: 'A user-facing runtime smoke exercises the changed path when feasible.',
+        status: 'pending',
+        required: true,
+      },
+    ];
+  }
+
+  private defaultAgentAssignments(): ProjectPlanningAgentAssignment[] {
+    return [
+      {
+        taskId: 'inspect-current-flow',
+        agentType: 'explorer',
+        expectedOutput: 'Concrete files, state transitions, and failure path that must change.',
+        canRunConcurrently: false,
+      },
+      {
+        taskId: 'implement-core-behavior',
+        agentType: 'worker',
+        expectedOutput: 'Patch implementing the core behavior with focused tests.',
+        verification: 'Review the patch against the original request and regression test.',
+        canRunConcurrently: false,
+      },
+      {
+        taskId: 'wire-user-surface',
+        agentType: 'worker',
+        expectedOutput: 'Patch wiring the behavior through the intended user-facing surface.',
+        verification: 'Verify the UI/command/route actually exercises the new behavior.',
+        canRunConcurrently: false,
+      },
+    ];
+  }
+
+  private addKnownContext(state: Partial<ProjectPlanningState>, entry: string): Partial<ProjectPlanningState> {
+    const knownContext = new Set(state.knownContext ?? []);
+    knownContext.add(entry);
+    return { ...state, knownContext: [...knownContext] };
+  }
+
+  private hasStructuralPlanningGaps(state: Partial<ProjectPlanningState>): boolean {
+    return !state.scope || (state.tasks?.length ?? 0) === 0 || (state.verificationGates?.length ?? 0) === 0;
   }
 
   private recordNextQuestion(
@@ -205,12 +463,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,15 +484,32 @@ 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');
   }
 
+  private buildStatusMessage(
+    state: ProjectPlanningState,
+    evaluation: ProjectPlanningEvaluation,
+  ): string {
+    const nextQuestion = evaluation.nextQuestion?.prompt;
+    const taskCount = state.tasks.length;
+    const gateCount = state.verificationGates.length;
+    const approved = state.executionApproved ? 'approved' : 'not approved';
+    if (evaluation.readiness === 'executable') {
+      return `[Planning] Updated plan: ${taskCount} task(s), ${gateCount} verification gate(s), execution ${approved}.`;
+    }
+    return `[Planning] Updated plan: ${taskCount} task(s), ${gateCount} verification gate(s). Next: ${nextQuestion ?? 'review the plan.'}`;
+  }
+
   private isActive(state: ProjectPlanningState | null): boolean {
     return state?.metadata?.['active'] === true && state.executionApproved !== true;
   }
@@ -246,4 +525,17 @@ export class ProjectPlanningCoordinator {
   private isApproval(text: string): boolean {
     return APPROVAL_PATTERNS.some((pattern) => pattern.test(text));
   }
+
+  private acceptsDefault(text: string): boolean {
+    const trimmed = text.trim();
+    return ACCEPT_DEFAULT_PATTERNS.some((pattern) => pattern.test(trimmed));
+  }
+
+  private isGoAhead(text: string): boolean {
+    return /\b(go|go ahead|let'?s go|execute|start|approved?|approval granted)\b/i.test(text.trim());
+  }
+
+  private isGenericPlanningRecommendation(text: string): boolean {
+    return GENERIC_RECOMMENDATION_PATTERNS.some((pattern) => pattern.test(text));
+  }
 }

package/src/runtime/bootstrap-core.ts

@@ -29,6 +29,7 @@ import { registerBootstrapHookBridge } from '@/runtime/index.ts';
 import { registerBootstrapRuntimeEvents } from '@/runtime/index.ts';
 import { createRuntimeServices, type RuntimeServices } from './services.ts';
 import { createUiRuntimeServices, type UiRuntimeServices } from './ui-services.ts';
+import { installWrfcAgentToolGuard } from '../tools/wrfc-agent-guard.ts';
 
 export interface BootstrapCoreState {
   readonly userSessionId: string;
@@ -221,6 +222,7 @@ export async function initializeBootstrapCore(
     overflowHandler: services.overflowHandler,
     changeTracker: services.sessionChangeTracker,
   });
+  installWrfcAgentToolGuard(toolRegistry);
   services.agentOrchestrator.setDependencies({
     surfaceRoot: 'tui',
     fileCache,

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/tools/wrfc-agent-guard.ts

@@ -0,0 +1,83 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+
+type AgentToolArgs = {
+  readonly mode?: unknown;
+  readonly template?: unknown;
+  readonly reviewMode?: unknown;
+  readonly dangerously_disable_wrfc?: unknown;
+  readonly tasks?: unknown;
+};
+
+type AgentTaskArgs = {
+  readonly template?: unknown;
+  readonly reviewMode?: unknown;
+  readonly dangerously_disable_wrfc?: unknown;
+};
+
+const OWNER_BLOCKED_TEMPLATES = new Set(['reviewer', 'review', 'verifier', 'tester', 'test']);
+
+export function installWrfcAgentToolGuard(registry: ToolRegistry): void {
+  const agentTool = registry.list().find((tool) => tool.definition.name === 'agent');
+  if (!agentTool) throw new Error('WRFC agent guard could not find the agent tool.');
+  wrapWrfcAgentTool(agentTool);
+}
+
+export function wrapWrfcAgentTool(tool: Tool): void {
+  const originalExecute = tool.execute.bind(tool);
+  tool.execute = async (args) => {
+    const denial = validateWrfcAgentToolInvocation(args as AgentToolArgs);
+    if (denial) return { success: false, error: denial };
+    return originalExecute(args);
+  };
+}
+
+export function validateWrfcAgentToolInvocation(args: AgentToolArgs): string | null {
+  if (args.mode === 'spawn') {
+    if (isWrfcEnabled(args, args) && isBlockedOwnerTemplate(args.template)) {
+      return [
+        'WRFC spawn blocked: a WRFC root task must be an owner/engineer task, not a reviewer/verifier/tester task.',
+        'Spawn one engineer/general owner with reviewMode:"wrfc"; WRFC creates reviewer and fixer agents only after owner output exists.',
+      ].join(' ');
+    }
+    return null;
+  }
+
+  if (args.mode !== 'batch-spawn') return null;
+  const tasks = Array.isArray(args.tasks) ? args.tasks.filter(isRecord) : [];
+  const wrfcTasks = tasks.filter((task) => isWrfcEnabled(task, args));
+  if (wrfcTasks.length === 0) return null;
+
+  if (tasks.length !== 1 || wrfcTasks.length !== 1) {
+    return [
+      'WRFC batch-spawn blocked: WRFC must start as exactly one owner task.',
+      'Do not batch an engineer with reviewer/verifier/tester tasks.',
+      'Spawn one engineer/general owner with reviewMode:"wrfc"; the WRFC controller creates review/fix agents after the owner deliverable exists.',
+    ].join(' ');
+  }
+
+  const [task] = wrfcTasks;
+  if (isBlockedOwnerTemplate(task.template ?? args.template)) {
+    return [
+      'WRFC batch-spawn blocked: the single WRFC task must be an owner/engineer task, not a reviewer/verifier/tester task.',
+      'Use template:"engineer" or template:"general" with reviewMode:"wrfc".',
+    ].join(' ');
+  }
+
+  return null;
+}
+
+function isRecord(value: unknown): value is AgentTaskArgs {
+  return Boolean(value) && typeof value === 'object';
+}
+
+function isWrfcEnabled(task: AgentTaskArgs, root: AgentToolArgs): boolean {
+  const disabled = task.dangerously_disable_wrfc === true || root.dangerously_disable_wrfc === true;
+  if (disabled) return false;
+  return task.reviewMode === 'wrfc' || root.reviewMode === 'wrfc';
+}
+
+function isBlockedOwnerTemplate(value: unknown): boolean {
+  if (typeof value !== 'string') return false;
+  return OWNER_BLOCKED_TEMPLATES.has(value.trim().toLowerCase());
+}

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