@bubblebrain-ai/bubble 0.0.43 → 0.0.44

package/dist/agent/change-tracker.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Git-ground-truth change tracking for a single agent run.
+ *
+ * Tool-metadata bookkeeping (kind === "write" | "edit" | "patch") misses every
+ * other mutation channel: bash heredocs/sed -i, scripts, subagent worktree
+ * merges. Git sees them all. A baseline snapshot is taken at run start; the
+ * delta at completion time is the run's actual footprint.
+ *
+ * Everything here degrades to null outside a git repo or on any git error —
+ * callers fall back to metadata-based signals.
+ */
+export interface GitChangeBaseline {
+    /** Paths already dirty (or untracked) before the run started. */
+    dirtyAtStart: Set<string>;
+}
+export interface ModifiedExistingTest {
+    path: string;
+    deletedLines: number;
+}
+export interface RunChangeSummary {
+    /** Paths that became dirty during the run (not dirty at baseline). */
+    changedFiles: string[];
+    /**
+     * Pre-existing (tracked) test files that were modified during the run,
+     * with how many lines the working tree deletes from them vs HEAD. New test
+     * files created by the run are NOT listed — creating tests is not suspect.
+     */
+    modifiedExistingTests: ModifiedExistingTest[];
+}
+export declare function isTestFilePath(path: string): boolean;
+export declare function captureGitBaseline(cwd: string): Promise<GitChangeBaseline | null>;
+/**
+ * Diff the current working tree against the run-start baseline.
+ *
+ * Known honest limits: a file already dirty at baseline that the run edited
+ * further is not attributed to the run (indistinguishable without content
+ * snapshots), and deleted-line counts for such files would mix user and agent
+ * edits — so they are excluded entirely.
+ */
+export declare function detectRunChanges(cwd: string, baseline: GitChangeBaseline | null): Promise<RunChangeSummary | null>;

package/dist/agent/change-tracker.js

@@ -0,0 +1,89 @@
+/**
+ * Git-ground-truth change tracking for a single agent run.
+ *
+ * Tool-metadata bookkeeping (kind === "write" | "edit" | "patch") misses every
+ * other mutation channel: bash heredocs/sed -i, scripts, subagent worktree
+ * merges. Git sees them all. A baseline snapshot is taken at run start; the
+ * delta at completion time is the run's actual footprint.
+ *
+ * Everything here degrades to null outside a git repo or on any git error —
+ * callers fall back to metadata-based signals.
+ */
+import { execFile } from "node:child_process";
+const GIT_TIMEOUT_MS = 3_000;
+const TEST_PATH_PATTERN = /(^|\/)(tests?|__tests__|spec)(\/|$)|(\.|_|-)(test|tests|spec)\.[^/]+$|(^|\/)test_[^/]+$/i;
+export function isTestFilePath(path) {
+    return TEST_PATH_PATTERN.test(path);
+}
+function git(cwd, args) {
+    return new Promise((resolve) => {
+        execFile("git", args, { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: 8 * 1024 * 1024 }, (error, stdout) => {
+            resolve(error ? null : stdout);
+        });
+    });
+}
+/** `git status --porcelain -z` → set of paths with any dirty/untracked state. */
+async function dirtyPaths(cwd) {
+    const out = await git(cwd, ["status", "--porcelain", "-uall", "-z"]);
+    if (out === null)
+        return null;
+    const paths = new Set();
+    for (const entry of out.split("\0")) {
+        if (entry.length < 4)
+            continue;
+        // "XY path" (rename entries "XY new\0old" — the extra segment lacks the
+        // status prefix and is shorter than 4 chars only when degenerate; treat
+        // every segment with the status shape as an entry).
+        const path = entry.slice(3);
+        if (path)
+            paths.add(path);
+    }
+    return paths;
+}
+export async function captureGitBaseline(cwd) {
+    const dirty = await dirtyPaths(cwd);
+    if (dirty === null)
+        return null;
+    return { dirtyAtStart: dirty };
+}
+/**
+ * Diff the current working tree against the run-start baseline.
+ *
+ * Known honest limits: a file already dirty at baseline that the run edited
+ * further is not attributed to the run (indistinguishable without content
+ * snapshots), and deleted-line counts for such files would mix user and agent
+ * edits — so they are excluded entirely.
+ */
+export async function detectRunChanges(cwd, baseline) {
+    if (!baseline)
+        return null;
+    const dirtyNow = await dirtyPaths(cwd);
+    if (dirtyNow === null)
+        return null;
+    const changedFiles = [...dirtyNow].filter((path) => !baseline.dirtyAtStart.has(path)).sort();
+    if (changedFiles.length === 0) {
+        return { changedFiles, modifiedExistingTests: [] };
+    }
+    // Untracked paths are new files; only tracked files count as "existing".
+    const untrackedOut = await git(cwd, ["ls-files", "--others", "--exclude-standard", "-z"]);
+    const untracked = new Set((untrackedOut ?? "").split("\0").filter(Boolean));
+    const modifiedExistingTests = [];
+    const candidates = changedFiles.filter((path) => isTestFilePath(path) && !untracked.has(path));
+    if (candidates.length > 0) {
+        const numstat = await git(cwd, ["diff", "HEAD", "--numstat", "-z", "--", ...candidates]);
+        if (numstat !== null) {
+            // -z numstat entries: "added\tdeleted\tpath\0" (renames add a segment).
+            for (const entry of numstat.split("\0")) {
+                const parts = entry.split("\t");
+                if (parts.length < 3)
+                    continue;
+                const deleted = Number(parts[1]);
+                const path = parts[2];
+                if (!path || Number.isNaN(deleted))
+                    continue;
+                modifiedExistingTests.push({ path, deletedLines: deleted });
+            }
+        }
+    }
+    return { changedFiles, modifiedExistingTests };
+}

