@bubblebrain-ai/bubble 0.0.2 → 0.0.4

package/README.md

@@ -4,8 +4,8 @@ Bubble is a terminal coding agent for working inside local project folders. It c
 
 ## Requirements
 
-- Bun
-- Node.js and npm
+- Node.js 20+ and npm for installation
+- Bun for running Bubble
 
 Install Bun if it is not already available:
 
@@ -24,9 +24,14 @@ npm install -g @bubblebrain-ai/bubble
 From a local package tarball:
 
 ```bash
-npm install -g ./bubblebrain-ai-bubble-0.0.1.tgz
+npm install -g ./bubblebrain-ai-bubble-0.0.3.tgz
 ```
 
+The npm command installs a small Node.js launcher named `bubble`. When you run
+`bubble`, the launcher checks for Bun and starts the real Bubble runtime with
+`bun`. If Bun is missing, it prints the install command above instead of failing
+with a low-level runtime error.
+
 ## Usage
 
 Start Bubble in the current directory:

package/dist/agent/execution-governor.d.ts

@@ -3,28 +3,42 @@ import type { TaskType } from "./task-classifier.js";
 export interface GovernorDecision {
     blockedResult?: ToolResult;
 }
+type WorkPhase = "explore" | "modify" | "verify";
 export declare class ExecutionGovernor {
     private taskType;
     private budget;
     private history;
     private totalSteps;
     private searchSteps;
+    private readSteps;
+    private explorationStepsWithoutWrite;
     private searchFrozen;
+    private explorationFrozen;
+    private phase;
+    private codeChanged;
     private reminderQueue;
     private warnedFamilies;
     private softTotalWarned;
     private softSearchWarned;
+    private softReadWarned;
     constructor(taskType: TaskType);
     consumePendingReminders(): string[];
     snapshot(): {
         totalSteps: number;
         searchSteps: number;
+        readSteps: number;
         searchFrozen: boolean;
+        explorationFrozen: boolean;
+        phase: WorkPhase;
     };
     filterToolDefinitions(toolDefinitions: ToolRegistryEntry[]): ToolRegistryEntry[];
     beforeToolCall(toolCall: ParsedToolCall): GovernorDecision;
     afterToolResult(toolCall: ParsedToolCall, result: ToolResult): void;
     private trailingNoProgressCount;
     private freezeSearch;
+    private enterModifyPhase;
+    private isModificationTask;
+    private historyCount;
     private maybeWarnOnSoftBudgets;
 }
+export {};

package/dist/agent/execution-governor.js

@@ -1,9 +1,12 @@
 import { analyzeToolIntent } from "./tool-intent.js";
