@bubblebrain-ai/bubble 0.0.46 → 0.0.47

package/dist/oauth/storage.js

@@ -1,14 +1,21 @@
 /**
- * OAuth credential storage in ~/.bubble/auth.json
+ * OAuth credential storage in <bubble home>/auth.json.
+ *
+ * The path is resolved at CONSTRUCTION time through getBubbleHome(), never at
+ * module load: a module-level constant froze the real ~/.bubble at import,
+ * which no test could isolate (known-defects #7) and which ignored
+ * BUBBLE_HOME / dev mode while every other config file honored them
+ * (config.json, sessions, memory all derive from getBubbleHome).
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { homedir } from "node:os";
-const AUTH_PATH = join(homedir(), ".bubble", "auth.json");
+import { getBubbleHome } from "../bubble-home.js";
 export class AuthStorage {
     data = {};
     mutationListeners = [];
-    constructor() {
+    authPath;
+    constructor(authPath = join(getBubbleHome(), "auth.json")) {
+        this.authPath = authPath;
         this.load();
     }
     /**
@@ -34,10 +41,10 @@ export class AuthStorage {
         }
     }
     load() {
-        if (!existsSync(AUTH_PATH))
+        if (!existsSync(this.authPath))
             return;
         try {
-            const raw = readFileSync(AUTH_PATH, "utf-8");
+            const raw = readFileSync(this.authPath, "utf-8");
             const parsed = JSON.parse(raw);
             this.data = parsed;
         }
@@ -46,13 +53,13 @@ export class AuthStorage {
         }
     }
     save() {
-        const dir = dirname(AUTH_PATH);
+        const dir = dirname(this.authPath);
         if (!existsSync(dir))
             mkdirSync(dir, { recursive: true });
-        writeFileSync(AUTH_PATH, JSON.stringify(this.data, null, 2) + "\n", { mode: 0o600 });
+        writeFileSync(this.authPath, JSON.stringify(this.data, null, 2) + "\n", { mode: 0o600 });
     }
     getPath() {
-        return AUTH_PATH;
+        return this.authPath;
     }
     get(providerId) {
         return this.data[providerId];

package/dist/orchestrator/default-hooks.d.ts

@@ -1,2 +1,22 @@
 import type { TurnHooks } from "./hooks.js";
+/**
+ * Default hooks: infrastructure and information only.
+ *
+ * The cognitive-governance layer that used to live here (task classifier,
+ * step-budget governor, discovery barrier, evidence tracker, bash-search
+ * arbitration, delegation nudge, completion self-check) was removed — see
+ * docs/harness-thinning.md. The TurnHooks mechanism itself stays, pi-style:
+ * hosts may install their own policies, the core ships none.
+ *
+ * What remains, and why it passes the ruler in that document:
+ * - resident-history compaction calls (infrastructure)
+ * - background-task and subagent-lifecycle reminders (facts the model
+ *   cannot otherwise see)
+ * - orchestrationRequestReminder (deliberately retained policy: amplifies
+ *   the user's EXPLICIT orchestration request at the decision turn)
+ * - userNamedModelReminder (deterministic catalog resolution of a model the
+ *   user named — information the model would otherwise retype from priors)
+ * - modified-existing-tests disclosure (git ground truth: bash writes and
+ *   subagent worktree merges do not appear in the model's own tool memory)
+ */
 export declare function createDefaultHooks(): TurnHooks[];

package/dist/orchestrator/default-hooks.js

