bingocode 1.1.184 → 1.1.186

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
 }

package/src/utils/attachments.ts

@@ -63,7 +63,7 @@ import {
   isValidImagePaste,
 } from 'src/types/textInputTypes.js'
 import { randomUUID, type UUID } from 'crypto'
-import { getSettings_DEPRECATED } from './settings/settings.js'
+import { getInitialSettings, getSettings_DEPRECATED } from './settings/settings.js'
 import { getSnippetForTwoFileDiff } from 'src/tools/FileEditTool/utils.js'
 import type {
   ContentBlockParam,
@@ -915,6 +915,9 @@ export async function getAttachments(
     maybe('critical_system_reminder', () =>
       Promise.resolve(getCriticalSystemReminderAttachment(toolUseContext)),
     ),
+    maybe('exec_mode_reminder', () =>
+      Promise.resolve(getExecModeReminderAttachment()),
+    ),
     ...(feature('COMPACTION_REMINDERS')
       ? [
           maybe('compaction_reminder', () =>
@@ -1590,6 +1593,19 @@ function getCriticalSystemReminderAttachment(
   return [{ type: 'critical_system_reminder', content: reminder }]
 }
 
+function getExecModeReminderAttachment(): Attachment[] {
+  if (!getInitialSettings().execMode) {
+    return []
+  }
+  return [
+    {
+      type: 'system_reminder' as const,
+      content:
+        '/exec active — Dispatch first. Protect context. Report decisions, blockers, results.',
+    },
+  ]
+}
+
 function getOutputStyleAttachment(): Attachment[] {
   const settings = getSettings_DEPRECATED()
   const outputStyle = settings?.outputStyle || 'default'

package/src/utils/settings/types.ts

@@ -725,6 +725,12 @@ export const SettingsSchema = lazySchema(() =>
         .describe(
           'When true, fast mode does not persist across sessions. Each session starts with fast mode off.',
         ),
+      execMode: z
+        .boolean()
+        .optional()
+        .describe(
+          'Priority dispatch, context protection, compressed reporting.',
+        ),
       promptSuggestionEnabled: z
         .boolean()
         .optional()