bingocode 1.1.100 → 1.1.101

package/package.json

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

package/src/bootstrap/state.ts

@@ -135,6 +135,10 @@ 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
   // 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
@@ -357,6 +361,10 @@ 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,
     sessionCronTasks: [],
     sessionCreatedTeams: new Set(),
     // Session-only trust flag (not persisted to disk)
@@ -1772,3 +1780,28 @@ export function setPromptId(id: string | null): void {
   STATE.promptId = id
 }
 
+// ============================================================================
+// /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
+}
+

package/src/hooks/useGoalEvaluator.ts

@@ -0,0 +1,98 @@
+import { useEffect, useRef } from 'react'
+import type { MutableRefObject } from 'react'
+import type { MessageType } from '../components/messages.js'
+import {
+  getGoalCondition,
+  getGoalIterationCount,
+  getGoalMaxIterations,
+  incrementGoalIterationCount,
+  setGoalCondition,
+} from '../bootstrap/state.js'
+import { enqueue } from '../utils/messageQueueManager.js'
+import { evaluateGoal } from '../utils/goalEvaluator.js'
+
+type UseGoalEvaluatorParams = {
+  lastQueryCompletionTime: number
+  messagesRef: MutableRefObject<MessageType[]>
+  isQueryActive: boolean
+}
+
+/**
+ * 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.
+ *
+ * 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.
+ */
+export function useGoalEvaluator({
+  lastQueryCompletionTime,
+  messagesRef,
+  isQueryActive,
+}: UseGoalEvaluatorParams): void {
+  const lastEvaluatedAt = useRef(0)
+  const evaluating = useRef(false)
+
+  useEffect(() => {
+    const condition = getGoalCondition()
+    if (!condition) return
+    if (isQueryActive) return
+    if (lastQueryCompletionTime === 0) return
+    if (lastQueryCompletionTime === lastEvaluatedAt.current) return
+    if (evaluating.current) return
+
+    lastEvaluatedAt.current = lastQueryCompletionTime
+    evaluating.current = true
+
+    void (async () => {
+      try {
+        const iterCount = getGoalIterationCount()
+        const maxIter = getGoalMaxIterations()
+
+        if (iterCount >= maxIter) {
+          setGoalCondition(null)
+          enqueue({
+            value: `⚠️ /goal stopped after ${maxIter} iterations. Goal not achieved: "${condition}"`,
+            mode: 'task-notification',
+            priority: 'now',
+          })
+          return
+        }
+
+        // Read snapshot BEFORE await to avoid stale data
+        const messages = messagesRef.current
+        const result = await evaluateGoal(condition, messages)
+
+        // Race protection: user may have called /goal clear during the await
+        if (getGoalCondition() !== condition) return
+
+        incrementGoalIterationCount()
+
+        if (result.satisfied) {
+          setGoalCondition(null)
+          enqueue({
+            value: `✅ Goal achieved (iteration ${iterCount + 1}): ${result.reason}`,
+            mode: 'task-notification',
+            priority: 'now',
+          })
+        } else {
+          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}"`
+          enqueue({
+            value: continueMsg,
+            mode: 'task-notification',
+            priority: 'now',
+          })
+        }
+      } finally {
+        evaluating.current = false
+      }
+    })()
+    // messages intentionally excluded from deps — read via ref to avoid batching issues
+  }, [lastQueryCompletionTime, isQueryActive])
+}

package/src/screens/REPL.tsx

@@ -197,6 +197,7 @@ const PROACTIVE_FALSE = () => false;
 const SUGGEST_BG_PR_NOOP = (_p: string, _n: string): boolean => false;
 const useProactive = feature('PROACTIVE') || feature('KAIROS') ? require('../proactive/useProactive.js').useProactive : null;
 const useScheduledTasks = feature('AGENT_TRIGGERS') ? require('../hooks/useScheduledTasks.js').useScheduledTasks : null;
+const useGoalEvaluator = require('../hooks/useGoalEvaluator.js').useGoalEvaluator
 /* eslint-enable @typescript-eslint/no-require-imports */
 import { isAgentSwarmsEnabled } from '../utils/agentSwarmsEnabled.js';
 import { useTaskListWatcher } from '../hooks/useTaskListWatcher.js';
@@ -3888,6 +3889,11 @@ export function REPL({
     hasActiveLocalJsxUI: isShowingLocalJSXCommand,
     queryGuard
   });
+  useGoalEvaluator({
+    lastQueryCompletionTime,
+    messagesRef,
+    isQueryActive,
+  });
 
   // We'll use the global lastInteractionTime from state.ts
 

