bingocode 1.1.100 → 1.1.102

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bingocode",
-  "version": "1.1.100",
+  "version": "1.1.102",
   "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/manager/CliMenuManager.tsx

@@ -73,8 +73,8 @@ async function buildSpawnEnv(): Promise<NodeJS.ProcessEnv> {
 }
 
 // Top height: Home fits LogoV2 + Toolbar, other pages more compact
-const TOP_H_HOME = Number(process.env.CLI_TOP_H_HOME || 9);
-const TOP_H_COMPACT = Number(process.env.CLI_TOP_H_COMPACT || 6);
+const TOP_H_HOME = Number(process.env.CLI_TOP_H_HOME || 10);
+const TOP_H_COMPACT = Number(process.env.CLI_TOP_H_COMPACT || 7);
 // Bottom bar height
 const BOTTOM_H = Number(process.env.CLI_BOTTOM_H || 3);
 
@@ -91,13 +91,13 @@ const i18nMap = {
       about: 'Bingo CLI - Version Info & About',
       aboutContent: [
         'Bingo is an AI assistant terminal client.',
-        'Author: leanchy (Email: leanchy07@outlook.com)',
-        'Github: github.com/leanchy/bingo-claude-code-offline-installer',
         '1. API Config: Press "P" or select "API Config" to set up your keys.',
         '2. Model Slots: Configure specific models in the Provider panel.',
         '3. Background Service: Bingo runs a local server to manage sessions.',
         '4. Start Chat: Run `bingocode` or `claude` in any terminal to start.',
       ].join('\n'),
+      author: 'Author: leanchy (Email: leanchy07@outlook.com)',
+      github: 'Github: github.com/leanchy/bingo-claude-code-offline-installer',
       mark: '→ Mark Session',
       unmark: '→ Unmark Session',
       tipsSimple: 'L Lang | ESC Back | ←→ Menu | ↩ Enter | ? Help',
@@ -119,13 +119,13 @@ const i18nMap = {
     about: 'Bingo CLI Terminal - Version Info & About',
     aboutContent: [
       'Bingo is an AI assistant terminal client.',
-      'Author: leanchy (Email: leanchy07@outlook.com)',
-      'Github: github.com/leanchy/bingo-claude-code-offline-installer',
       '1. API Config: Press "P" or select "API Config" to set up your keys.',
       '2. Model Slots: Configure specific models in the Provider panel.',
       '3. Background Service: Bingo runs a local server to manage sessions.',
       '4. Start Chat: Run `bingocode` or `claude` in any terminal to start.',
     ].join('\n'),
+    author: 'Author: leanchy (Email: leanchy07@outlook.com)',
+    github: 'Github: github.com/leanchy/bingo-claude-code-offline-installer',
     mark: '→ Mark Session',
     unmark: '→ Unmark Session',
     tipsSimple: 'L Lang | ESC Back | ←→ Menu | ↩ Enter | ? Help',
@@ -305,7 +305,7 @@ export const CliMenuManager: React.FC = () => {
   const [showHelp, setShowHelp] = useState(false);
 
   // Keyboard navigation for lists
-  const [listOffset, setListOffset] = useState(0);
+  const [historyHighlightIndex, setHistoryHighlightIndex] = useState(0);
 
   // Quick Resume (R)
   const [quickResumeRequested, setQuickResumeRequested] = useState(false);
@@ -571,6 +571,7 @@ export const CliMenuManager: React.FC = () => {
       setHistoryCursor(null);
       setSessionMessages([]);
       setMsgsPage(0);
+      setHistoryHighlightIndex(0);
       setSettingsOffset(0);
       return;
     }
@@ -611,30 +612,22 @@ export const CliMenuManager: React.FC = () => {
     // History shortcuts
     if (!showHelp && page === 'history') {
       if (historyMenuStage === 'list') {
-        const HIST_VISIBLE = MID_H - 2;
-        if (key.downArrow || input === 'j' || input === '\u001b[B') {
-          // Internal SelectInput handles cursor, we just need to track offset for ScrollBar
-          setListOffset(o => Math.min(o + 1, Math.max(0, groupedHistoryItems.length - HIST_VISIBLE)));
-        }
-        if (key.upArrow || input === 'k' || input === '\u001b[A') {
-          setListOffset(o => Math.max(0, o - 1));
-        }
         if (input === 'q') {
           setPage(null);
           setHistoryMenuStage('list');
           setSelectedHistory(null);
           setHistoryCursor(null);
-          setListOffset(0);
+          setHistoryHighlightIndex(0);
           return;
         }
         if (input === 'j' && historyHasMore) {
           setHistoryCursor(historyList[historyList.length - 1]?.id || null);
-          setListOffset(0);
+          setHistoryHighlightIndex(0);
           return;
         }
         if (input === 'k') {
           setHistoryCursor(null);
-          setListOffset(0);
+          setHistoryHighlightIndex(0);
           return;
         }
       } else if (historyMenuStage === 'window') {
@@ -934,12 +927,23 @@ export const CliMenuManager: React.FC = () => {
     // Home: WelcomeV2 (58 cols wide)
     if (page === null) {
       const WELCOME_W = 58;
-      const leftPad = Math.max(0, Math.floor((VIEW_W - WELCOME_W) / 2));
       return (
         <Box flexDirection="column" width={VIEW_W} height={MID_H}>
           <Box flexDirection="row" width={VIEW_W} flexGrow={1}>
-            <Box width={leftPad} flexShrink={0} />
-            <WelcomeV2 />
+            <Box paddingX={2}>
+              <WelcomeV2 />
+            </Box>
+            <Box flexGrow={1} flexDirection="column" alignItems="flex-end" paddingRight={4} paddingTop={1}>
+              <Box borderStyle="classic" borderColor="gray" paddingX={1} flexDirection="column">
+                <Text color="cyan" bold>Version Info</Text>
+                <Text> </Text>
+                <Text dimColor>v1.1.101</Text>
+                <Text dimColor>Stable Release</Text>
+                <Text> </Text>
+                <Text color="gray">Arch: {process.arch}</Text>
+                <Text color="gray">Node: {process.version}</Text>
+              </Box>
+            </Box>
           </Box>
           {!apiUrl && !bootErr && (
             <StateDisplay type="loading" message="Starting server..." />
@@ -1145,16 +1149,21 @@ export const CliMenuManager: React.FC = () => {
 
     // About
     if (page === 'about') {
+      const i18n = i18nMap[lang] as any;
       return (
-        <Box width={VIEW_W} height={MID_H} flexDirection="column">
-          <Text color="cyan" bold>{i18nMap[lang].about}</Text>
-          <Box marginTop={1} flexDirection="column">
-            <Text>{(i18nMap[lang] as any).aboutContent}</Text>
+        <Box width={VIEW_W} height={MID_H} flexDirection="column" paddingX={1}>
+          <Box flexGrow={1} flexDirection="column">
+            <Text color="cyan" bold>{i18n.about}</Text>
+            <Box marginTop={1} flexDirection="column">
+              <Text>{i18n.aboutContent}</Text>
+            </Box>
+            <Box marginTop={1}>
+              <Hint>API Base: {apiUrl}</Hint>
+            </Box>
           </Box>
-          <Box marginTop={1}>
-            <Hint>
-              API Base: {apiUrl}
-            </Hint>
+          <Box borderStyle="classic" borderColor="gray" paddingX={1} flexDirection="column" marginTop={1}>
+            <Text dimColor size="small">{i18n.author}</Text>
+            <Text dimColor size="small">{i18n.github}</Text>
           </Box>
         </Box>
       );

package/src/manager/CliMenuUi.tsx

@@ -266,16 +266,36 @@ export const TopBar: React.FC<{
   compactLogo: React.ReactNode;
   toolbar?: React.ReactNode;
   ip?: string;
-}> = memo(({ ready, page, width = 80, height = 5, homeLogo, compactLogo, toolbar, ip }) => (
-  <Panel width={width} height={height} borderStyle="round" paddingX={1} paddingY={0}>
-    <Box width={width - 2} flexDirection="row" justifyContent="space-between" alignItems="center">
-      <Box>
-        {ready ? (page === null ? homeLogo : compactLogo) : <FallbackTop ip={ip} />}
+}> = memo(({ ready, page, width = 80, height = 5, homeLogo, compactLogo, toolbar, ip }) => {
+  const isHome = page === null;
+  return (
+    <Panel width={width} height={height} borderStyle="round" paddingX={1} paddingY={0}>
+      <Box width={width - 4} flexDirection="row" alignItems="flex-start">
+        {/* Left Section: Welcome Text & IP */}
+        <Box flexDirection="column" width={20} marginRight={2}>
+          {isHome ? (
+            <Box flexDirection="column">
+              <Text bold color="cyan">Welcome Bingo</Text>
+              <Text bold color="cyan">Code</Text>
+            </Box>
+          ) : (
+            <Text bold color="cyan">Bingo Code</Text>
+          )}
+          {ip ? (
+            <Box marginTop={1}>
+              <Text color="gray" dimColor>IP: {ip.replace(':','\n   ')}</Text>
+            </Box>
+          ) : null}
+        </Box>
+
+        {/* Center/Right Section: Logo + Toolbar (Dynamic) */}
+        <Box flexGrow={1} flexDirection="column">
+           {toolbar}
+        </Box>
       </Box>
-      {toolbar ? <Box>{toolbar}</Box> : <Box><Hint dim>{ready ? '' : '…'}</Hint></Box>}
-    </Box>
-  </Panel>
-));
+    </Panel>
+  );
+});
 
 // InfoPair (Label fixed width for column alignment)
 export const InfoPair: React.FC<{ label: string; value: string; labelColor?: string; valueColor?: string; labelWidth?: number }> = memo(({

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 }
+  }
+}