package/dist/agent/profiles.js

@@ -155,7 +155,7 @@ export function builtinAgentProfiles() {
                 "You are an implementer subagent working in your own isolated git worktree — the parent tree is never touched.",
                 "Your worktree forks from the last commit; changes the parent made after that commit are NOT present unless included in your briefing.",
                 "Make the smallest coherent edits that complete your assigned group. Stay strictly inside the file set you were given; if a needed change falls outside it, report that instead of editing.",
-                "Verify your changes narrowly (targeted tests or typecheck) when possible, and end with a concise summary of files changed and verification results — the parent reviews and applies your worktree.",
+                "Verify your changes when possible — run the affected module's existing tests, not only the cases you added — and end with a concise summary of files changed and verification results; the parent reviews and applies your worktree.",
             ].join("\n"),
         },
     ];

package/dist/agent.js

@@ -573,6 +573,10 @@ export class Agent {
                 // the redirected one.
                 hookState.exploredFiles?.clear();
                 hookState.largeTaskCheckpointDone = false;
+                // A steer is a new ask: the completion gate must be able to fire
+                // again for the follow-up's closing pass, or appended requirements
+                // never get a self-check (codeChanged stays — prior edits are real).
+                hookState.completionGateFired = false;
                 if (typeof input.content === "string" && input.content.trim()) {
                     hookState.taskType = classifyTask(input.content);
                 }

package/dist/main.js

@@ -575,6 +575,26 @@ async function main() {
             // mode is byte-for-byte the previous behavior.
             const jsonOutput = args.outputFormat === "json";
             const collector = new PrintRunCollector();
+            // Harness-side change footprint (git ground truth) — printed by the
+            // harness so the run cannot omit or misstate what it touched.
+            const changeBaseline = jsonOutput
+                ? await (await import("./agent/change-tracker.js")).captureGitBaseline(args.cwd)
+                : null;
+            const collectChanges = async () => {
+                if (!changeBaseline)
+                    return undefined;
+                const { detectRunChanges } = await import("./agent/change-tracker.js");
+                const detected = await detectRunChanges(args.cwd, changeBaseline).catch(() => null);
+                if (!detected)
+                    return undefined;
+                return {
+                    changed_files: detected.changedFiles.length,
+                    modified_existing_tests: detected.modifiedExistingTests.map((t) => ({
+                        path: t.path,
+                        deleted_lines: t.deletedLines,
+                    })),
+                };
+            };
             const printSessionId = sessionManager
                 ? basename(sessionManager.getSessionFile())
                 : undefined;
@@ -617,6 +637,7 @@ async function main() {
                         summary: collector.summary(),
                         sessionId: printSessionId,
                         compaction: agent.getCompactionStats(),
+                        changes: await collectChanges(),
                     }) + "\n");
                 }
                 else {
@@ -633,6 +654,7 @@ async function main() {
                     summary: collector.summary(),
                     sessionId: printSessionId,
                     compaction: agent.getCompactionStats(),
+                    changes: await collectChanges(),
                 }) + "\n");
                 process.exitCode = 1;
             }

package/dist/orchestrator/default-hooks.js