package/src/skills/bundled/goal.ts

@@ -0,0 +1,71 @@
+import {
+  getGoalCondition,
+  getGoalMaxIterations,
+  setGoalCondition,
+} from '../../bootstrap/state.js'
+import { registerBundledSkill } from '../bundledSkills.js'
+
+const USAGE = `Usage: /goal <condition>
+
+Set a session goal. The agent will keep working until the condition is met.
+
+Examples:
+  /goal all tests pass
+  /goal login flow handles empty email without crash
+  /goal PR is ready for review with passing CI
+
+To cancel: /goal clear`
+
+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>',
+    userInvocable: true,
+    async getPromptForCommand(args) {
+      const trimmed = args.trim()
+
+      if (!trimmed) {
+        return [{ type: 'text', text: USAGE }]
+      }
+
+      if (['clear', 'stop', 'cancel'].includes(trimmed)) {
+        const current = getGoalCondition()
+        if (current) {
+          setGoalCondition(null)
+          return [
+            {
+              type: 'text',
+              text: `Goal cancelled: "${current}". Tell the user their goal has been cancelled.`,
+            },
+          ]
+        }
+        return [
+          {
+            type: 'text',
+            text: 'No active goal to cancel. Tell the user there is no active goal.',
+          },
+        ]
+      }
+
+      setGoalCondition(trimmed)
+      const maxIter = getGoalMaxIterations()
+
+      return [
+        {
+          type: 'text',
+          text: `# /goal activated
+
+Goal condition: "${trimmed}"
+
+This goal is now registered for this session. An independent evaluator model will check after each turn whether the goal is satisfied. Maximum ${maxIter} iterations.
+
+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.`,
+        },
+      ]
+    },
+  })
+}

package/src/skills/bundled/index.ts

@@ -22,6 +22,7 @@ export function initBundledSkills(): void {
   require('./simplify.js').registerSimplifySkill()
   require('./batch.js').registerBatchSkill()
   require('./stuck.js').registerStuckSkill()
+  require('./goal.js').registerGoalSkill()
   if (feature('KAIROS') || feature('KAIROS_DREAM')) {
     const { registerDreamSkill } = require('./dream.js')
     registerDreamSkill()

package/src/utils/goalEvaluator.ts

@@ -0,0 +1,64 @@
+import Anthropic from '@anthropic-ai/sdk'
+import type { MessageType } from '../components/messages.js'
+
+export const GOAL_EVALUATOR_MODEL = 'claude-haiku-4-5'
+
+export type GoalEvalResult = {
+  satisfied: boolean
+  reason: string
+  gap: string | null
+}
+
+/**
+ * Evaluate whether the goal condition has been met based on recent messages.
+ *
+ * Runs as an independent Anthropic client call — completely decoupled from the
+ * main query chain. Never pollutes conversation state or tool history.
+ */
+export async function evaluateGoal(
+  goalCondition: string,
+  messages: MessageType[],
+): Promise<GoalEvalResult> {
+  const client = new Anthropic()
+
+  const recentAssistantTexts = messages
+    .filter(m => m.type === 'assistant' || m.role === 'assistant')
+    .slice(-5)
+    .map(m => {
+      if (typeof m.message?.content === 'string') return m.message.content
+      if (Array.isArray(m.message?.content)) {
+        return m.message.content
+          .filter((b: { type: string }) => b.type === 'text')
+          .map((b: { text: string }) => b.text)
+          .join('\n')
+      }
+      return ''
+    })
+    .filter(Boolean)
+    .join('\n---\n')
+
+  const prompt = `You are a goal completion evaluator. Determine if the goal has been fully achieved.
+
+Goal: "${goalCondition}"
+
+Recent assistant output:
+${recentAssistantTexts || '(none yet)'}
+
+Respond in JSON only:
+{"satisfied": true|false, "reason": "<one sentence>", "gap": "<missing item or null>"}`
+
+  const response = await client.messages.create({
+    model: GOAL_EVALUATOR_MODEL,
+    max_tokens: 256,
+    messages: [{ role: 'user', content: prompt }],
+  })
+
+  const text =
+    response.content[0]?.type === 'text' ? response.content[0].text : ''
+  try {
+    const cleaned = text.replace(/^```(?:json)?\n?|\n?```$/g, '').trim()
+    return JSON.parse(cleaned) as GoalEvalResult
+  } catch {
+    return { satisfied: false, reason: 'Evaluator parse error', gap: text }
+  }
+}