bingocode 1.1.183 → 1.1.185

package/.claude/scheduled_tasks.json

@@ -0,0 +1,34 @@
+{
+  "tasks": [
+    {
+      "id": "274f11cf",
+      "cron": "0 9 * * *",
+      "prompt": "test prompt",
+      "createdAt": 1782997215925,
+      "recurring": true,
+      "name": "test-name",
+      "description": "test description",
+      "folder": "/test/folder",
+      "model": "claude-opus-4-7",
+      "permissionMode": "ask",
+      "worktree": false,
+      "frequency": "daily",
+      "scheduledTime": "09:00"
+    },
+    {
+      "id": "1c4152a1",
+      "cron": "0 9 * * *",
+      "prompt": "test prompt",
+      "createdAt": 1782998699654,
+      "recurring": true,
+      "name": "test-name",
+      "description": "test description",
+      "folder": "/test/folder",
+      "model": "claude-opus-4-7",
+      "permissionMode": "ask",
+      "worktree": false,
+      "frequency": "daily",
+      "scheduledTime": "09:00"
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.1.183",
+  "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,
@@ -1793,38 +1776,5 @@ export function setPromptId(id: string | null): void {
 // /goal session state accessors
 // ============================================================================
 
-export function getGoalCondition(): string | null {
-  return STATE.goalCondition
-}
-
-export function setGoalCondition(condition: string | null): void {
-  STATE.goalCondition = condition
-  STATE.goalIterationCount = 0
-}
-
-export function getGoalIterationCount(): number {
-  return STATE.goalIterationCount
-}
-
-export function incrementGoalIterationCount(): void {
-  STATE.goalIterationCount++
-}
-
-export function getGoalMaxIterations(): number {
-  return STATE.goalMaxIterations
-}
-
-// Goal evaluator history accessors
-export function getGoalEvalHistory() {
-  return STATE.goalEvalHistory
-}
-
-export function updateGoalEvalHistory(lastGap: string | null): void {
-  if (lastGap === STATE.goalEvalHistory.lastGap) {
-    STATE.goalEvalHistory.consecutiveSameGapCount++
-  } else {
-    STATE.goalEvalHistory.lastGap = lastGap
-    STATE.goalEvalHistory.consecutiveSameGapCount = 1
-  }
-}
+// ============================================================================
 

package/src/hooks/useGoalAutoUpdater.ts

@@ -0,0 +1,187 @@
+/**
+ * Goal Auto-Updater Hook — bridges agent tool execution with goal state.
+ *
+ * Monitors PostToolUse events and automatically updates goal state in real-time.
+ * This replaces the manual "output EVAL blocks" approach with automatic state
+ * tracking based on what the agent actually does.
+ *
+ * Integration point: called in REPL.tsx after each tool execution completes.
+ * Uses the GoalStore to update state, which triggers re-renders in any
+ * subscribed components via the signal pattern.
+ */
+
+import type { ToolResult, SubGoalStatus } from '../types/goal.js'
+import { getGoalState, addArtifact, updateSubGoalStatus, recalculateProgress } from '../utils/goalStore.js'
+import { asSubGoalId } from '../utils/goalHelpers.js'
+import { assessDrift } from '../utils/goalDrift.js'
+import type { DriftAssessment, SubGoal } from '../types/goal.js'
+
+/**
+ * Classify a tool execution result into a goal-relevant action category.
+ * Returns null if the tool is not relevant to goal progress tracking.
+ */
+function classifyToolAction(
+  toolName: string,
+  toolInput: Record<string, unknown>,
+  toolOutput: string,
+  success: boolean,
+): ToolAction | null {
+  // Read-only tools (query) → informational, not state-changing
+  if (isReadTool(toolName)) return null
+
+  // Write tools (create/modify)
+  if (isCreateTool(toolName)) {
+    const filePath = extractFilePath(toolInput)
+    return {
+      type: 'create',
+      filePath,
+      subGoalId: inferSubGoal(toolName, filePath),
+      description: `Created ${filePath}`,
+    }
+  }
+
+  // Build tools (verify)
+  if (isVerifyTool(toolName)) {
+    return {
+      type: 'verify',
+      filePath: extractFilePath(toolInput),
+      subGoalId: inferSubGoal(toolName, extractFilePath(toolInput)),
+      description: `Verified with ${toolName}`,
+    }
+  }
+
+  // Default: generic mutation
+  return {
+    type: 'modify',
+    filePath: extractFilePath(toolInput),
+    subGoalId: inferSubGoal(toolName, extractFilePath(toolInput)),
+    description: `Modified via ${toolName}`,
+  }
+}
+
+type ToolAction = {
+  type: 'create' | 'modify' | 'verify'
+  filePath: string
+  subGoalId: string
+  description: string
+}
+
+/** Update goal state after a tool execution. Called from REPL.tsx after
+ *  each PostToolUse event. Also performs drift assessment to detect
+ *  when agent behavior starts deviating from target goals. */
+export function useGoalAutoUpdater(
+  toolResult: ToolResult,
+): void {
+  const state = getGoalState()
+  if (!state.activeGoalId) return
+  if (!state.operationalGoal) return
+
+  const action = classifyToolAction(
+    toolResult.toolName,
+    toolResult.toolInput,
+    toolResult.toolOutput,
+    toolResult.success,
+  )
+
+  if (!action) return
+
+  // Phase 1: Update goal state based on action type
+  switch (action.type) {
+    case 'create':
+      addArtifact(action.filePath)
+      break
+    case 'modify':
+      addArtifact(action.filePath)
+      break
+    case 'verify':
+      updateSubGoalStatus(action.subGoalId, 'active')
+      break
+  }
+
+  // Phase 2: Recalculate progress after state mutation
+  recalculateProgress()
+
+  // Phase 3: Assess drift (after state update, before next turn)
+  const currentSubGoal = state.dag.nodes.get(action.subGoalId)
+  if (currentSubGoal) {
+    const drift = assessDrift(
+      action.description ?? `${toolResult.toolName}: ${toolResult.toolOutput.slice(0, 100)}`,
+      currentSubGoal,
+      state.operationalGoal.text,
+    )
+
+    // Log drift warnings for debugging — future: escalate to enqueue()
+    if (drift.warnings.length > 0) {
+      const highWarnings = drift.warnings.filter(w => w.severity === 'high')
+      if (highWarnings.length > 0) {
+        // Drift is severe — agent should replan
+        // TODO: wire into enqueue() for user-visible warning
+        console.warn(`[GoalDrift] ${drift.warnings.length} warning(s): score ${drift.consistencyScore}%, trend ${drift.trend}`)
+      }
+    }
+  }
+}
+
+// ============================================================================
+// Helpers
+// ============================================================================
+
+/** Check if a tool is read-only (doesn't modify state). */
+function isReadTool(toolName: string): boolean {
+  const readTools = new Set([
+    'Read',
+    'Glob',
+    'Grep',
+    'LS',
+    'WebSearch',
+    'WebFetch',
+    'TaskOutput',
+    'TaskStatus',
+  ])
+  return readTools.has(toolName)
+}
+
+/** Check if a tool creates new files. */
+function isCreateTool(toolName: string): boolean {
+  const createTools = new Set([
+    'Write',
+    'Edit',    // can create or modify, but classified as create for new files
+    'NotebookEdit',
+  ])
+  return createTools.has(toolName)
+}
+
+/** Check if a tool verifies existing work (tests, builds). */
+function isVerifyTool(toolName: string): boolean {
+  const verifyTools = new Set([
+    'Bash',     // often used for test/build commands
+  ])
+  return verifyTools.has(toolName)
+}
+
+/** Extract file path from tool input. Handles different tool input shapes. */
+function extractFilePath(input: Record<string, unknown>): string {
+  if (typeof input.file_path === 'string') return input.file_path
+  if (typeof input.path === 'string') return input.path
+  if (typeof input.notebook_path === 'string') return input.notebook_path
+  return ''
+}
+
+/** Infer which sub-goal this tool action likely belongs to.
+ *  Uses file path heuristics to match against known sub-goals. */
+function inferSubGoal(toolName: string, filePath: string): string {
+  // For now, use a simple heuristic — match by file path pattern
+  // This will be enhanced in Phase 6 with actual DAG integration
+  if (!filePath) return 'unknown'
+
+  // Strip the path and use the filename as a sub-goal identifier
+  // In practice, the real mapping will come from the DAG's SubGoal nodes
+  const fileName = filePath.split('/').pop()?.split('\\').pop() ?? filePath
+  return `task-${fileName}`
+}
+
+// ============================================================================
+// Re-export for convenience
+// ============================================================================
+
+export { getGoalState as useGoalStore }

package/src/hooks/useGoalEvaluator.ts

@@ -1,15 +1,25 @@
+/**
+ * Goal evaluator hook — post-turn goal assessment.
+ *
+ * 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'
+  getGoalState,
+  recalculateProgress,
+  incrementIteration,
+  recordEvalGap,
+  getActiveGoalId,
+  getReadySubGoals,
+  getBlockedSubGoals,
+} from '../utils/goalStore.js'
 import { enqueue } from '../utils/messageQueueManager.js'
 import { evaluateGoal } from '../utils/goalEvaluator.js'
 
@@ -20,16 +30,15 @@ type UseGoalEvaluatorParams = {
 }
 
 /**
- * React hook that fires an independent goal evaluator after each turn.
+ * React hook — fires after each turn. Triggered by lastQueryCompletionTime.
+ * Uses messagesRef (sync ref, not React state) to avoid batching issues.
  *
- * Triggered by lastQueryCompletionTime changing (set in REPL.tsx after
- * queryGuard.end() succeeds). Uses messagesRef (not React state) to avoid
- * batching issues — the ref is synchronously updated via Zustand pattern
- * before React re-renders.
- *
- * On goal not satisfied: enqueues a continuation message with priority 'now'
- * so useQueueProcessor picks it up immediately for the next turn.
- * On goal satisfied or max iterations reached: clears the goal condition.
+ * Flow:
+ *   1. Check max iterations reached → if so, stop
+ *   2. Call env-aware evaluator v2 (rule engine + Haiku + main model)
+ *   3. On satisfied → clear goal, enqueue success message
+ *   4. On repeated gap (3x) → circuit breaker, clear goal
+ *   5. On not satisfied → enqueue continuation message
  */
 export function useGoalEvaluator({
   lastQueryCompletionTime,
@@ -40,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
@@ -52,49 +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 — 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
         }
 
-        // Read snapshot BEFORE await to avoid stale data
+        // Get messages + current sub-goal for evaluation context
         const messages = messagesRef.current
-        const result = await evaluateGoal(condition, messages)
+        const currentSubGoal = goalState.immediateGoal
+          ? goalState.dag.nodes.get(goalState.immediateGoal.subGoalId)
+          : undefined
+
+        // Run environment-aware evaluation (rule engine + semantic + final)
+        const result = await evaluateGoal(condition, messages, currentSubGoal)
 
-        // Race protection: user may have called /goal clear during the 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
+        }
 
-        // Check for repeated gaps - implement circuit breaker
-        const evalHistory = getGoalEvalHistory()
+        // Circuit breaker: 3 consecutive same gap
+        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) {
-          // Circuit breaker: stop after 3 repeated gaps
-          setGoalCondition(null)
+          // Circuit breaker — same gap repeated 3 times, stop looping
+          const { clear } = require('../utils/goalStore.js')
+          clear()
           enqueue({
-            value: `⚠️ Goal evaluator stopped after detecting the same gap "${result.gap}" 3 times in a row. Please adjust your approach or output EVAL blocks in the correct format.`,
+            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}"`
@@ -104,10 +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
       }
     })()
-    // messages intentionally excluded from deps — read via ref to avoid batching issues
-  }, [lastQueryCompletionTime, isQueryActive])
+  }, [lastQueryCompletionTime, isQueryActive]) // messagesRef is stable ref — not included as dep
 }

