bingocode 1.1.184 → 1.1.185

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.1.184",
+  "version": "1.1.185",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",

package/src/bootstrap/state.ts

@@ -135,16 +135,7 @@ type State = {
   // (useScheduledTasks). Set by cronScheduler.start() when the JSON has
   // entries, or by CronCreateTool. Not persisted.
   scheduledTasksEnabled: boolean
-  // Session-only goal condition for /goal command. Null when no active goal.
-  goalCondition: string | null
-  goalIterationCount: number
-  goalMaxIterations: number
-  // Goal evaluator history for detecting repeated gaps
-  goalEvalHistory: {
-    lastGap: string | null
-    consecutiveSameGapCount: number
-  }
-  // Session-only cron tasks created via CronCreate with durable: false.
+    // Session-only cron tasks created via CronCreate with durable: false.
   // Fire on schedule like file-backed tasks but are never written to
   // .claude/scheduled_tasks.json — they die with the process. Typed via
   // SessionCronTask below (not importing from cronTasks.ts keeps
@@ -366,15 +357,7 @@ function getInitialState(): State {
     sessionBypassPermissionsMode: false,
     // Scheduled tasks disabled until flag or dialog enables them
     scheduledTasksEnabled: false,
-    // Goal condition for /goal command (null = no active goal)
-    goalCondition: null,
-    goalIterationCount: 0,
-    goalMaxIterations: 20,
-    goalEvalHistory: {
-      lastGap: null,
-      consecutiveSameGapCount: 0,
-    },
-    sessionCronTasks: [],
+        sessionCronTasks: [],
     sessionCreatedTeams: new Set(),
     // Session-only trust flag (not persisted to disk)
     sessionTrustAccepted: false,
@@ -1794,85 +1777,4 @@ export function setPromptId(id: string | null): void {
 // ============================================================================
 
 // ============================================================================
-// /goal session state accessors (DEPRECATED — use goalStore.ts instead)
-// ============================================================================
-// These accessors are kept for backwards compatibility with existing code.
-// They delegate to the new GoalStore in src/utils/goalStore.ts.
-// New code should import from goalStore.ts directly.
-// TODO: remove after all consumers are migrated.
-
-import { getGoalState as _getGoalState } from '../utils/goalStore.js'
-
-export function getGoalCondition(): string | null {
-  try {
-    return _getGoalState().userGoal?.text ?? _getGoalState().operationalGoal?.text ?? null
-  } catch {
-    return STATE.goalCondition // fallback to old field during migration
-  }
-}
-
-export function setGoalCondition(condition: string | null): void {
-  if (condition) {
-    try {
-      // Delegate to new store for structured goal management
-      const { setUserGoal: _setUserGoal, setOperationalGoal: _setOperationalGoal } = require('../utils/goalStore.js')
-      _setUserGoal(condition)
-      _setOperationalGoal(condition)
-    } catch {
-      STATE.goalCondition = condition // fallback
-      STATE.goalIterationCount = 0
-    }
-  } else {
-    STATE.goalCondition = null
-    STATE.goalIterationCount = 0
-  }
-}
-
-export function getGoalIterationCount(): number {
-  try {
-    return _getGoalState().metrics.iterationCount
-  } catch {
-    return STATE.goalIterationCount
-  }
-}
-
-export function incrementGoalIterationCount(): void {
-  try {
-    const { incrementIteration } = require('../utils/goalStore.js')
-    incrementIteration()
-  } catch {
-    STATE.goalIterationCount++
-  }
-}
-
-export function getGoalMaxIterations(): number {
-  try {
-    return _getGoalState().metrics.maxIterations
-  } catch {
-    return STATE.goalMaxIterations
-  }
-}
-
-// Goal evaluator history accessors (DEPRECATED — use goalStore.ts)
-export function getGoalEvalHistory() {
-  try {
-    return _getGoalState().metrics.evalHistory
-  } catch {
-    return STATE.goalEvalHistory
-  }
-}
-
-export function updateGoalEvalHistory(lastGap: string | null): void {
-  try {
-    const { recordEvalGap: _recordEvalGap } = require('../utils/goalStore.js')
-    _recordEvalGap(lastGap)
-  } catch {
-    if (lastGap === STATE.goalEvalHistory.lastGap) {
-      STATE.goalEvalHistory.consecutiveSameGapCount++
-    } else {
-      STATE.goalEvalHistory.lastGap = lastGap
-      STATE.goalEvalHistory.consecutiveSameGapCount = 1
-    }
-  }
-}
 

package/src/hooks/useGoalEvaluator.ts

@@ -3,21 +3,23 @@
  *
  * Fires after each turn completes (triggered by lastQueryCompletionTime change).
  * Evaluates progress toward active goal using env-aware evaluator v2.
+ *
+ * Migrated from old state.ts flat fields to the new GoalStore API.
+ * All state access goes through GoalStore — no more STATE.goalCondition fallbacks.
  */
 
 import { useEffect, useRef } from 'react'
 import type { MutableRefObject } from 'react'
 import type { MessageType } from '../components/messages.js'
 import {
-  getGoalCondition,
-  getGoalIterationCount,
-  getGoalMaxIterations,
-  incrementGoalIterationCount,
-  setGoalCondition,
-  getGoalEvalHistory,
-  updateGoalEvalHistory,
-} from '../bootstrap/state.js'
-import { getGoalState, recalculateProgress } from '../utils/goalStore.js'
+  getGoalState,
+  recalculateProgress,
+  incrementIteration,
+  recordEvalGap,
+  getActiveGoalId,
+  getReadySubGoals,
+  getBlockedSubGoals,
+} from '../utils/goalStore.js'
 import { enqueue } from '../utils/messageQueueManager.js'
 import { evaluateGoal } from '../utils/goalEvaluator.js'
 
@@ -47,7 +49,8 @@ export function useGoalEvaluator({
   const evaluating = useRef(false)
 
   useEffect(() => {
-    const condition = getGoalCondition()
+    const goalState = getGoalState()
+    const condition = goalState.userGoal?.text ?? null
     if (!condition) return
     if (isQueryActive) return
     if (lastQueryCompletionTime === 0) return
@@ -59,56 +62,71 @@ export function useGoalEvaluator({
 
     void (async () => {
       try {
-        const iterCount = getGoalIterationCount()
-        const maxIter = getGoalMaxIterations()
+        const iterCount = goalState.metrics.iterationCount
+        const maxIter = goalState.metrics.maxIterations
 
-        // Max iterations check
+        // Max iterations check — circuit breaker
         if (iterCount >= maxIter) {
-          setGoalCondition(null)
+          // Clear goal from store (delegates to clear() which resets engine too)
+          const { clear } = require('../utils/goalStore.js')
+          clear()
           enqueue({
-            value: `⚠️ /goal stopped after ${maxIter} iterations. Goal not achieved: "${condition}"`,
+            value: `Goal not achieved after ${maxIter} iterations. Goal was: "${condition}"`,
             mode: 'task-notification',
             priority: 'now',
           })
           return
         }
 
-        // Get current goal state + sub-goal from store
+        // Get messages + current sub-goal for evaluation context
         const messages = messagesRef.current
-        const goalState = getGoalState()
         const currentSubGoal = goalState.immediateGoal
           ? goalState.dag.nodes.get(goalState.immediateGoal.subGoalId)
           : undefined
 
-        // Run environment-aware evaluation
+        // Run environment-aware evaluation (rule engine + semantic + final)
         const result = await evaluateGoal(condition, messages, currentSubGoal)
 
-        // Race: user may have cleared goal during await
-        if (getGoalCondition() !== condition) return
+        // Race: user may have cleared goal during async evaluation
+        if (!getActiveGoalId()) return
 
-        incrementGoalIterationCount()
-        updateGoalEvalHistory(result.gap)
+        incrementIteration()
+        recordEvalGap(result.gap)
         recalculateProgress()
 
+        // Check active sub-goals and blocked count for drift diagnosis
+        const ready = getReadySubGoals()
+        const blocked = getBlockedSubGoals()
+        if (blocked.length > 0 && ready.length === 0) {
+          // All sub-goals blocked — need to replan or escalate
+          void ready
+          void blocked
+        }
+
         // Circuit breaker: 3 consecutive same gap
-        const evalHistory = getGoalEvalHistory()
+        const evalHistory = goalState.metrics.evalHistory
         const isRepeatedGap = evalHistory.consecutiveSameGapCount >= 3 && result.gap !== null
 
         if (result.satisfied) {
-          setGoalCondition(null)
+          // Goal achieved — clear from store and file system
+          const { clearAndDelete } = require('../utils/goalStore.js')
+          clearAndDelete()
           enqueue({
-            value: `✅ Goal achieved (iteration ${iterCount + 1}): ${result.reason}`,
+            value: `Goal achieved (iteration ${iterCount + 1}): ${result.reason}`,
             mode: 'task-notification',
             priority: 'now',
           })
         } else if (isRepeatedGap) {
-          setGoalCondition(null)
+          // Circuit breaker — same gap repeated 3 times, stop looping
+          const { clear } = require('../utils/goalStore.js')
+          clear()
           enqueue({
-            value: `⚠️ Goal evaluator stopped — same gap "${result.gap}" 3x. Adjust approach or output EVAL blocks.`,
+            value: `Goal evaluator stopped — same gap "${result.gap}" ${evalHistory.consecutiveSameGapCount}x. Adjust approach or output EVAL blocks.`,
             mode: 'task-notification',
             priority: 'now',
           })
         } else {
+          // Not yet satisfied — continue
           const continueMsg = result.gap
             ? `Goal not yet met (${iterCount + 1}/${maxIter}). Gap: ${result.gap}. Continue toward: "${condition}"`
             : `Goal not yet met (${iterCount + 1}/${maxIter}, reason: ${result.reason}). Continue toward: "${condition}"`
@@ -118,9 +136,12 @@ export function useGoalEvaluator({
             priority: 'now',
           })
         }
+      } catch (err) {
+        // Evaluation error is non-fatal — log and continue
+        console.error('[GoalEvaluator] Evaluation error:', err)
       } finally {
         evaluating.current = false
       }
     })()
-  }, [lastQueryCompletionTime, isQueryActive])
+  }, [lastQueryCompletionTime, isQueryActive]) // messagesRef is stable ref — not included as dep
 }