@bubblebrain-ai/bubble 0.0.41 → 0.0.42

package/dist/agent.d.ts

@@ -227,6 +227,7 @@ export declare class Agent {
     private getActiveToolEntries;
     injectSystemReminder(content: string): void;
     injectModeReminder(): void;
+    get role(): "parent" | "subagent";
     get model(): string;
     set model(value: string);
     get providerId(): string;

package/dist/agent.js

@@ -428,6 +428,9 @@ export class Agent {
         }
         this.injectSystemReminder(reminder);
     }
+    get role() {
+        return this.agentRole;
+    }
     get model() {
         return this._model;
     }

package/dist/orchestrator/default-hooks.js

@@ -4,7 +4,7 @@ import { EvidenceTracker } from "../agent/evidence-tracker.js";
 import { ExecutionGovernor } from "../agent/execution-governor.js";
 import { DiscoveryBarrier } from "../agent/discovery-barrier.js";
 import { arbitrateToolCall } from "../agent/tool-arbiter.js";
-import { buildEditRetryEscalationReminder, buildSmallTaskHint, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
+import { buildCompletionSelfCheckReminder, buildEditRetryEscalationReminder, buildSmallTaskHint, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
 import { largeImplementationTaskReminder, orchestrationRequestReminder, reminderForTaskType, userNamedModelReminder } from "../prompt/task-reminders.js";
 import { formatCoverageSummary, resolveWorkflowPhase } from "./workflow.js";
 import { resolve as resolvePath } from "node:path";
@@ -220,9 +220,33 @@ export function createDefaultHooks() {
                 }
                 // Verification reminders intentionally removed. See afterToolCall.
             },
-            afterTurn() {
+            afterTurn(ctx) {
                 // Verification force-continuation removed. The model decides whether
                 // verification is meaningful for the task, per the system prompt.
+                //
+                // Completion self-check gate: when a run that changed code is about
+                // to end (this hook only runs on final, no-tool-call turns), remind
+                // the model ONCE to re-read the original request before finishing.
+                // Unlike the removed verification gate it never repeats — the model
+                // is explicitly told a confirming final answer ends the run — so the
+                // "prove it" spiral that killed the old design cannot start.
+                if (ctx.state.completionGateFired)
+                    return;
+                if (!ctx.state.codeChanged)
+                    return;
+                // Tools are frozen: the model could not act on anything the check
+                // surfaces, so another turn is pure token burn.
+                if (ctx.state.forceTextOnlyReason)
+                    return;
+                // Subagents hand off to a parent that does its own closing pass, and
+                // worktree profiles explicitly forbid the very actions a completion
+                // check would suggest.
+                if (ctx.agent.role === "subagent")
+                    return;
+                ctx.state.completionGateFired = true;
+                ctx.state.forceContinuationReason = "completion_self_check";
+                ctx.queueReminder(buildCompletionSelfCheckReminder());
+                traceEvent("completion_gate_fired", { turnCount: ctx.state.turnCount });
             },
         },
     ];

package/dist/orchestrator/hooks.d.ts

@@ -16,6 +16,8 @@ export interface TurnHookState {
     forceTextOnlyReason?: string;
     forceContinuationReason?: string;
     codeChanged?: boolean;
+    /** Completion self-check gate already fired this run (fires at most once). */
+    completionGateFired?: boolean;
     smallTaskHintSent?: boolean;
     recentEditFailures?: string[];
     editNoMatchReminderPaths?: string[];

package/dist/prompt/reminders.d.ts

@@ -23,6 +23,7 @@ export declare function buildInvestigationReminder(): string;
 export declare function buildLoopWarningReminder(reason: string): string;
 export declare function buildSearchFreezeReminder(reason: string): string;
 export declare function buildExplorationFreezeReminder(reason: string): string;
+export declare function buildCompletionSelfCheckReminder(): string;
 export declare function buildToolFreezeReminder(reason: string): string;
 export declare function buildWorkflowPhaseReminder(input: {
     phase: "investigate" | "correlate" | "conclude";

package/dist/prompt/reminders.js

@@ -119,6 +119,13 @@ Choose one of:
 3. If files were already changed, run the narrowest meaningful verification or finish with the result.
 `);
 }
+export function buildCompletionSelfCheckReminder() {
+    return wrapInSystemReminder(`
+You appear to be finishing. Before giving your final answer, re-read the user's original request in this conversation and check whether any explicit requirement in it remains unfulfilled — including requirements about how the work should be delivered or reported, not only whether the implementation works.
+
+If something is missing, complete it now. If everything is done, give your final answer directly — do not repeat this check or re-verify work you have already verified.
+`);
+}
 export function buildToolFreezeReminder(reason) {
     return wrapInSystemReminder(`
 CRITICAL - MAXIMUM STEPS REACHED

package/dist/prompt/runtime.js

@@ -11,6 +11,7 @@ const defaultGuidelines = [
     "Prefer structured tools (glob, grep, read) over bash for search and inspection. Do not repeat a near-identical search or re-read the same file unless new evidence changes the question.",
     "If a tool fails, diagnose the error before switching tactics. Do not retry the identical call with identical arguments. After two equivalent failures, switch approach — re-read the file, use a different tool, rewrite the whole file with write, or ask the user.",
     "Before reporting a task complete, verify it works when verification is meaningful and cheap — run the existing test, execute the script, check the output. If no test exists, the change is purely declarative (static HTML/markdown/config), or running the code is not practical, state that explicitly rather than inventing a verification step. Do not write throwaway validation scripts to prove correctness; if there is no real check to run, report the change and stop.",
+    "Before declaring a task complete, re-read the user's original request and verify that every explicit requirement in it — about both the result and the process — has been fulfilled, not only that the implementation works.",
 ];
 export function buildRuntimePrompt(options = {}) {
     const guidelines = dedupe(defaultGuidelines, options.guidelines ?? []);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bubblebrain-ai/bubble",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "description": "A terminal coding agent",
   "type": "module",
   "engines": {