-import { buildInvestigationReminder, buildLoopWarningReminder, buildSearchFreezeReminder } from "../prompt/reminders.js";
+import { buildExplorationFreezeReminder, buildInvestigationReminder, buildLoopWarningReminder, buildSearchFreezeReminder } from "../prompt/reminders.js";
 const BUDGETS = {
     security_investigation: {
         softTotalSteps: 14,
         softSearchSteps: 6,
+        softReadSteps: 8,
+        maxExplorationStepsWithoutWrite: 12,
+        maxNoProgressReadExactRepeats: 2,
         maxNoProgressExactRepeats: 2,
         maxNoProgressFamilyRepeats: 3,
         warningFamilyRepeats: 2,
@@ -11,30 +14,103 @@ const BUDGETS = {
     code_search: {
         softTotalSteps: 16,
         softSearchSteps: 8,
+        softReadSteps: 10,
+        maxExplorationStepsWithoutWrite: 14,
+        maxNoProgressReadExactRepeats: 2,
         maxNoProgressExactRepeats: 3,
         maxNoProgressFamilyRepeats: 4,
         warningFamilyRepeats: 3,
     },
+    debugging: {
+        softTotalSteps: 18,
+        softSearchSteps: 8,
+        softReadSteps: 7,
+        maxExplorationStepsWithoutWrite: 10,
+        maxNoProgressReadExactRepeats: 1,
+        maxNoProgressExactRepeats: 3,
+        maxNoProgressFamilyRepeats: 4,
+        warningFamilyRepeats: 3,
+    },
+    implementation: {
+        softTotalSteps: 18,
+        softSearchSteps: 8,
+        softReadSteps: 6,
+        maxExplorationStepsWithoutWrite: 8,
+        maxNoProgressReadExactRepeats: 1,
+        maxNoProgressExactRepeats: 3,
+        maxNoProgressFamilyRepeats: 4,
+        warningFamilyRepeats: 3,
+    },
+    code_review: {
+        softTotalSteps: 14,
+        softSearchSteps: 6,
+        softReadSteps: 8,
+        maxExplorationStepsWithoutWrite: 12,
+        maxNoProgressReadExactRepeats: 2,
+        maxNoProgressExactRepeats: 3,
+        maxNoProgressFamilyRepeats: 4,
+        warningFamilyRepeats: 3,
+    },
+    code_explanation: {
+        softTotalSteps: 12,
+        softSearchSteps: 6,
+        softReadSteps: 8,
+        maxExplorationStepsWithoutWrite: 12,
+        maxNoProgressReadExactRepeats: 2,
+        maxNoProgressExactRepeats: 3,
+        maxNoProgressFamilyRepeats: 4,
+        warningFamilyRepeats: 3,
+    },
+    repo_orientation: {
+        softTotalSteps: 12,
+        softSearchSteps: 6,
+        softReadSteps: 8,
+        maxExplorationStepsWithoutWrite: 12,
+        maxNoProgressReadExactRepeats: 2,
+        maxNoProgressExactRepeats: 3,
+        maxNoProgressFamilyRepeats: 4,
+        warningFamilyRepeats: 3,
+    },
+    product_discussion: {
+        softTotalSteps: 10,
+        softSearchSteps: 4,
+        softReadSteps: 4,
+        maxExplorationStepsWithoutWrite: 8,
+        maxNoProgressReadExactRepeats: 2,
+        maxNoProgressExactRepeats: 2,
+        maxNoProgressFamilyRepeats: 3,
+        warningFamilyRepeats: 2,
+    },
     general: {
         softTotalSteps: 18,
         softSearchSteps: 8,
+        softReadSteps: 10,
+        maxExplorationStepsWithoutWrite: 14,
+        maxNoProgressReadExactRepeats: 2,
         maxNoProgressExactRepeats: 3,
         maxNoProgressFamilyRepeats: 4,
         warningFamilyRepeats: 3,
     },
 };
 const SEARCH_TOOLS_DISABLED = new Set(["grep", "web_search", "web_fetch"]);
+const EXPLORATION_TOOLS_DISABLED = new Set(["read", "glob", "grep", "web_search", "web_fetch", "task", "tool_search"]);
 export class ExecutionGovernor {
     taskType;
     budget;
     history = [];
     totalSteps = 0;
     searchSteps = 0;
+    readSteps = 0;
+    explorationStepsWithoutWrite = 0;
     searchFrozen = false;
+    explorationFrozen = false;
+    phase = "explore";
+    codeChanged = false;
     reminderQueue = [];
     warnedFamilies = new Set();
     softTotalWarned = false;
     softSearchWarned = false;
+    softReadWarned = false;
     constructor(taskType) {
         this.taskType = taskType;
         this.budget = BUDGETS[taskType];
@@ -51,21 +127,42 @@ export class ExecutionGovernor {
         return {
             totalSteps: this.totalSteps,
             searchSteps: this.searchSteps,
+            readSteps: this.readSteps,
             searchFrozen: this.searchFrozen,
+            explorationFrozen: this.explorationFrozen,
+            phase: this.phase,
         };
     }
     filterToolDefinitions(toolDefinitions) {
-        if (!this.searchFrozen) {
-            return toolDefinitions;
+        let filtered = toolDefinitions;
+        if (this.explorationFrozen) {
+            filtered = filtered.filter((tool) => !EXPLORATION_TOOLS_DISABLED.has(tool.name));
         }
-        return toolDefinitions.filter((tool) => !SEARCH_TOOLS_DISABLED.has(tool.name));
+        else if (this.searchFrozen) {
+            filtered = filtered.filter((tool) => !SEARCH_TOOLS_DISABLED.has(tool.name));
+        }
+        return filtered;
     }
     beforeToolCall(toolCall) {
         const intent = analyzeToolIntent(toolCall);
+        if (this.explorationFrozen && isExplorationIntent(intent)) {
+            return {
+                blockedResult: blockedResult("Exploration blocked: this implementation task already has enough context. Use edit/write, verify an existing change, or explain the blocker.", "blocked", "Exploration frozen because tool calls stopped producing task progress.", metadataKindForFamily(intent.family)),
+            };
+        }
+        if (this.isModificationTask() && !this.codeChanged && intent.family === "read") {
+            const signature = intent.read?.signature;
+            if (signature && this.historyCount((entry) => entry.signature === signature) >= this.budget.maxNoProgressReadExactRepeats) {
+                this.enterModifyPhase(`Repeated the same file range without making progress: ${signature}`);
+                return {
+                    blockedResult: blockedResult("Read blocked: this file range was already read. You have enough context to make the requested change; use edit/write now or explain the blocker.", "blocked", "Repeated identical read before modification.", "read"),
+                };
+            }
+        }
         if (intent.family === "search") {
             if (this.searchFrozen) {
                 return {
-                    blockedResult: blockedResult("Search blocked: repeated low-yield searching is now frozen for this task.", "blocked", "Search frozen due to repeated low-yield searching."),
+                    blockedResult: blockedResult("Search blocked: repeated low-yield searching is now frozen for this task.", "blocked", "Search frozen due to repeated low-yield searching.", "search"),
                 };
             }
             const signature = intent.search?.signature;
@@ -73,7 +170,7 @@ export class ExecutionGovernor {
             if (signature && this.trailingNoProgressCount((entry) => entry.signature === signature) >= this.budget.maxNoProgressExactRepeats) {
                 this.freezeSearch(`Repeated the same search signature without new evidence: ${signature}`);
                 return {
-                    blockedResult: blockedResult("Search blocked: repeated the same search multiple times without new evidence.", "blocked", "Repeated identical search without progress."),
+                    blockedResult: blockedResult("Search blocked: repeated the same search multiple times without new evidence.", "blocked", "Repeated identical search without progress.", "search"),
                 };
             }
             if (familyKey) {
@@ -81,7 +178,7 @@ export class ExecutionGovernor {
                 if (familyNoProgress >= this.budget.maxNoProgressFamilyRepeats) {
                     this.freezeSearch(`Repeated the same search family without new evidence: ${familyKey}`);
                     return {
-                        blockedResult: blockedResult("Search blocked: repeated the same search family without new evidence.", "blocked", "Repeated similar searches without progress."),
+                        blockedResult: blockedResult("Search blocked: repeated the same search family without new evidence.", "blocked", "Repeated similar searches without progress.", "search"),
                     };
                 }
                 if (familyNoProgress >= this.budget.warningFamilyRepeats && !this.warnedFamilies.has(familyKey)) {
@@ -94,18 +191,38 @@ export class ExecutionGovernor {
         if (intent.family === "search") {
             this.searchSteps += 1;
         }
-        this.maybeWarnOnSoftBudgets(intent.family === "search");
+        if (intent.family === "read") {
+            this.readSteps += 1;
+        }
+        if (isExplorationIntent(intent) && !this.codeChanged) {
+            this.explorationStepsWithoutWrite += 1;
+        }
+        this.maybeWarnOnSoftBudgets(intent.family === "search", intent.family === "read");
         return {};
     }
     afterToolResult(toolCall, result) {
         const intent = analyzeToolIntent(toolCall);
-        const progress = inferProgress(intent, result);
+        const repeatedRead = intent.family === "read"
+            && !!intent.read?.signature
+            && this.history.some((entry) => entry.signature === intent.read?.signature);
+        const progress = inferProgress(intent, result) && !repeatedRead;
         this.history.push({
             family: intent.family,
-            signature: intent.search?.signature,
-            familyKey: intent.search?.familyKey,
+            signature: intent.search?.signature ?? intent.read?.signature,
+            familyKey: intent.search?.familyKey ?? intent.read?.familyKey,
             progress,
         });
+        if (isSuccessfulWriteIntent(intent, result)) {
+            this.codeChanged = true;
+            this.phase = "verify";
+            return;
+        }
+        if (this.isModificationTask()
+            && !this.codeChanged
+            && isExplorationIntent(intent)
+            && this.explorationStepsWithoutWrite >= this.budget.maxExplorationStepsWithoutWrite) {
+            this.enterModifyPhase(`Used ${this.explorationStepsWithoutWrite} exploration tools without editing files.`);
+        }
     }
     trailingNoProgressCount(predicate) {
         let count = 0;
@@ -128,7 +245,22 @@ export class ExecutionGovernor {
         this.searchFrozen = true;
         this.reminderQueue.push(buildSearchFreezeReminder(reason));
     }
-    maybeWarnOnSoftBudgets(isSearchStep) {
+    enterModifyPhase(reason) {
+        if (this.explorationFrozen) {
+            return;
+        }
+        this.phase = "modify";
+        this.explorationFrozen = true;
+        this.searchFrozen = true;
+        this.reminderQueue.push(buildExplorationFreezeReminder(reason));
+    }
+    isModificationTask() {
+        return this.taskType === "implementation" || this.taskType === "debugging";
+    }
+    historyCount(predicate) {
+        return this.history.reduce((count, entry) => count + (predicate(entry) ? 1 : 0), 0);
+    }
+    maybeWarnOnSoftBudgets(isSearchStep, isReadStep) {
         if (!this.softTotalWarned && this.totalSteps >= this.budget.softTotalSteps) {
             this.softTotalWarned = true;
             this.reminderQueue.push(buildLoopWarningReminder("This task has already used many tool steps. Do not keep exploring by default; synthesize what you know unless a concrete missing gap remains."));
@@ -137,6 +269,32 @@ export class ExecutionGovernor {
             this.softSearchWarned = true;
             this.reminderQueue.push(buildLoopWarningReminder("This task has already used many search steps. Stop broad searching unless you can point to a specific remaining evidence gap."));
         }
+        if (isReadStep && !this.softReadWarned && this.readSteps >= this.budget.softReadSteps) {
+            this.softReadWarned = true;
+            this.reminderQueue.push(buildLoopWarningReminder("This task has already used many file reads. Stop re-reading context unless a concrete edit requires one exact missing snippet."));
+        }
+    }
+}
+function isExplorationIntent(intent) {
+    return intent.family === "search" || intent.family === "read" || intent.family === "web";
+}
+function isSuccessfulWriteIntent(intent, result) {
+    if (result.isError || result.status === "blocked" || result.status === "command_error") {
+        return false;
+    }
+    return intent.family === "write" || intent.family === "edit" || result.metadata?.kind === "write" || result.metadata?.kind === "edit";
+}
+function metadataKindForFamily(family) {
+    switch (family) {
+        case "search":
+        case "read":
+        case "write":
+        case "edit":
+        case "shell":
+        case "web":
+            return family;
+        default:
+            return "security";
     }
 }
 function inferProgress(intent, result) {
@@ -156,13 +314,13 @@ function inferProgress(intent, result) {
     }
     return !result.isError;
 }
-function blockedResult(content, status, reason) {
+function blockedResult(content, status, reason, kind = "security") {
     return {
         content,
         isError: true,
         status,
         metadata: {
-            kind: "security",
+            kind,
             reason,
         },
     };

package/dist/agent/task-classifier.d.ts

@@ -1,3 +1,3 @@
 import type { ContentPart } from "../types.js";
-export type TaskType = "security_investigation" | "code_search" | "general";
+export type TaskType = "security_investigation" | "debugging" | "implementation" | "code_review" | "code_explanation" | "repo_orientation" | "product_discussion" | "code_search" | "general";
 export declare function classifyTask(input: string | ContentPart[]): TaskType;

package/dist/agent/task-classifier.js

@@ -18,6 +18,48 @@ const SEARCH_PATTERNS = [
     /\blocate\b/i,
     /\btrace\b/i,
 ];
+const REVIEW_PATTERNS = [
+    /\breview\b/i,
+    /\bcode review\b/i,
+    /帮我看看.*(代码|改动|diff)/i,
+    /看下.*(风险|问题|bug)/i,
+];
+const DEBUG_PATTERNS = [
+    /\bdebug\b/i,
+    /\bbug\b/i,
+    /\bfail(ing|ed|ure)?\b/i,
+    /\berror\b/i,
+    /\bregression\b/i,
+    /报错|失败|不对|有问题|修复|定位/i,
+];
+const IMPLEMENTATION_PATTERNS = [
+    /\bimplement\b/i,
+    /\bbuild\b/i,
+    /\badd\b/i,
+    /\bchange\b/i,
+    /\bupdate\b/i,
+    /\brefactor\b/i,
+    /实现|开发|改一下|加一个|调整|优化/i,
+];
+const EXPLANATION_PATTERNS = [
+    /\bexplain\b/i,
+    /\bhow does\b/i,
+    /\bwhat does\b/i,
+    /解释|讲讲|怎么看|在干嘛|如何运转/i,
+];
+const ORIENTATION_PATTERNS = [
+    /\bwhat is this project\b/i,
+    /\borient/i,
+    /\boverview\b/i,
+    /这个项目.*(干嘛|做什么)|看下这个项目|项目.*概览/i,
+];
+const PRODUCT_PATTERNS = [
+    /\bproduct\b/i,
+    /\bdesign\b/i,
+    /\bstrategy\b/i,
+    /\broadmap\b/i,
+    /产品|方案|设计|体验|取舍|方向/i,
+];
 export function classifyTask(input) {
     const text = typeof input === "string"
         ? input
@@ -29,6 +71,24 @@ export function classifyTask(input) {
     if (securityHits >= 2) {
         return "security_investigation";
     }
+    if (REVIEW_PATTERNS.some((pattern) => pattern.test(text))) {
+        return "code_review";
+    }
+    if (DEBUG_PATTERNS.some((pattern) => pattern.test(text))) {
+        return "debugging";
+    }
+    if (ORIENTATION_PATTERNS.some((pattern) => pattern.test(text))) {
+        return "repo_orientation";
+    }
+    if (EXPLANATION_PATTERNS.some((pattern) => pattern.test(text))) {
+        return "code_explanation";
+    }
+    if (IMPLEMENTATION_PATTERNS.some((pattern) => pattern.test(text))) {
+        return "implementation";
+    }
+    if (PRODUCT_PATTERNS.some((pattern) => pattern.test(text))) {
+        return "product_discussion";
+    }
     if (SEARCH_PATTERNS.some((pattern) => pattern.test(text))) {
         return "code_search";
     }

package/dist/agent/tool-intent.d.ts

@@ -7,9 +7,17 @@ export interface SearchIntent {
     signature: string;
     familyKey: string;
 }
+export interface ReadIntent {
+    path: string;
+    offset?: number | string;
+    limit?: number | string;
+    signature: string;
+    familyKey: string;
+}
 export interface ToolIntent {
     family: ToolFamily;
     search?: SearchIntent;
+    read?: ReadIntent;
 }
 export declare function analyzeToolIntent(toolCall: Pick<ParsedToolCall, "name" | "parsedArgs">): ToolIntent;
 export interface ParsedSearchCommand {
@@ -17,4 +25,10 @@ export interface ParsedSearchCommand {
     path?: string;
     include?: string;
 }
+export interface ParsedReadCommand {
+    path: string;
+    offset?: number | string;
+    limit?: number | string;
+}
 export declare function parseSearchBashCommand(command: string): ParsedSearchCommand | undefined;
+export declare function parseReadBashCommand(command: string): ParsedReadCommand | undefined;

package/dist/agent/tool-intent.js

@@ -38,10 +38,20 @@ export function analyzeToolIntent(toolCall) {
                     search: buildSearchIntent(parsed.pattern, parsed.path, parsed.include),
                 };
             }
+            const parsedRead = parseReadBashCommand(stringArg(toolCall.parsedArgs.command));
+            if (parsedRead) {
+                return {
+                    family: "read",
+                    read: buildReadIntent(parsedRead.path, parsedRead.offset, parsedRead.limit),
+                };
+            }
             return { family: "shell" };
         }
         case "read":
-            return { family: "read" };
+            return {
+                family: "read",
+                read: buildReadIntent(stringArg(toolCall.parsedArgs.path ?? toolCall.parsedArgs.file), numberOrStringArg(toolCall.parsedArgs.offset), numberOrStringArg(toolCall.parsedArgs.limit)),
+            };
         case "write":
             return { family: "write" };
         case "edit":
@@ -99,6 +109,36 @@ export function parseSearchBashCommand(command) {
         include,
     };
 }
+export function parseReadBashCommand(command) {
+    const trimmed = command.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    if (/[|;&><`]/.test(trimmed)) {
+        return undefined;
+    }
+    const tokens = shellSplit(trimmed);
+    if (tokens.length === 0) {
+        return undefined;
+    }
+    const binary = tokens[0];
+    if (binary === "cat" || binary === "nl") {
+        const path = lastPositional(tokens.slice(1));
+        return path ? { path } : undefined;
+    }
+    if (binary === "head") {
+        const { path, lineCount } = parseHeadTailArgs(tokens.slice(1));
+        return path ? { path, offset: 1, limit: lineCount ?? "head" } : undefined;
+    }
+    if (binary === "tail") {
+        const { path, lineCount } = parseHeadTailArgs(tokens.slice(1));
+        return path ? { path, offset: `tail:${lineCount ?? "default"}`, limit: lineCount ?? "tail" } : undefined;
+    }
+    if (binary === "sed") {
+        return parseSedReadCommand(tokens.slice(1));
+    }
+    return undefined;
+}
 function buildSearchIntent(pattern, path, include) {
     const normalizedPath = normalizePath(path ?? ".");
     const rawNormalizedPattern = normalizeRawPattern(pattern);
@@ -114,6 +154,18 @@ function buildSearchIntent(pattern, path, include) {
         familyKey,
     };
 }
+function buildReadIntent(path, offset, limit) {
+    const normalizedPath = normalizePath(path || ".");
+    const normalizedOffset = offset ?? 1;
+    const normalizedLimit = limit ?? "default";
+    return {
+        path,
+        offset,
+        limit,
+        signature: `${normalizedPath}::${normalizedOffset}::${normalizedLimit}`,
+        familyKey: normalizedPath,
+    };
+}
 function canonicalizeSearchTokens(pattern) {
     const normalized = normalizeRawPattern(pattern);
     const tokens = normalized.split(/[^a-z0-9_]+/).filter(Boolean);
@@ -132,6 +184,78 @@ function normalizePath(pathValue) {
 function stringArg(value) {
     return typeof value === "string" ? value : "";
 }
+function numberOrStringArg(value) {
+    return typeof value === "number" || typeof value === "string" ? value : undefined;
+}
+function lastPositional(tokens) {
+    for (let index = tokens.length - 1; index >= 0; index--) {
+        const token = tokens[index];
+        if (!token.startsWith("-")) {
+            return token;
+        }
+    }
+    return undefined;
+}
+function parseHeadTailArgs(tokens) {
+    let lineCount;
+    const positional = [];
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (token === "-n" || token === "--lines") {
+            lineCount = parseLineCount(tokens[index + 1]);
+            index += 1;
+            continue;
+        }
+        if (token.startsWith("-n") && token.length > 2) {
+            lineCount = parseLineCount(token.slice(2));
+            continue;
+        }
+        if (token.startsWith("--lines=")) {
+            lineCount = parseLineCount(token.slice("--lines=".length));
+            continue;
+        }
+        if (token.startsWith("-")) {
+            continue;
+        }
+        positional.push(token);
+    }
+    return {
+        path: positional[positional.length - 1],
+        lineCount,
+    };
+}
+function parseSedReadCommand(tokens) {
+    const positional = [];
+    for (const token of tokens) {
+        if (token === "-n" || token.startsWith("-")) {
+            continue;
+        }
+        positional.push(token);
+    }
+    if (positional.length < 2) {
+        return undefined;
+    }
+    const expression = positional[0];
+    const path = positional[positional.length - 1];
+    const range = expression.match(/^(\d+)(?:,(\d+))?p$/);
+    if (!range) {
+        return { path, offset: expression };
+    }
+    const start = Number(range[1]);
+    const end = range[2] ? Number(range[2]) : start;
+    return {
+        path,
+        offset: start,
+        limit: Math.max(1, end - start + 1),
+    };
+}
+function parseLineCount(value) {
+    if (!value) {
+        return undefined;
+    }
+    const parsed = Number(value.replace(/^\+/, ""));
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
 function shellSplit(command) {
     const tokens = [];
     let current = "";

package/dist/agent.js

@@ -460,6 +460,10 @@ export class Agent {
             });
             flushGovernorReminders();
             yield { type: "turn_end", usage: turnUsage };
+            if (hookState.forceContinuationReason) {
+                delete hookState.forceContinuationReason;
+                continue;
+            }
             break;
         }
         yield { type: "agent_end" };

package/dist/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};