package/src/query.ts

@@ -110,6 +110,8 @@ import {
 } from './bootstrap/state.js'
 import { createBudgetTracker, checkTokenBudget } from './query/tokenBudget.js'
 import { count } from './utils/array.js'
+import { convertSDKToolResults } from './utils/goalHelpers.js'
+import { useGoalAutoUpdater } from './hooks/useGoalAutoUpdater.js'
 
 /* eslint-disable @typescript-eslint/no-require-imports */
 const snipModule = feature('HISTORY_SNIP')
@@ -1408,6 +1410,25 @@ async function* queryLoop(
     }
     queryCheckpoint('query_tool_execution_end')
 
+    // === Goal system auto-update: PostToolUse hook ===
+    // Update goal state based on actual tool execution results.
+    // This replaces the old "output EVAL blocks" approach — now we track
+    // progress automatically from what the agent actually does.
+    if (toolUseBlocks.length > 0) {
+      try {
+        const goalResults = convertSDKToolResults(
+          toolUseBlocks as ReadonlyArray<{ id: string; name: string; input: Record<string, unknown> }>,
+          toolResults as ReadonlyArray<{ type: string; message: { content: { type: string; text?: string; tool_use_id?: string; content?: string }[] } }>,
+        )
+        for (const result of goalResults) {
+          useGoalAutoUpdater(result)
+        }
+      } catch (err) {
+        // Goal auto-update is non-critical — don't block the main loop
+        logError('goal_auto_update_error', err instanceof Error ? err.message : String(err))
+      }
+    }
+
     // Generate tool use summary after tool batch completes — passed to next recursive call
     let nextPendingToolUseSummary:
       | Promise<ToolUseSummaryMessage | null>