@@ -1,51 +1,43 @@
-import { classifyTask } from "../agent/task-classifier.js";
-import { classifyTaskSize } from "../agent/task-size.js";
-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 { buildCompletionSelfCheckReminder, buildEditRetryEscalationReminder, buildSmallTaskHint, buildWorkflowPhaseReminder, } from "../prompt/reminders.js";
-import { largeImplementationTaskReminder, orchestrationRequestReminder, reminderForTaskType, userNamedModelReminder } from "../prompt/task-reminders.js";
+import { buildModifiedTestsDisclosure } from "../prompt/reminders.js";
+import { orchestrationRequestReminder, 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";
-import { builtinAgentProfiles, discoverAgentProfiles, hasWriteWorktreeProfile } from "../agent/profiles.js";
 import { buildSubagentLifecycleReminder } from "../agent/subagent-lifecycle-reminder.js";
+/**
+ * Default hooks: infrastructure and information only.
+ *
+ * The cognitive-governance layer that used to live here (task classifier,
+ * step-budget governor, discovery barrier, evidence tracker, bash-search
+ * arbitration, delegation nudge, completion self-check) was removed — see
+ * docs/harness-thinning.md. The TurnHooks mechanism itself stays, pi-style:
+ * hosts may install their own policies, the core ships none.
+ *
+ * What remains, and why it passes the ruler in that document:
+ * - resident-history compaction calls (infrastructure)
+ * - background-task and subagent-lifecycle reminders (facts the model
+ *   cannot otherwise see)
+ * - orchestrationRequestReminder (deliberately retained policy: amplifies
+ *   the user's EXPLICIT orchestration request at the decision turn)
+ * - userNamedModelReminder (deterministic catalog resolution of a model the
+ *   user named — information the model would otherwise retype from priors)
+ * - modified-existing-tests disclosure (git ground truth: bash writes and
+ *   subagent worktree merges do not appear in the model's own tool memory)
+ */
 export function createDefaultHooks() {
     return [
         {
             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.
+                // Git ground truth for the tests-touched disclosure: 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);
-                ctx.state.discoveryBarrier = new DiscoveryBarrier({
-                    cwd: ctx.cwd,
-                    input: ctx.input,
-                    enabled: taskType === "repo_orientation",
-                });
-                const taskReminder = reminderForTaskType(taskType, {
-                    // Only parent agents carry the delegation tools; the nudge must
-                    // never reach a child that cannot spawn anything.
-                    canDelegate: ctx.agent.hasToolAvailable("spawn_agent"),
-                });
-                if (taskReminder) {
-                    ctx.queueReminder(taskReminder);
-                }
                 // User named the mechanism ("agent team" / workflow / 编排): remind at
                 // the decision turn, where it outweighs the parallel-spawns prior.
                 const orchestrationReminder = orchestrationRequestReminder(ctx.input, ctx.agent.hasToolAvailable("run_workflow"));
                 if (orchestrationReminder) {
                     ctx.queueReminder(orchestrationReminder);
-                    // The large-change checkpoint must not re-offer spawn_agent in a
-                    // turn where this reminder just forbade it (design §3).
-                    ctx.state.orchestrationReminderSent = true;
                 }
                 // User named a configured model ("gpt 5.6 sol"): resolve it against
                 // the routable catalog and hand over the exact id at the decision
@@ -54,18 +46,6 @@ export function createDefaultHooks() {
                 if (namedModelReminder) {
                     ctx.queueReminder(namedModelReminder);
                 }
-                // Small-task hint: counterweight to the default protocol's exploration
-                // bias, only fires once per run on focused one-shot requests like
-                // "写个 HTML 介绍元旦". Don't issue for the same input twice.
-                if (!ctx.state.smallTaskHintSent && classifyTaskSize(ctx.input) === "small") {
-                    ctx.state.smallTaskHintSent = true;
-                    ctx.queueReminder(buildSmallTaskHint());
-                }
-                if (taskType === "security_investigation") {
-                    ctx.state.evidenceTracker = new EvidenceTracker();
-                    ctx.state.workflowPhase = "investigate";
-                    ctx.state.workflowKey = "";
-                }
                 // Background-task truth at turn start: completions that landed while
                 // the agent was idle (or during another session's turn) reach the
                 // model here; the same state-change gate prevents duplicates with the
@@ -74,31 +54,10 @@ export function createDefaultHooks() {
                 if (backgroundTaskReminder) {
                     ctx.queueReminder(backgroundTaskReminder);
                 }
-                for (const reminder of ctx.state.governor.consumePendingReminders()) {
-                    ctx.queueReminder(reminder);
-                }
                 ctx.agent.compactResidentHistory();
             },
             beforeModelCall(ctx) {
                 ctx.agent.compactResidentHistory();
-                if (ctx.state.taskType === "security_investigation" && ctx.state.evidenceTracker && ctx.state.governor) {
-                    const coverage = ctx.state.evidenceTracker.snapshot();
-                    const phase = resolveWorkflowPhase({
-                        coreCoverageComplete: ctx.state.evidenceTracker.isCoreCoverageComplete(),
-                        searchFrozen: false,
-                    });
-                    ctx.state.workflowPhase = phase;
-                    const summary = formatCoverageSummary(coverage);
-                    const key = `${phase}:${ctx.state.evidenceTracker.key()}:0`;
-                    if (ctx.state.workflowKey !== key) {
-                        ctx.state.workflowKey = key;
-                        ctx.queueReminder(buildWorkflowPhaseReminder({
-                            phase,
-                            covered: summary.covered,
-                            pending: summary.pending,
-                        }));
-                    }
-                }
             },
             afterTurn(ctx) {
                 ctx.agent.compactResidentHistory();
@@ -107,98 +66,6 @@ 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);
-                ctx.state.governor?.beforeToolCall(toolCall);
-                // Large-change checkpoint (large-task-delegation design §1): the
-                // first mutation of the turn is the decision point — exploration is
-                // over, nothing has been edited yet.
-                if (isMutationTool(toolCall.name)) {
-                    maybeQueueLargeTaskNudge(ctx);
-                }
-                const blockedResult = ctx.state.discoveryBarrier?.beforeToolCall(toolCall);
-                if (blockedResult)
-                    ctx.blockToolCall(blockedResult);
-            },
-            afterToolCall(ctx) {
-                if (ctx.toolCall.arbiterNote) {
-                    ctx.replaceResult({
-                        ...ctx.result,
-                        metadata: {
-                            ...ctx.result.metadata,
-                            arbiterNote: ctx.toolCall.arbiterNote,
-                        },
-                    });
-                }
-                ctx.state.evidenceTracker?.observe(ctx.toolCall, ctx.result);
-                ctx.state.governor?.afterToolResult(ctx.toolCall, ctx.result);
-                ctx.state.discoveryBarrier?.afterToolCall(ctx.toolCall, ctx.result);
-                // Edit/write retry-escalation: models can spiral on "identical content"
-                // or "not found" errors. Nudge them to re-ground or switch strategy.
-                if (isMutationTool(ctx.toolCall.name) && ctx.result.isError) {
-                    if (ctx.toolCall.name === "edit" && ctx.result.status === "no_match" && ctx.result.metadata?.kind === "edit") {
-                        const path = typeof ctx.result.metadata.path === "string" ? ctx.result.metadata.path : "";
-                        const reminded = ctx.state.editNoMatchReminderPaths ?? (ctx.state.editNoMatchReminderPaths = []);
-                        if (path && !reminded.includes(path)) {
-                            reminded.push(path);
-                            const summary = ctx.result.content.split("\n")[0] || "";
-                            ctx.queueReminder(buildEditRetryEscalationReminder(`Edit oldText did not match ${path}. ${summary}`));
-                        }
-                    }
-                    const hash = hashEditCall(ctx.toolCall);
-                    const history = ctx.state.recentEditFailures ?? (ctx.state.recentEditFailures = []);
-                    history.push(hash);
-                    // Keep last 4 entries.
-                    if (history.length > 4)
-                        history.shift();
-                    const len = history.length;
-                    if (len >= 2 && history[len - 1] === history[len - 2] && !ctx.state.editRetryReminderSent) {
-                        ctx.state.editRetryReminderSent = true;
-                        const summary = ctx.result.content.split("\n")[0] || "";
-                        ctx.queueReminder(buildEditRetryEscalationReminder(`Last failure: ${ctx.toolCall.name} on the same target with identical arguments. ${summary}`));
-                    }
-                }
-                else if (isMutationTool(ctx.toolCall.name) && !ctx.result.isError) {
-                    // Successful mutation resets the dedup state so a later, unrelated
-                    // failure won't fire the reminder spuriously.
-                    ctx.state.recentEditFailures = [];
-                    ctx.state.editNoMatchReminderPaths = [];
-                    ctx.state.editRetryReminderSent = false;
-                }
-                // Redundant-Read detection moved into the read tool itself: it now
-                // returns a FILE_UNCHANGED_STUB (or auto-advances to the next page)
-                // when the same args land on an unchanged file. Hook-level reminder
-                // is removed to avoid duplicate signals and to let the structural
-                // dedup do the work.
-                if (isCodeWriteResult(ctx.toolCall, ctx.result)) {
-                    markCodeChanged(ctx.state);
-                    ctx.state.appliedEditCount = (ctx.state.appliedEditCount ?? 0) + 1;
-                }
-                // Large-task breadth evidence (design §1): only files actually READ.
-                // Search results contribute nothing — one glob returns up to 100
-                // match paths and would saturate any threshold instantly (review
-                // blocker). Bash-parsed reads (cat/head/sed -n) carry relative
-                // paths, so resolve against cwd before dedup.
-                if (!ctx.result.isError && ctx.result.metadata?.kind === "read") {
-                    const path = typeof ctx.result.metadata.path === "string" ? ctx.result.metadata.path : undefined;
-                    if (path) {
-                        (ctx.state.exploredFiles ??= new Set()).add(resolvePath(ctx.cwd, path));
-                    }
-                }
-                // Removed: active verification tracking. The previous design nagged the
-                // model every turn until it ran a recognised verification command, and
-                // narrowly accepted only test/lint commands — which meant ad-hoc python
-                // checks did not count, the nag never cleared, and reasoning models
-                // (DeepSeek v4-pro with hex-blindness) spiraled trying to "prove" the
-                // edit was correct. CC's approach is the opposite: verify when there
-                // is something real to verify, say so explicitly when there isn't, and
-                // trust the model to judge. We follow that.
-                if (ctx.state.governor) {
-                    for (const reminder of ctx.state.governor.consumePendingReminders()) {
-                        ctx.queueReminder(reminder);
-                    }
-                }
             },
             beforeContinuation(ctx) {
                 if (hasSubagentLifecycleActivity(ctx.toolCalls, ctx.toolResults)) {
@@ -215,131 +82,39 @@ export function createDefaultHooks() {
                 if (taskReminder) {
                     ctx.queueReminder(taskReminder);
                 }
-                // Routing detector note (model-routing design §6): rides the same
-                // channel as the lifecycle reminder, once per session. Consuming also
-                // closes the per-fan-out counting window.
-                const routingReminder = ctx.agent.consumePendingRoutingReminder?.();
-                if (routingReminder) {
-                    ctx.queueReminder(routingReminder);
-                }
-                if (ctx.state.taskType === "security_investigation" && ctx.state.evidenceTracker?.isCoreCoverageComplete()) {
-                    ctx.requestTextOnlyTurn("Core security investigation evidence has been collected. Summarize the findings instead of continuing with more tool calls.");
-                    return;
-                }
-                // Verification reminders intentionally removed. See afterToolCall.
             },
             async 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)
+                // Modified-existing-tests disclosure: pure information, delivered at
+                // most once, only when this run touched test files that already
+                // existed at run start. Forcing one continuation turn is the only way
+                // a final-turn fact can reach the model at all. The old completion
+                // self-check ("re-read the request...") was removed with the
+                // governance layer; this survives it because the underlying fact
+                // comes from git, not from the model's own tool history.
+                if (ctx.state.testsTouchedDisclosed)
                     return;
-                // Tools are frozen: the model could not act on anything the check
-                // surfaces, so another turn is pure token burn.
+                // Tools are frozen: the model could not act on the disclosure, 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. The parent's gate still covers their merged
-                // changes via the git baseline below.
+                // Subagents hand off to a parent whose own disclosure covers their
+                // merged changes via the git baseline.
                 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)
+                // Only attribute git changes to runs that actually used tools, so
+                // external repo churn cannot hijack a pure Q&A turn.
+                if (!ctx.state.toolUsed || !ctx.state.gitBaseline)
                     return;
-                ctx.state.completionGateFired = true;
-                ctx.state.forceContinuationReason = "completion_self_check";
-                ctx.queueReminder(buildCompletionSelfCheckReminder({
-                    modifiedExistingTests: changes?.modifiedExistingTests,
-                }));
-                traceEvent("completion_gate_fired", {
-                    turnCount: ctx.state.turnCount,
-                    changedFiles: changes?.changedFiles.length,
-                    modifiedExistingTests: changes?.modifiedExistingTests.length,
-                });
+                const changes = await detectRunChanges(ctx.cwd, ctx.state.gitBaseline);
+                if (!changes || changes.modifiedExistingTests.length === 0)
+                    return;
+                ctx.state.testsTouchedDisclosed = true;
+                ctx.state.forceContinuationReason = "tests_touched_disclosure";
+                ctx.queueReminder(buildModifiedTestsDisclosure(changes.modifiedExistingTests));
             },
         },
     ];
 }
