@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/agent/profiles.js

@@ -0,0 +1,526 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+import { randomInt } from "node:crypto";
+import { getSubtaskPolicy } from "./subtask-policy.js";
+const READONLY_PRESET = [
+    "read",
+    "ls",
+    "grep",
+    "lsp",
+    "web_search",
+    "web_fetch",
+    "memory",
+    "skill",
+];
+const SUBAGENT_DENY_TOOLS = new Set([
+    "subagent",
+    "spawn_agent",
+    "wait_agent",
+    "send_input",
+    "close_agent",
+    "list_agents",
+    "run_workflow",
+    "wait_workflow",
+]);
+const DEFAULT_NICKNAME_CANDIDATES = [
+    "Ada",
+    "Alan",
+    "Grace",
+    "Katherine",
+    "Claude",
+    "Edsger",
+    "Barbara",
+    "Donald",
+    "Margaret",
+    "Ken",
+    "Radia",
+    "Leslie",
+    "Mary",
+    "Dennis",
+    "Frances",
+    "Niklaus",
+    "Jean",
+    "Linus",
+    "Anita",
+    "Yukihiro",
+    "Brenda",
+    "Guido",
+    "Sophie",
+    "Tim",
+    "Hedy",
+    "John",
+    "Evelyn",
+    "Bjarne",
+    "Karen",
+    "Vint",
+    "Adele",
+    "Fernando",
+];
+export function discoverAgentProfiles(cwd, scope = "user") {
+    const diagnostics = [];
+    const profiles = [...builtinAgentProfiles()];
+    const userDir = join(getBubbleHome(), "agents");
+    const projectAgentsDir = findNearestProjectAgentsDir(cwd);
+    if (scope !== "project") {
+        profiles.push(...loadProfilesFromDir(userDir, "user", diagnostics));
+    }
+    if (scope !== "user" && projectAgentsDir) {
+        profiles.push(...loadProfilesFromDir(projectAgentsDir, "project", diagnostics));
+    }
+    const map = new Map();
+    for (const profile of profiles) {
+        map.set(profile.name, profile);
+    }
+    return {
+        profiles: [...map.values()],
+        projectAgentsDir,
+        diagnostics,
+    };
+}
+export function builtinAgentProfiles() {
+    const toProfile = (type) => {
+        const policy = getSubtaskPolicy(type);
+        return {
+            name: `builtin:${type}`,
+            description: `${type} read-only subagent`,
+            source: "builtin",
+            mode: "readonly",
+            model: "inherit",
+            tools: {
+                preset: "explicit",
+                include: [...policy.allowedTools],
+                exclude: [],
+            },
+            approval: "fail",
+            nicknameCandidates: DEFAULT_NICKNAME_CANDIDATES,
+            prompt: policy.reminder,
+            subtaskType: type,
+        };
+    };
+    const roleProfile = (name, description, prompt, include = READONLY_PRESET) => ({
+        name,
+        description,
+        source: "builtin",
+        mode: "readonly",
+        model: "inherit",
+        tools: {
+            preset: "explicit",
+            include,
+            exclude: [],
+        },
+        approval: "fail",
+        nicknameCandidates: DEFAULT_NICKNAME_CANDIDATES,
+        prompt,
+    });
+    return [
+        roleProfile("default", "General read-only subagent", [
+            "You are a focused child agent. Complete the assigned task independently using only read-only tools.",
+            "Return a concise result with concrete evidence, file paths, and any uncertainty.",
+            "Do not ask the user questions. If blocked by policy or missing data, state the blocker plainly.",
+        ].join("\n")),
+        roleProfile("explorer", "Fast codebase exploration subagent", [
+            "You are an explorer subagent for codebase reconnaissance.",
+            "Answer the specific question by inspecting the repository directly. Prefer precise file paths and line-level evidence.",
+            "Keep the answer compact and avoid broad refactors or implementation plans unless asked.",
+        ].join("\n"), ["read", "ls", "grep", "lsp", "memory", "skill"]),
+        roleProfile("worker", "Implementation-planning worker subagent", [
+            "You are a worker subagent. In this Phase 1 runtime you are read-only, so you must not modify files.",
+            "Analyze the assigned implementation slice, identify exact files to change, and return a concrete patch plan or findings.",
+            "If write-capable worker mode is needed, say so explicitly.",
+        ].join("\n"), ["read", "ls", "grep", "lsp", "memory", "skill"]),
+        toProfile("search"),
+        toProfile("security_investigation"),
+        toProfile("evidence_correlation"),
+        toProfile("general_readonly"),
+        // The write-capable builtin (large-task-delegation design §3): before
+        // this, write_worktree was reachable only via user-authored profile
+        // frontmatter, so the delegation nudge would have recommended a surface
+        // that does not exist in a stock session.
+        {
+            name: "implementer",
+            description: "Write-capable implementation subagent (isolated git worktree)",
+            source: "builtin",
+            mode: "write_worktree",
+            model: "inherit",
+            tools: {
+                preset: "explicit",
+                include: ["read", "ls", "grep", "edit", "write", "bash", "lsp"],
+                exclude: [],
+            },
+            approval: "fail",
+            nicknameCandidates: DEFAULT_NICKNAME_CANDIDATES,
+            prompt: [
+                "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 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"),
+        },
+    ];
+}
+/**
+ * The delegation nudge only fires when a write-capable spawn surface exists
+ * (large-task-delegation design §3): defense in depth for hosts that strip
+ * or override the builtin profiles.
+ */
+export function hasWriteWorktreeProfile(profiles) {
+    return profiles.some((profile) => profile.mode === "write_worktree");
+}
+export function findAgentProfile(profiles, name) {
+    return profiles.find((profile) => profile.name === name)
+        ?? profiles.find((profile) => profile.name === `builtin:${name}`);
+}
+export function assignAgentNickname(profile, activeNicknames = []) {
+    const active = new Set([...activeNicknames].map((item) => item.toLowerCase()));
+    const candidates = (profile.nicknameCandidates && profile.nicknameCandidates.length > 0
+        ? profile.nicknameCandidates
+        : DEFAULT_NICKNAME_CANDIDATES)
+        .map((item) => item.trim())
+        .filter(Boolean);
+    const available = candidates.filter((item) => !active.has(item.toLowerCase()));
+    const pool = available.length > 0 ? available : candidates;
+    if (pool.length === 0) {
+        return `Agent-${randomInt(1000, 9999)}`;
+    }
+    return pool[randomInt(pool.length)];
+}
+/**
+ * Tool-effect gate as a function of the profile's mode (design §8): readonly
+ * children keep the read-only fence; write_worktree children may edit, write,
+ * and run bash — inside their isolated worktree, never the parent tree.
+ */
+export function allowedToolEffectsForMode(mode) {
+    return mode === "write_worktree"
+        ? new Set(["read", "write_direct", "write_patch", "unknown"])
+        : new Set(["read"]);
+}
+export function selectToolsForAgentProfile(tools, profile, approval = profile.approval) {
+    const explicitInclude = new Set((profile.tools.include ?? []).map(canonicalToolName));
+    const selected = requestedToolNames(profile);
+    for (const tool of SUBAGENT_DENY_TOOLS)
+        selected.delete(tool);
+    const out = [];
+    for (const tool of tools) {
+        if (!selected.has(tool.name))
+            continue;
+        if (SUBAGENT_DENY_TOOLS.has(tool.name))
+            continue;
+        if ((tool.effect ?? "unknown") !== "read")
+            continue;
+        if (tool.deferred && !explicitInclude.has(tool.name))
+            continue;
+        if (approval === "disabled" && tool.requiresApproval)
+            continue;
+        // Explicit include is the profile author pre-unlocking the tool: the
+        // child is a fresh Agent with its own (empty) unlock set, so a deferred
+        // flag surviving here would re-lock the tool inside the child.
+        const entry = tool.deferred ? { ...tool, deferred: false } : tool;
+        out.push(wrapApprovalFailTool(entry, approval));
+    }
+    return out;
+}
+export function validateAgentProfileTools(tools, profile, approval = profile.approval) {
+    const available = new Map(tools.map((tool) => [tool.name, tool]));
+    const explicitInclude = new Set((profile.tools.include ?? []).map(canonicalToolName));
+    const allowedEffects = allowedToolEffectsForMode(profile.mode);
+    const diagnostics = [];
+    for (const name of requestedToolNames(profile)) {
+        if (SUBAGENT_DENY_TOOLS.has(name)) {
+            diagnostics.push({
+                severity: "error",
+                toolName: name,
+                message: `Tool "${name}" is not allowed inside subagents because recursive delegation is disabled.`,
+            });
+            continue;
+        }
+        const tool = available.get(name);
+        if (!tool) {
+            if (explicitInclude.has(name)) {
+                diagnostics.push({
+                    severity: "warning",
+                    toolName: name,
+                    message: `Tool "${name}" is listed by profile "${profile.name}" but is not available in this session.`,
+                });
+            }
+            continue;
+        }
+        const effect = tool.effect ?? "unknown";
+        if (!allowedEffects.has(effect)) {
+            diagnostics.push({
+                severity: "error",
+                toolName: name,
+                message: `Tool "${name}" has effect "${effect}" and cannot run in ${profile.mode} subagents.`,
+            });
+        }
+        else if (profile.mode === "readonly" && approval === "disabled" && tool.requiresApproval) {
+            // write_worktree children use the worktree approval policy instead.
+            diagnostics.push({
+                severity: "warning",
+                toolName: name,
+                message: `Tool "${name}" requires approval and will be removed because approval is disabled for this subagent.`,
+            });
+        }
+    }
+    return diagnostics;
+}
+export function mergeUsage(current, usage) {
+    const promptTokens = (current?.promptTokens ?? 0) + usage.promptTokens;
+    const completionTokens = (current?.completionTokens ?? 0) + usage.completionTokens;
+    return {
+        promptTokens,
+        completionTokens,
+        totalTokens: promptTokens + completionTokens,
+    };
+}
+function wrapApprovalFailTool(tool, approval) {
+    if (approval !== "fail" || !tool.requiresApproval)
+        return tool;
+    return {
+        ...tool,
+        execute: async () => ({
+            content: `Blocked: tool "${tool.name}" requires interactive approval, which is disabled for subagents.`,
+            isError: true,
+            status: "blocked",
+            metadata: {
+                kind: "security",
+                reason: "Subagents cannot request interactive approval.",
+            },
+        }),
+    };
+}
+/**
+ * Renamed/merged tools keep working for user-defined profiles written
+ * against the old names (memory_search/memory_read_summary merged into
+ * "memory", 2026-07-13).
+ */
+const LEGACY_TOOL_ALIASES = {
+    memory_search: "memory",
+    memory_read_summary: "memory",
+};
+export function canonicalToolName(name) {
+    return LEGACY_TOOL_ALIASES[name] ?? name;
+}
+function requestedToolNames(profile) {
+    const selected = new Set();
+    if (profile.tools.preset === "readonly") {
+        for (const tool of READONLY_PRESET)
+            selected.add(tool);
+    }
+    else if (profile.tools.preset === "explicit") {
+        for (const tool of profile.tools.include ?? [])
+            selected.add(canonicalToolName(tool));
+    }
+    for (const tool of profile.tools.include ?? [])
+        selected.add(canonicalToolName(tool));
+    for (const tool of profile.tools.exclude ?? [])
+        selected.delete(canonicalToolName(tool));
+    return selected;
+}
+function loadProfilesFromDir(dir, source, diagnostics) {
+    if (!existsSync(dir))
+        return [];
+    let entries = [];
+    try {
+        entries = readdirSync(dir);
+    }
+    catch (error) {
+        diagnostics.push(`Failed to read agent profile directory ${dir}: ${error.message || String(error)}`);
+        return [];
+    }
+    const profiles = [];
+    for (const entry of entries) {
+        if (!entry.endsWith(".md"))
+            continue;
+        const filePath = join(dir, entry);
+        try {
+            if (!statSync(filePath).isFile())
+                continue;
+            const parsed = parseAgentProfileFile(readFileSync(filePath, "utf8"), source, filePath);
+            if (parsed)
+                profiles.push(parsed);
+        }
+        catch (error) {
+            diagnostics.push(`Failed to load agent profile ${filePath}: ${error.message || String(error)}`);
+        }
+    }
+    return profiles;
+}
+function parseAgentProfileFile(raw, source, filePath) {
+    const parsed = splitFrontmatter(raw);
+    if (!parsed)
+        return undefined;
+    const frontmatter = parseProfileFrontmatter(parsed.frontmatter);
+    const fallbackName = filePath.split("/").pop()?.replace(/\.md$/, "") ?? "agent";
+    const name = stringValue(frontmatter.name) || fallbackName;
+    const description = stringValue(frontmatter.description);
+    if (!name || !description)
+        return undefined;
+    return {
+        name,
+        description,
+        source,
+        filePath,
+        mode: modeValue(frontmatter.mode),
+        model: stringValue(frontmatter.model) || "inherit",
+        category: stringValue(frontmatter.category),
+        tools: toolsValue(frontmatter.tools),
+        maxTurns: numberValue(frontmatter.maxTurns),
+        approval: approvalValue(frontmatter.approval),
+        nicknameCandidates: stringArray(frontmatter.nicknameCandidates) ?? stringArray(frontmatter.nicknames),
+        prompt: parsed.body.trim(),
+    };
+}
+function splitFrontmatter(raw) {
+    const normalized = raw.replace(/\r\n/g, "\n");
+    if (!normalized.startsWith("---\n"))
+        return undefined;
+    const end = normalized.indexOf("\n---\n", 4);
+    if (end < 0)
+        return undefined;
+    return {
+        frontmatter: normalized.slice(4, end),
+        body: normalized.slice(end + 5),
+    };
+}
+function parseProfileFrontmatter(block) {
+    const out = {};
+    const lines = block.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim())
+            continue;
+        const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!match)
+            continue;
+        const [, key, value] = match;
+        if (value.trim()) {
+            out[key] = parseScalar(value.trim());
+            continue;
+        }
+        i++;
+        const listItems = [];
+        for (; i < lines.length; i++) {
+            const itemLine = lines[i];
+            if (!itemLine.startsWith("  - ")) {
+                i--;
+                break;
+            }
+            const item = itemLine.slice("  - ".length).trim();
+            if (item)
+                listItems.push(String(parseScalar(item)));
+        }
+        if (listItems.length > 0) {
+            out[key] = listItems;
+            continue;
+        }
+        const nested = {};
+        i++;
+        for (; i < lines.length; i++) {
+            const nestedLine = lines[i];
+            if (!nestedLine.startsWith("  ")) {
+                i--;
+                break;
+            }
+            const nestedMatch = nestedLine.trim().match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+            if (nestedMatch) {
+                const nestedKey = nestedMatch[1];
+                const nestedValue = nestedMatch[2].trim();
+                if (nestedValue) {
+                    nested[nestedKey] = parseScalar(nestedValue);
+                    continue;
+                }
+                const items = [];
+                i++;
+                for (; i < lines.length; i++) {
+                    const itemLine = lines[i];
+                    if (!itemLine.startsWith("    - ")) {
+                        i--;
+                        break;
+                    }
+                    const item = itemLine.slice("    - ".length).trim();
+                    if (item)
+                        items.push(String(parseScalar(item)));
+                }
+                nested[nestedKey] = items.length > 0 ? items : "";
+            }
+        }
+        out[key] = nested;
+    }
+    return out;
+}
+function parseScalar(value) {
+    if (!value)
+        return "";
+    const unquoted = value.replace(/^"(.*)"$/, "$1").replace(/^'(.*)'$/, "$1");
+    if (unquoted.startsWith("[") && unquoted.endsWith("]")) {
+        return unquoted.slice(1, -1).split(",").map((item) => String(parseScalar(item.trim()))).filter(Boolean);
+    }
+    if (unquoted === "true")
+        return true;
+    if (unquoted === "false")
+        return false;
+    if (/^-?\d+$/.test(unquoted))
+        return Number.parseInt(unquoted, 10);
+    return unquoted;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function numberValue(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function modeValue(value) {
+    return value === "write_patch" || value === "write_worktree" ? value : "readonly";
+}
+function approvalValue(value) {
+    return value === "disabled" ? "disabled" : "fail";
+}
+function toolsValue(value) {
+    if (typeof value === "string") {
+        if (value === "none" || value === "explicit" || value === "readonly")
+            return { preset: value };
+        return { preset: "explicit", include: [value] };
+    }
+    if (Array.isArray(value)) {
+        return { preset: "explicit", include: stringArray(value) ?? [] };
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        const raw = value;
+        const preset = raw.preset === "none" || raw.preset === "explicit" || raw.preset === "readonly"
+            ? raw.preset
+            : "readonly";
+        return {
+            preset,
+            include: stringArray(raw.include),
+            exclude: stringArray(raw.exclude),
+        };
+    }
+    return { preset: "readonly", include: [], exclude: [] };
+}
+function stringArray(value) {
+    if (typeof value === "string" && value.trim())
+        return [value.trim()];
+    if (!Array.isArray(value))
+        return undefined;
+    return value.filter((item) => typeof item === "string" && !!item.trim()).map((item) => item.trim());
+}
+function findNearestProjectAgentsDir(cwd) {
+    let current = cwd;
+    while (true) {
+        const candidate = join(current, ".bubble", "agents");
+        if (existsSync(candidate)) {
+            try {
+                if (statSync(candidate).isDirectory())
+                    return candidate;
+            }
+            catch {
+                // ignore
+            }
+        }
+        const parent = dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}

package/dist/agent/provider-fingerprint.d.ts

@@ -0,0 +1,6 @@
+import type { Message, ProviderMessage, ProviderMetadataProvider, ProviderRawContentBlock, ToolDefinition } from "../types.js";
+export declare function appendProviderContentBlock(message: Extract<Message, {
+    role: "assistant";
+}>, provider: ProviderMetadataProvider, block: ProviderRawContentBlock): void;
+export declare function buildProviderRequestFingerprint(messages: ProviderMessage[], tools: ToolDefinition[], providerId: string, toolChoice?: string): Record<string, unknown>;
+export declare function cloneProviderRawContentBlock(block: ProviderRawContentBlock): ProviderRawContentBlock;

package/dist/agent/provider-fingerprint.js

@@ -0,0 +1,89 @@
+/**
+ * Provider-request fingerprints and raw content-block plumbing.
+ *
+ * The fingerprint is a structural digest of the projected request (roles,
+ * char volumes, JSON byte sizes) used to detect whether a retried request
+ * actually changed, and to trace what the model saw.
+ */
+import { estimateContextTokens } from "../context/budget.js";
+export function appendProviderContentBlock(message, provider, block) {
+    const current = message.providerMetadata?.[provider]?.contentBlocks ?? [];
+    message.providerMetadata = {
+        ...message.providerMetadata,
+        [provider]: {
+            ...message.providerMetadata?.[provider],
+            contentBlocks: [...current, cloneProviderRawContentBlock(block)],
+        },
+    };
+}
+export function buildProviderRequestFingerprint(messages, tools, providerId, toolChoice) {
+    const roleCounts = {};
+    let contentChars = 0;
+    let reasoningChars = 0;
+    let toolResultChars = 0;
+    let maxToolResultChars = 0;
+    let assistantToolCalls = 0;
+    let rawAnthropicBlocks = 0;
+    let rawAnthropicThinkingBlocks = 0;
+    let rawAnthropicSignatureChars = 0;
+    for (const message of messages) {
+        roleCounts[message.role] = (roleCounts[message.role] ?? 0) + 1;
+        if (message.role === "assistant") {
+            contentChars += message.content.length;
+            reasoningChars += message.reasoning?.length ?? 0;
+            assistantToolCalls += message.toolCalls?.length ?? 0;
+            const blocks = message.providerMetadata?.anthropic?.contentBlocks ?? [];
+            rawAnthropicBlocks += blocks.length;
+            for (const block of blocks) {
+                if (block.type === "thinking" || block.type === "redacted_thinking") {
+                    rawAnthropicThinkingBlocks += 1;
+                }
+                if (typeof block.signature === "string") {
+                    rawAnthropicSignatureChars += block.signature.length;
+                }
+            }
+        }
+        else if (message.role === "tool") {
+            toolResultChars += message.content.length;
+            maxToolResultChars = Math.max(maxToolResultChars, message.content.length);
+        }
+        else if (message.role === "user") {
+            contentChars += typeof message.content === "string"
+                ? message.content.length
+                : message.content.reduce((sum, part) => sum + (part.type === "text" ? part.text.length : part.image_url.url.length), 0);
+        }
+        else {
+            contentChars += message.content.length;
+        }
+    }
+    const systemMessages = messages.filter((message) => message.role === "system");
+    const bodyMessages = messages.filter((message) => message.role !== "system");
+    const systemJsonBytes = Buffer.byteLength(JSON.stringify(systemMessages), "utf8");
+    const bodyJsonBytes = Buffer.byteLength(JSON.stringify(bodyMessages), "utf8");
+    const toolSchemaJsonBytes = Buffer.byteLength(JSON.stringify(tools), "utf8");
+    return {
+        roleCounts,
+        estimatedTokens: estimateContextTokens(messages, providerId),
+        projectedJsonBytes: Buffer.byteLength(JSON.stringify(messages), "utf8"),
+        systemJsonBytes,
+        bodyJsonBytes,
+        toolSchemaJsonBytes,
+        staticPrefixJsonBytes: Buffer.byteLength(JSON.stringify({
+            system: systemMessages,
+            tools,
+            tool_choice: toolChoice,
+        }), "utf8"),
+        toolChoice,
+        contentChars,
+        reasoningChars,
+        toolResultChars,
+        maxToolResultChars,
+        assistantToolCalls,
+        rawAnthropicBlocks,
+        rawAnthropicThinkingBlocks,
+        rawAnthropicSignatureChars,
+    };
+}
+export function cloneProviderRawContentBlock(block) {
+    return JSON.parse(JSON.stringify(block));
+}

package/dist/agent/resident-history.d.ts

@@ -0,0 +1,7 @@
+import type { Message } from "../types.js";
+export declare const RESIDENT_HISTORY_KEEP_RECENT_TURNS = 3;
+export declare const RESIDENT_HISTORY_HEAP_HARD_LIMIT: number;
+export declare function estimateResidentChars(messages: Message[]): number;
+export declare function estimateToolPayloadChars(messages: Message[]): number;
+export declare function countUserTurns(messages: Message[]): number;
+export declare function getCurrentHeapUsed(): number;

package/dist/agent/resident-history.js

@@ -0,0 +1,61 @@
+/**
+ * Resident-history size estimation and the cliff-edge guards that decide when
+ * in-memory history is compacted (see docs/harness-thinning.md, wave 2).
+ */
+import { isRealUserMessage } from "../context/compact.js";
+export const RESIDENT_HISTORY_KEEP_RECENT_TURNS = 3;
+export const RESIDENT_HISTORY_HEAP_HARD_LIMIT = 768 * 1024 * 1024;
+export function estimateResidentChars(messages) {
+    let total = 0;
+    for (const message of messages) {
+        switch (message.role) {
+            case "system":
+            case "meta":
+                total += message.content.length;
+                break;
+            case "tool":
+                total += message.content.length + message.toolCallId.length;
+                break;
+            case "assistant":
+                total += message.content.length + (message.reasoning?.length ?? 0);
+                total += message.toolCalls?.reduce((sum, toolCall) => sum + toolCall.id.length + toolCall.name.length + toolCall.arguments.length, 0) ?? 0;
+                break;
+            case "user":
+                if (typeof message.content === "string") {
+                    total += message.content.length;
+                }
+                else {
+                    total += message.content.reduce((sum, part) => {
+                        if (part.type === "text") {
+                            return sum + part.text.length;
+                        }
+                        return sum + part.image_url.url.length;
+                    }, 0);
+                }
+                break;
+        }
+    }
+    return total;
+}
+export function estimateToolPayloadChars(messages) {
+    return messages.reduce((sum, message) => {
+        if (message.role !== "tool") {
+            return sum;
+        }
+        return sum + message.content.length;
+    }, 0);
+}
+export function countUserTurns(messages) {
+    // Real user turns only: projected reminders and summary envelopes are
+    // user-ROLE but not user TURNS — counting them used to shrink the keep
+    // window and fire compaction almost every turn.
+    return messages.reduce((count, message) => count + (isRealUserMessage(message) ? 1 : 0), 0);
+}
+export function getCurrentHeapUsed() {
+    try {
+        return process.memoryUsage().heapUsed;
+    }
+    catch {
+        return 0;
+    }
+}