package/src/skills/bundled/goal.ts

@@ -1,27 +1,30 @@
-import {
-  getGoalCondition,
-  getGoalMaxIterations,
-  setGoalCondition,
-} from '../../bootstrap/state.js'
+/**
+ * Goal command — CLI entry point for Goal Management system.
+ *
+ * 4-layer architecture: User Goal → Operational Goal → Sub Goals → Immediate Goal.
+ * Orchestrates creation, status queries, and management commands.
+ */
+
+import { getGoalState, setUserGoal, setOperationalGoal, clearState } from '../../utils/goalStore.js'
 import { registerBundledSkill } from '../bundledSkills.js'
 
-const USAGE = `Usage: /goal <condition>
+const USAGE = `Usage: /goal <create | clear | cancel>
 
-Set a session goal. The agent will keep working until the condition is met.
+Set a session goal. Agent will work autonomously until goal met.
 
 Examples:
-  /goal all tests pass
-  /goal login flow handles empty email without crash
-  /goal PR is ready for review with passing CI
+  /goal create all tests pass
+  /goal create login flow handles empty email without crash
+  /goal create PR ready for review with passing CI
 
-To cancel: /goal clear`
+To cancel: /goal clear or /goal cancel`
 
 export function registerGoalSkill(): void {
   registerBundledSkill({
     name: 'goal',
     description:
-      'Set a session-level goal condition and loop until met. Use when user says "/goal <condition>" or wants autonomous execution until a specific outcome is reached.',
-    argumentHint: '<condition | clear>',
+      'Manage task goals with hierarchical decomposition and progress tracking.',
+    argumentHint: '<create | clear | cancel>',
     userInvocable: true,
     async getPromptForCommand(args) {
       const trimmed = args.trim()
@@ -30,48 +33,54 @@ export function registerGoalSkill(): void {
         return [{ type: 'text', text: USAGE }]
       }
 
-      if (['clear', 'stop', 'cancel'].includes(trimmed)) {
-        const current = getGoalCondition()
-        if (current) {
-          setGoalCondition(null)
+      // --- Cancel / Clear ---
+      if (['clear', 'stop', 'cancel'].includes(trimmed.toLowerCase())) {
+        const state = getGoalState()
+        if (state.activeGoalId) {
+          const userText = state.userGoal?.text ?? '(unknown)'
+          clearState()
           return [
             {
               type: 'text',
-              text: `Goal cancelled: "${current}". Tell the user their goal has been cancelled.`,
+              text: `Goal cancelled: "${userText}". Goal state cleared from memory and disk.`,
             },
           ]
         }
         return [
           {
             type: 'text',
-            text: 'No active goal to cancel. Tell the user there is no active goal.',
+            text: 'No active goal. Use `/goal create <text>` to start.',
           },
         ]
       }
 
-      setGoalCondition(trimmed)
-      const maxIter = getGoalMaxIterations()
+      // --- Create ---
+      setUserGoal(trimmed)
+      setOperationalGoal(trimmed)
+      const state = getGoalState()
+      const maxIter = state.metrics.maxIterations
 
       return [
         {
           type: 'text',
           text: `# /goal activated
 
-Goal condition: "${trimmed}"
-
-This goal is now registered for this session. After each turn, an independent evaluator (Haiku 4.5, a weak model) will check whether the goal is satisfied. Maximum ${maxIter} iterations.
+**Goal**: "${trimmed}"
+**Architecture**: User Goal → Operational Goal → DAG Sub Goals → Immediate Action
+**Max iterations**: ${maxIter}
 
-CRITICAL: The evaluator reads ONLY your text output. It cannot see code changes, tool results, or file contents — only the plain text you write.
+The evaluator now uses **environment-aware assessment** (3 tiers):
+  Level 1: Rule engine — checks file existence, test output, compile status
+  Level 2: Haiku 4.5 — semantic interpretation of evidence
+  Level 3: Main model — final verification (ambiguous cases only)
 
-	At each turn toward the goal, output a short evaluation block like:
-	EVAL: [metric1]: [value] / [target] → ✓ or ✗
+EVAL blocks still welcome for agent self-reporting, but no longer required.
+  Format: \`EVAL: metric: value / target → ✓ or ✗\`
 
-	This block is the ONLY signal the evaluator can reliably process. Make it short,
-	unambiguous, and quantitative. Do NOT expect the evaluator to infer success from narrative discussion.
-	Note: The EVAL block can appear anywhere in your text response (not just in quote blocks).
+Tell user: Goal set. Agent works autonomously until "${trimmed}" achieved (max ${maxIter} turns).
+Send \`/goal clear\` to cancel.
 
-Tell the user: Goal set — you will work autonomously until "${trimmed}" is achieved (max ${maxIter} turns). Send \`/goal clear\` to cancel.
-Now begin: assess current state and take the first concrete action toward the goal.`,
+Now: assess current state, take first concrete action toward goal.`,
         },
       ]
     },