@pellux/goodvibes-tui 0.19.82 → 0.19.83

package/CHANGELOG.md

@@ -4,6 +4,11 @@ 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

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.82-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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-tui",
-  "version": "0.19.82",
+  "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",

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/project-planning-panel.ts

@@ -267,7 +267,7 @@ export class ProjectPlanningPanel extends BasePanel {
     if (question.whyItMatters) {
       lines.push(...buildBodyText(width, `Why this matters: ${question.whyItMatters}`, C, C.dim));
     }
-    if (question.recommendedAnswer) {
+    if (question.recommendedAnswer && !this.isGenericRecommendation(question.recommendedAnswer)) {
       lines.push(...buildBodyText(width, `Recommendation: ${question.recommendedAnswer}`, C, C.good));
     }
     lines.push(...buildBodyText(
@@ -321,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));
       }
     }
@@ -469,6 +469,8 @@ export class ProjectPlanningPanel extends BasePanel {
     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({
@@ -479,7 +481,31 @@ export class ProjectPlanningPanel extends BasePanel {
         kind: 'approve',
       });
     }
-    if (question.recommendedAnswer?.trim()) {
+    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',
@@ -517,6 +543,13 @@ export class ProjectPlanningPanel extends BasePanel {
     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()) {

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(
@@ -238,6 +496,20 @@ export class ProjectPlanningCoordinator {
     ].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;
   }
@@ -253,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/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.82';
+let _version = '0.19.83';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;