bingocode 1.1.183 → 1.1.184

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.184",
   "type": "module",
   "bin": {
     "claude": "bin/claude-win.cjs",

package/src/bootstrap/state.ts

@@ -1793,38 +1793,86 @@ export function setPromptId(id: string | null): void {
 // /goal session state accessors
 // ============================================================================
 
+// ============================================================================
+// /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 {
-  return STATE.goalCondition
+  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 {
-  STATE.goalCondition = condition
-  STATE.goalIterationCount = 0
+  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 {
-  return STATE.goalIterationCount
+  try {
+    return _getGoalState().metrics.iterationCount
+  } catch {
+    return STATE.goalIterationCount
+  }
 }
 
 export function incrementGoalIterationCount(): void {
-  STATE.goalIterationCount++
+  try {
+    const { incrementIteration } = require('../utils/goalStore.js')
+    incrementIteration()
+  } catch {
+    STATE.goalIterationCount++
+  }
 }
 
 export function getGoalMaxIterations(): number {
-  return STATE.goalMaxIterations
+  try {
+    return _getGoalState().metrics.maxIterations
+  } catch {
+    return STATE.goalMaxIterations
+  }
 }
 
-// Goal evaluator history accessors
+// Goal evaluator history accessors (DEPRECATED — use goalStore.ts)
 export function getGoalEvalHistory() {
-  return STATE.goalEvalHistory
+  try {
+    return _getGoalState().metrics.evalHistory
+  } catch {
+    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
+  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/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,3 +1,10 @@
+/**
+ * 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.
+ */
+
 import { useEffect, useRef } from 'react'
 import type { MutableRefObject } from 'react'
 import type { MessageType } from '../components/messages.js'
@@ -10,6 +17,7 @@ import {
   getGoalEvalHistory,
   updateGoalEvalHistory,
 } from '../bootstrap/state.js'
+import { getGoalState, recalculateProgress } from '../utils/goalStore.js'
 import { enqueue } from '../utils/messageQueueManager.js'
 import { evaluateGoal } from '../utils/goalEvaluator.js'
 
@@ -20,16 +28,15 @@ type UseGoalEvaluatorParams = {
 }
 
 /**
- * React hook that fires an independent goal evaluator after each turn.
- *
- * 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.
+ * React hook — fires after each turn. Triggered by lastQueryCompletionTime.
+ * Uses messagesRef (sync ref, not React state) to avoid batching issues.
  *
- * 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,
@@ -55,6 +62,7 @@ export function useGoalEvaluator({
         const iterCount = getGoalIterationCount()
         const maxIter = getGoalMaxIterations()
 
+        // Max iterations check
         if (iterCount >= maxIter) {
           setGoalCondition(null)
           enqueue({
@@ -65,17 +73,24 @@ export function useGoalEvaluator({
           return
         }
 
-        // Read snapshot BEFORE await to avoid stale data
+        // Get current goal state + sub-goal from store
         const messages = messagesRef.current
-        const result = await evaluateGoal(condition, messages)
+        const goalState = getGoalState()
+        const currentSubGoal = goalState.immediateGoal
+          ? goalState.dag.nodes.get(goalState.immediateGoal.subGoalId)
+          : undefined
+
+        // Run environment-aware evaluation
+        const result = await evaluateGoal(condition, messages, currentSubGoal)
 
-        // Race protection: user may have called /goal clear during the await
+        // Race: user may have cleared goal during await
         if (getGoalCondition() !== condition) return
 
         incrementGoalIterationCount()
         updateGoalEvalHistory(result.gap)
+        recalculateProgress()
 
-        // Check for repeated gaps - implement circuit breaker
+        // Circuit breaker: 3 consecutive same gap
         const evalHistory = getGoalEvalHistory()
         const isRepeatedGap = evalHistory.consecutiveSameGapCount >= 3 && result.gap !== null
 
@@ -87,10 +102,9 @@ export function useGoalEvaluator({
             priority: 'now',
           })
         } else if (isRepeatedGap) {
-          // Circuit breaker: stop after 3 repeated gaps
           setGoalCondition(null)
           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}" 3x. Adjust approach or output EVAL blocks.`,
             mode: 'task-notification',
             priority: 'now',
           })
@@ -108,6 +122,5 @@ export function useGoalEvaluator({
         evaluating.current = false
       }
     })()
-    // messages intentionally excluded from deps — read via ref to avoid batching issues
   }, [lastQueryCompletionTime, isQueryActive])
 }

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.`,
         },
       ]
     },