@@ -6,6 +6,7 @@ import { DiscoveryBarrier } from "../agent/discovery-barrier.js";
 import { arbitrateToolCall } from "../agent/tool-arbiter.js";
 import { buildCompletionSelfCheckReminder, buildEditRetryEscalationReminder, buildSmallTaskHint, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
 import { largeImplementationTaskReminder, orchestrationRequestReminder, reminderForTaskType, userNamedModelReminder } from "../prompt/task-reminders.js";
+import { captureGitBaseline, detectRunChanges } from "../agent/change-tracker.js";
 import { formatCoverageSummary, resolveWorkflowPhase } from "./workflow.js";
 import { resolve as resolvePath } from "node:path";
 import { traceEvent } from "../debug-trace.js";
@@ -14,7 +15,13 @@ import { buildSubagentLifecycleReminder } from "../agent/subagent-lifecycle-remi
 export function createDefaultHooks() {
     return [
         {
-            beforeTurn(ctx) {
+            async beforeTurn(ctx) {
+                // Git ground truth for the completion gate: tool-metadata bookkeeping
+                // misses bash-written files and subagent worktree merges; a dirty-state
+                // baseline at run start makes the run's real footprint observable.
+                if (ctx.state.gitBaseline === undefined) {
+                    ctx.state.gitBaseline = await captureGitBaseline(ctx.cwd);
+                }
                 const taskType = classifyTask(ctx.input);
                 ctx.state.taskType = taskType;
                 ctx.state.governor = new ExecutionGovernor(taskType);
@@ -99,6 +106,7 @@ export function createDefaultHooks() {
         },
         {
             beforeToolCall(ctx) {
+                ctx.state.toolUsed = true;
                 const arbitration = arbitrateToolCall(ctx.toolCall);
                 const toolCall = { ...arbitration.toolCall, ...(arbitration.note ? { arbiterNote: arbitration.note } : {}) };
                 ctx.replaceToolCall(toolCall);
@@ -220,7 +228,7 @@ export function createDefaultHooks() {
                 }
                 // Verification reminders intentionally removed. See afterToolCall.
             },
-            afterTurn(ctx) {
+            async afterTurn(ctx) {
                 // Verification force-continuation removed. The model decides whether
                 // verification is meaningful for the task, per the system prompt.
                 //
@@ -232,21 +240,37 @@ export function createDefaultHooks() {
                 // "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.
+                // check would suggest. The parent's gate still covers their merged
+                // changes via the git baseline below.
                 if (ctx.agent.role === "subagent")
                     return;
+                // Change detection: tool metadata first (cheap), then git ground
+                // truth — which also catches bash-written files and subagent
+                // worktree merges. Gate only runs git when the run actually used
+                // tools, so external repo churn cannot hijack a pure Q&A turn.
+                let changes = null;
+                if (ctx.state.toolUsed && ctx.state.gitBaseline) {
+                    changes = await detectRunChanges(ctx.cwd, ctx.state.gitBaseline);
+                }
+                const changedSomething = !!ctx.state.codeChanged || (changes !== null && changes.changedFiles.length > 0);
+                if (!changedSomething)
+                    return;
                 ctx.state.completionGateFired = true;
                 ctx.state.forceContinuationReason = "completion_self_check";
-                ctx.queueReminder(buildCompletionSelfCheckReminder());
-                traceEvent("completion_gate_fired", { turnCount: ctx.state.turnCount });
+                ctx.queueReminder(buildCompletionSelfCheckReminder({
+                    modifiedExistingTests: changes?.modifiedExistingTests,
+                }));
+                traceEvent("completion_gate_fired", {
+                    turnCount: ctx.state.turnCount,
+                    changedFiles: changes?.changedFiles.length,
+                    modifiedExistingTests: changes?.modifiedExistingTests.length,
+                });
             },
         },
     ];

package/dist/orchestrator/hooks.d.ts

@@ -1,5 +1,6 @@
 import type { Agent } from "../agent.js";
 import type { ContentPart, ParsedToolCall, ToolRegistryEntry, ToolResult } from "../types.js";
+import type { GitChangeBaseline } from "../agent/change-tracker.js";
 import type { TaskType } from "../agent/task-classifier.js";
 import type { ExecutionGovernor } from "../agent/execution-governor.js";
 import type { EvidenceTracker } from "../agent/evidence-tracker.js";
@@ -18,6 +19,10 @@ export interface TurnHookState {
     codeChanged?: boolean;
     /** Completion self-check gate already fired this run (fires at most once). */
     completionGateFired?: boolean;
+    /** Git dirty-state snapshot at run start (null = not a git repo / git failed). */
+    gitBaseline?: GitChangeBaseline | null;
+    /** Any tool executed this run — guards git-change attribution for pure Q&A turns. */
+    toolUsed?: boolean;
     smallTaskHintSent?: boolean;
     recentEditFailures?: string[];
     editNoMatchReminderPaths?: string[];

package/dist/print-output.d.ts

@@ -42,6 +42,18 @@ export declare class PrintRunCollector {
     private addUsage;
     summary(): PrintRunSummary;
 }
+/**
+ * Harness-observed change footprint of the run (git ground truth). Printed
+ * by the harness, not the model — a run cannot omit or misstate what it
+ * touched ("no breaking changes" next to deleted test assertions).
+ */
+export interface PrintChangeSummary {
+    changed_files: number;
+    modified_existing_tests: Array<{
+        path: string;
+        deleted_lines: number;
+    }>;
+}
 /**
  * Per-path counts of context compactions during the run. Lets benchmark
  * harnesses correlate outcomes with "did the model ever lose sight of the
@@ -61,10 +73,12 @@ export declare function formatPrintJson(input: {
     sessionId?: string;
     stopReason?: "end_turn" | "error" | "cancelled";
     compaction?: PrintCompactionStats;
+    changes?: PrintChangeSummary;
 }): string;
 export declare function formatPrintJsonError(input: {
     message: string;
     summary?: PrintRunSummary;
     sessionId?: string;
     compaction?: PrintCompactionStats;
+    changes?: PrintChangeSummary;
 }): string;

package/dist/print-output.js

@@ -84,6 +84,7 @@ export function formatPrintJson(input) {
         usage: input.summary.usage,
         usage_reported: input.summary.usage_reported,
         ...(input.compaction ? { compaction: input.compaction } : {}),
+        ...(input.changes ? { changes: input.changes } : {}),
     });
 }
 export function formatPrintJsonError(input) {
@@ -101,5 +102,6 @@ export function formatPrintJsonError(input) {
             }
             : {}),
         ...(input.compaction ? { compaction: input.compaction } : {}),
+        ...(input.changes ? { changes: input.changes } : {}),
     });
 }

package/dist/prompt/reminders.d.ts

@@ -23,7 +23,14 @@ 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 interface CompletionSelfCheckOptions {
+    /** Pre-existing test files this run modified, with deleted-line counts. */
+    modifiedExistingTests?: Array<{
+        path: string;
+        deletedLines: number;
+    }>;
+}
+export declare function buildCompletionSelfCheckReminder(options?: CompletionSelfCheckOptions): string;
 export declare function buildToolFreezeReminder(reason: string): string;
 export declare function buildWorkflowPhaseReminder(input: {
     phase: "investigate" | "correlate" | "conclude";

package/dist/prompt/reminders.js

@@ -116,15 +116,30 @@ You have enough context to act. Do not continue reading, searching, or delegatin
 Choose one of:
 1. Use edit/write to make the requested change.
 2. If no safe change can be made from the gathered context, explain the concrete blocker.
-3. If files were already changed, run the narrowest meaningful verification or finish with the result.
+3. If files were already changed, verify the change and run the affected module's existing tests, 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.
+export function buildCompletionSelfCheckReminder(options = {}) {
+    const sections = [];
+    const modifiedTests = options.modifiedExistingTests ?? [];
+    if (modifiedTests.length > 0) {
+        // Disclosure, not accusation: legitimate test updates (requirement
+        // changes, fixing a broken test, refactors) are normal engineering — the
+        // rule is that they must be declared, never silent. Confrontational
+        // wording risks a model rolling back a user-requested test update.
+        const listed = modifiedTests
+            .slice(0, 8)
+            .map((t) => `- ${t.path}${t.deletedLines > 0 ? ` (${t.deletedLines} line${t.deletedLines === 1 ? "" : "s"} removed)` : ""}`)
+            .join("\n");
+        sections.push(`This run modified pre-existing test files:
+${listed}${modifiedTests.length > 8 ? `\n- …and ${modifiedTests.length - 8} more` : ""}
+
+If a change you made caused an existing test to fail and you edited the test so the suite passes, restore the original behavior instead — weakening a test to make it pass is never acceptable. If the test changes are intentional (the request requires new expected behavior, or the test itself was wrong), keep them and state each modified test and the reason in your final summary.`);
+    }
+    sections.push(`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.
-`);
+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.`);
+    return wrapInSystemReminder(`\n${sections.join("\n\n")}\n`);
 }
 export function buildToolFreezeReminder(reason) {
     return wrapInSystemReminder(`

package/dist/prompt/task-reminders.js

@@ -24,7 +24,7 @@ Implementation workflow:
 - Do not stop at a proposal when the user asked for a change.
 - Inspect the relevant files first, then make the smallest coherent edit.
 - Keep unrelated files and behavior out of scope.
-- Run a narrow verification command or explain why it cannot be run.
+- Verify the change, then run the existing tests of the affected module — not only the cases you added — or explain why they cannot be run.
 `);
         case "code_review":
             return wrapInSystemReminder(`

package/package.json

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