fix(task): change budget scope from per-message to per-session

The task_budget was incorrectly keyed by (sessionID, messageID), causing
the budget counter to reset every turn since each assistant response
generates a new messageID. Changed to per-session tracking so all task
calls within a delegated session count toward the same budget.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: NamedIdentity

CLAUDE.md

@@ -0,0 +1,113 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+OpenCode is an open-source AI-powered coding agent, similar to Claude Code but provider-agnostic. It supports multiple LLM providers (Anthropic, OpenAI, Google, Azure, local models) and features a TUI built with SolidJS, LSP support, and client/server architecture.
+
+## Development Commands
+
+```bash
+# Install and run development server
+bun install
+bun dev                     # Run in packages/opencode directory
+bun dev <directory>         # Run against a specific directory
+bun dev .                   # Run against repo root
+
+# Type checking
+bun run typecheck           # Single package
+bun turbo typecheck         # All packages
+
+# Testing (per-package, not from root)
+cd packages/opencode && bun test
+
+# Build standalone executable
+./packages/opencode/script/build.ts --single
+# Output: ./packages/opencode/dist/opencode-<platform>/bin/opencode
+
+# Regenerate SDK after API changes
+./script/generate.ts
+# Or for JS SDK specifically:
+./packages/sdk/js/script/build.ts
+
+# Web app development
+bun run --cwd packages/app dev              # http://localhost:5173
+
+# Desktop app (requires Tauri/Rust)
+bun run --cwd packages/desktop tauri dev    # Native + web server
+bun run --cwd packages/desktop dev          # Web only (port 1420)
+bun run --cwd packages/desktop tauri build  # Production build
+```
+
+## Architecture
+
+**Monorepo Structure** (Bun workspaces + Turbo):
+
+| Package | Purpose |
+|---------|---------|
+| `packages/opencode` | Core CLI, server, business logic |
+| `packages/app` | Shared web UI components (SolidJS + Vite) |
+| `packages/desktop` | Native desktop app (Tauri wrapper) |
+| `packages/ui` | Shared component library (Kobalte + Tailwind) |
+| `packages/console/app` | Console dashboard (Solid Start) |
+| `packages/console/core` | Backend services (Hono + DrizzleORM) |
+| `packages/sdk/js` | JavaScript SDK |
+| `packages/plugin` | Plugin system API |
+
+**Key Directories in `packages/opencode/src`**:
+- `cli/cmd/tui/` - Terminal UI (SolidJS + opentui)
+- `agent/` - Agent logic and state
+- `provider/` - AI provider implementations
+- `server/` - Server mode
+- `mcp/` - Model Context Protocol integration
+- `lsp/` - Language Server Protocol support
+
+**Default branch**: `dev`
+
+## Code Style
+
+- Keep logic in single functions unless reusable
+- Avoid destructuring: use `obj.a` instead of `const { a } = obj`
+- Avoid `try/catch` - prefer `.catch()`
+- Avoid `else` statements
+- Avoid `any` type
+- Avoid `let` - use immutable patterns
+- Prefer single-word variable names when descriptive
+- Use Bun APIs (e.g., `Bun.file()`) when applicable
+
+## Built-in Agents
+
+- **build** - Default agent with full access for development
+- **plan** - Read-only agent for analysis (denies edits, asks before bash)
+- **general** - Subagent for complex tasks, invoked with `@general`
+
+Switch agents with `Tab` key in TUI.
+
+## Debugging
+
+```bash
+# Debug with inspector
+bun run --inspect=ws://localhost:6499/ dev
+
+# Debug server separately
+bun run --inspect=ws://localhost:6499/ ./src/index.ts serve --port 4096
+opencode attach http://localhost:4096
+
+# Debug TUI
+bun run --inspect=ws://localhost:6499/ --conditions=browser ./src/index.ts
+
+# Use spawn for breakpoints in server code
+bun dev spawn
+```
+
+Use `--inspect-wait` or `--inspect-brk` for different breakpoint behaviors.
+
+## PR Guidelines
+
+- All PRs must reference an existing issue (`Fixes #123`)
+- UI/core feature changes require design review with core team
+- PR titles follow conventional commits: `feat:`, `fix:`, `docs:`, `chore:`, `refactor:`, `test:`
+- Optional scope: `feat(app):`, `fix(desktop):`
+- Include screenshots/videos for UI changes
+- Explain verification steps for logic changes

packages/opencode/src/tool/task.ts

@@ -13,26 +13,20 @@ import { Config } from "../config/config"
 import { PermissionNext } from "@/permission/next"
 import { Instance } from "../project/instance"
 
-// Track task calls per request: Map<sessionID, Map<messageID, count>>
-// Budget is per-request (one "work assignment" within a session), resets on new messageID
-// Note: State grows with sessions/messages but entries are small. Future optimization:
+// Track task calls per session: Map<sessionID, count>
+// Budget is per-session (all calls within the delegated work count toward the limit)
+// Note: State grows with sessions but entries are small. Future optimization:
 // clean up completed sessions via Session lifecycle hooks if memory becomes a concern.
-const taskCallState = Instance.state(() => new Map<string, Map<string, number>>())
+const taskCallState = Instance.state(() => new Map<string, number>())
 
-function getCallCount(sessionID: string, messageID: string): number {
-  const sessionCounts = taskCallState().get(sessionID)
-  return sessionCounts?.get(messageID) ?? 0
+function getCallCount(sessionID: string): number {
+  return taskCallState().get(sessionID) ?? 0
 }
 
-function incrementCallCount(sessionID: string, messageID: string): number {
+function incrementCallCount(sessionID: string): number {
   const state = taskCallState()
-  let sessionCounts = state.get(sessionID)
-  if (!sessionCounts) {
-    sessionCounts = new Map()
-    state.set(sessionID, sessionCounts)
-  }
-  const newCount = (sessionCounts.get(messageID) ?? 0) + 1
-  sessionCounts.set(messageID, newCount)
+  const newCount = (state.get(sessionID) ?? 0) + 1
+  state.set(sessionID, newCount)
   return newCount
 }
 
@@ -127,8 +121,8 @@ export const TaskTool = Tool.define("task", async (ctx) => {
           )
         }
 
-        // Check 3: Budget not exhausted for this request (messageID)
-        const currentCount = getCallCount(ctx.sessionID, ctx.messageID)
+        // Check 3: Budget not exhausted for this session
+        const currentCount = getCallCount(ctx.sessionID)
         if (currentCount >= callerTaskBudget) {
           throw new Error(
             `Task budget exhausted (${currentCount}/${callerTaskBudget} calls). ` +
@@ -137,7 +131,7 @@ export const TaskTool = Tool.define("task", async (ctx) => {
         }
 
         // Increment count after passing all checks (including ownership above)
-        incrementCallCount(ctx.sessionID, ctx.messageID)
+        incrementCallCount(ctx.sessionID)
       }
 
       const session = await iife(async () => {