-function markCodeChanged(state) {
-    state.codeChanged = true;
-}
-// Large-task delegation checkpoint (large-task-delegation design §1-3).
-const BREADTH_FILES = 8;
-const BREADTH_FILES_WITH_PLAN = 5;
-const BREADTH_TODOS = 6;
-function maybeQueueLargeTaskNudge(ctx) {
-    // Evaluated exactly once per turn, at the first mutation — fired or not
-    // (mid-implementation re-detection is out of scope by design §4).
-    if (ctx.state.largeTaskCheckpointDone)
-        return;
-    ctx.state.largeTaskCheckpointDone = true;
-    const agent = ctx.agent;
-    const taskType = ctx.state.taskType;
-    const exploredFiles = ctx.state.exploredFiles?.size ?? 0;
-    const pendingTodos = agent.getTodos?.()
-        ?.filter((todo) => todo.status === "pending" || todo.status === "in_progress").length ?? 0;
-    const threshold = pendingTodos >= BREADTH_TODOS ? BREADTH_FILES_WITH_PLAN : BREADTH_FILES;
-    // Gate order: cheap checks first; the profile discovery (filesystem) runs
-    // only when everything else already passed.
-    const suppressedBy = agent.largeTaskNudgeConsumed ? "session_latch"
-        : (taskType === "code_review" || taskType === "security_investigation") ? "task_type"
-            : !agent.hasToolAvailable("spawn_agent") ? "no_spawn_tool"
-                : (agent.activeSubAgentCount?.() ?? 0) > 0 ? "active_children"
-                    : agent.hasRunningWorkflow?.() ? "running_workflow"
-                        : exploredFiles < threshold ? "below_threshold"
-                            : !writeWorktreeSurfaceAvailable(ctx.cwd) ? "no_write_profile"
-                                : undefined;
-    traceEvent("delegation_detector", {
-        fired: suppressedBy === undefined,
-        exploredFiles,
-        pendingTodos,
-        threshold,
-        taskType: taskType ?? "unknown",
-        ...(suppressedBy ? { suppressedBy } : {}),
-    });
-    if (suppressedBy !== undefined)
-        return;
-    agent.largeTaskNudgeConsumed = true;
-    ctx.queueReminder(largeImplementationTaskReminder({
-        exploredFiles,
-        pendingTodos,
-        appliedEdits: ctx.state.appliedEditCount ?? 0,
-        orchestrationRequested: ctx.state.orchestrationReminderSent === true,
-    }));
-}
-function writeWorktreeSurfaceAvailable(cwd) {
-    try {
-        const discovered = discoverAgentProfiles(cwd, "both").profiles;
-        return hasWriteWorktreeProfile([...builtinAgentProfiles(), ...discovered]);
-    }
-    catch {
-        return hasWriteWorktreeProfile(builtinAgentProfiles());
-    }
-}
-function isCodeWriteResult(_toolCall, result) {
-    if (result.isError || result.status === "blocked" || result.status === "cancelled" || result.status === "command_error") {
-        return false;
-    }
-    return result.metadata?.kind === "write" || result.metadata?.kind === "edit" || result.metadata?.kind === "patch";
-}
-function isMutationTool(name) {
-    return name === "edit" || name === "write";
-}
 function hasSubagentLifecycleActivity(toolCalls, toolResults) {
     return toolCalls.some((toolCall) => isSubagentLifecycleTool(toolCall.name))
         || toolResults.some((result) => result.metadata?.kind === "subagent");
@@ -350,26 +125,3 @@ function isSubagentLifecycleTool(name) {
         || name === "send_input"
         || name === "close_agent";
 }
-function hashEditCall(toolCall) {
-    // Cheap fingerprint that identifies "same edit/write call". JSON of the
-    // sorted parsed args is good enough — we only need stable equality between
-    // identical calls, not cryptographic strength.
-    try {
-        return `${toolCall.name}:${stableStringify(toolCall.parsedArgs)}`;
-    }
-    catch {
-        return `${toolCall.name}:${toolCall.arguments}`;
-    }
-}
-function stableStringify(value) {
-    if (Array.isArray(value)) {
-        return `[${value.map(stableStringify).join(",")}]`;
-    }
-    if (value && typeof value === "object") {
-        const entries = Object.keys(value)
-            .sort()
-            .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`);
-        return `{${entries.join(",")}}`;
-    }
-    return JSON.stringify(value ?? null);
-}

package/dist/orchestrator/hooks.d.ts

@@ -1,45 +1,20 @@
 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";
-import type { DiscoveryBarrier } from "../agent/discovery-barrier.js";
-import type { WorkflowPhase } from "./workflow.js";
 export interface TurnHookState {
-    taskType?: TaskType;
-    governor?: ExecutionGovernor;
-    discoveryBarrier?: DiscoveryBarrier;
-    evidenceTracker?: EvidenceTracker;
-    workflowPhase?: WorkflowPhase;
-    workflowKey?: string;
     turnCount?: number;
     forceTextOnlyReason?: string;
     forceContinuationReason?: string;
-    codeChanged?: boolean;
-    /** Completion self-check gate already fired this run (fires at most once). */
-    completionGateFired?: boolean;
+    /** Modified-existing-tests disclosure already delivered this run (at most once). */
+    testsTouchedDisclosed?: 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[];
-    editRetryReminderSent?: boolean;
-    recentReadPaths?: string[];
-    redundantReadReminded?: Set<string>;
     taskBudget?: {
         total: number;
         spent: number;
     };
-    exploredFiles?: Set<string>;
-    /** Checkpoint evaluated at the first mutation — once per turn, fired or not. */
-    largeTaskCheckpointDone?: boolean;
-    /** Successful mutations this turn; rendered as K in the nudge wording. */
-    appliedEditCount?: number;
-    /** orchestrationRequestReminder fired: the nudge offers only run_workflow. */
-    orchestrationReminderSent?: boolean;
 }
 export interface TurnHookContext {
     agent: Agent;
@@ -54,26 +29,18 @@ export interface BeforeModelCallHookContext extends TurnHookContext {
     disableTools: (reason: string) => void;
 }
 export interface BeforeToolCallHookContext extends TurnHookContext {
-    toolCall: ParsedToolCall & {
-        arbiterNote?: string;
-    };
+    toolCall: ParsedToolCall;
     blockedResult?: ToolResult;
-    replaceToolCall: (toolCall: ParsedToolCall & {
-        arbiterNote?: string;
-    }) => void;
+    replaceToolCall: (toolCall: ParsedToolCall) => void;
     blockToolCall: (result: ToolResult) => void;
 }
 export interface AfterToolCallHookContext extends TurnHookContext {
-    toolCall: ParsedToolCall & {
-        arbiterNote?: string;
-    };
+    toolCall: ParsedToolCall;
     result: ToolResult;
     replaceResult: (result: ToolResult) => void;
 }
 export interface BeforeContinuationHookContext extends TurnHookContext {
-    toolCalls: Array<ParsedToolCall & {
-        arbiterNote?: string;
-    }>;
+    toolCalls: ParsedToolCall[];
     toolResults: ToolResult[];
     requestTextOnlyTurn: (reason: string) => void;
 }

package/dist/permission/mode.js

@@ -1,7 +1,7 @@
 export const PERMISSION_MODE_INFO = {
     default: { title: "Default", shortTitle: "default", symbol: "", color: "muted" },
     plan: { title: "Plan", shortTitle: "plan", symbol: "⏸", color: "accent" },
-    bypassPermissions: { title: "Bypass permissions", shortTitle: "bypass", symbol: "⏵⏵", color: "error" },
+    bypassPermissions: { title: "Bypass permissions", shortTitle: "bypass permission", symbol: "⏵⏵", color: "error" },
 };
 /**
  * Cycle order for the interactive mode keybind. The visible TUI loop keeps the

package/dist/prompt/reminders.d.ts

@@ -19,41 +19,15 @@ export declare const PLAN_MODE_EXIT_REMINDER: string;
  * they can be invoked.
  */
 export declare function buildDeferredToolsReminder(names: string[]): string;
-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 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";
-    covered: string[];
-    pending: string[];
-}): string;
 /**
- * Fired when a file mutation failure suggests the model may be relying on stale
- * local memory instead of the current file bytes. Models — especially
- * thinking-heavy ones — can otherwise spiral on `No changes made: identical
- * content` or `oldText not found` because their internal reasoning convinces
- * them they are typing the change correctly.
+ * Modified-existing-tests disclosure (docs/harness-thinning.md): a fact from
+ * git ground truth — bash writes and subagent worktree merges do not appear
+ * in the model's own tool memory. Disclosure, not accusation: legitimate
+ * test updates are normal engineering; the rule is that they must be
+ * declared, never silent.
  */
-export declare function buildEditRetryEscalationReminder(reason: string): string;
-/**
- * Fired the FIRST time the model re-reads a file it already read in this turn.
- * Soft — does not freeze the tool. The model may still re-read when context was
- * pruned, the requested range changed, or a later mutation needs verification.
- */
-export declare function buildRedundantReadReminder(path: string): string;
-/**
- * Injected once at task start when the user's input looks like a small,
- * focused task (e.g. "write an HTML page about X"). Counterweight to the
- * default protocol which biases toward thorough exploration.
- */
-export declare function buildSmallTaskHint(): string;
+export declare function buildModifiedTestsDisclosure(modifiedExistingTests: Array<{
+    path: string;
+    deletedLines: number;
+}>): string;