@bubblebrain-ai/bubble 0.0.6 → 0.0.7

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

@@ -3,21 +3,16 @@ 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 mutationVersion;
     private reminderQueue;
     private warnedFamilies;
+    private warnedSignatures;
     private softTotalWarned;
     private softSearchWarned;
     private softReadWarned;
@@ -29,16 +24,13 @@ export declare class ExecutionGovernor {
         readSteps: number;
         searchFrozen: boolean;
         explorationFrozen: boolean;
-        phase: WorkPhase;
+        phase: "observe";
     };
     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 hasCurrentMutationObservation;
+    private warnOnce;
     private maybeWarnOnSoftBudgets;
 }
-export {};

package/dist/agent/execution-governor.js

@@ -1,118 +1,84 @@
 import { analyzeToolIntent } from "./tool-intent.js";
-import { buildExplorationFreezeReminder, buildInvestigationReminder, buildLoopWarningReminder, buildSearchFreezeReminder } from "../prompt/reminders.js";
+import { buildInvestigationReminder, buildLoopWarningReminder } from "../prompt/reminders.js";
 const BUDGETS = {
     security_investigation: {
         softTotalSteps: 14,
         softSearchSteps: 6,
         softReadSteps: 8,
-        maxExplorationStepsWithoutWrite: 12,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 2,
-        maxNoProgressFamilyRepeats: 3,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 2,
     },
     code_search: {
         softTotalSteps: 16,
         softSearchSteps: 8,
         softReadSteps: 10,
-        maxExplorationStepsWithoutWrite: 14,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 3,
     },
     debugging: {
         softTotalSteps: 18,
         softSearchSteps: 8,
         softReadSteps: 7,
-        maxExplorationStepsWithoutWrite: 10,
-        maxNoProgressReadExactRepeats: 1,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 1,
         warningFamilyRepeats: 3,
     },
     implementation: {
         softTotalSteps: 18,
         softSearchSteps: 8,
         softReadSteps: 6,
-        maxExplorationStepsWithoutWrite: 8,
-        maxNoProgressReadExactRepeats: 1,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 1,
         warningFamilyRepeats: 3,
     },
     code_review: {
         softTotalSteps: 14,
         softSearchSteps: 6,
         softReadSteps: 8,
-        maxExplorationStepsWithoutWrite: 12,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 3,
     },
     code_explanation: {
         softTotalSteps: 12,
         softSearchSteps: 6,
         softReadSteps: 8,
-        maxExplorationStepsWithoutWrite: 12,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 3,
     },
     repo_orientation: {
         softTotalSteps: 12,
         softSearchSteps: 6,
         softReadSteps: 8,
-        maxExplorationStepsWithoutWrite: 12,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 3,
     },
     product_discussion: {
         softTotalSteps: 10,
         softSearchSteps: 4,
         softReadSteps: 4,
-        maxExplorationStepsWithoutWrite: 8,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 2,
-        maxNoProgressFamilyRepeats: 3,
+        warningExactRepeats: 2,
         warningFamilyRepeats: 2,
     },
     general: {
         softTotalSteps: 18,
         softSearchSteps: 8,
         softReadSteps: 10,
-        maxExplorationStepsWithoutWrite: 14,
-        maxNoProgressReadExactRepeats: 2,
-        maxNoProgressExactRepeats: 3,
-        maxNoProgressFamilyRepeats: 4,
+        warningExactRepeats: 2,
         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", "spawn_agent", "wait_agent", "send_input", "tool_search"]);
 export class ExecutionGovernor {
-    taskType;
     budget;
     history = [];
     totalSteps = 0;
     searchSteps = 0;
     readSteps = 0;
-    explorationStepsWithoutWrite = 0;
-    searchFrozen = false;
-    explorationFrozen = false;
-    phase = "explore";
-    codeChanged = false;
+    mutationVersion = 0;
     reminderQueue = [];
     warnedFamilies = new Set();
+    warnedSignatures = new Set();
     softTotalWarned = false;
     softSearchWarned = false;
     softReadWarned = false;
     constructor(taskType) {
-        this.taskType = taskType;
         this.budget = BUDGETS[taskType];
         if (taskType === "security_investigation") {
             this.reminderQueue.push(buildInvestigationReminder());
@@ -128,62 +94,33 @@ export class ExecutionGovernor {
             totalSteps: this.totalSteps,
             searchSteps: this.searchSteps,
             readSteps: this.readSteps,
-            searchFrozen: this.searchFrozen,
-            explorationFrozen: this.explorationFrozen,
-            phase: this.phase,
+            searchFrozen: false,
+            explorationFrozen: false,
+            phase: "observe",
         };
     }
     filterToolDefinitions(toolDefinitions) {
-        let filtered = toolDefinitions;
-        if (this.explorationFrozen) {
-            filtered = filtered.filter((tool) => !EXPLORATION_TOOLS_DISABLED.has(tool.name));
-        }
-        else if (this.searchFrozen) {
-            filtered = filtered.filter((tool) => !SEARCH_TOOLS_DISABLED.has(tool.name));
-        }
-        return filtered;
+        return toolDefinitions;
     }
     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") {
+        if (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 (signature && this.hasCurrentMutationObservation((entry) => entry.signature === signature)) {
+                this.warnOnce(`read:${signature}`, "This exact file range was already read since the last successful edit/write. If the content is still available and nothing changed, use the prior result; otherwise it is okay to re-read to recover context or verify a change.");
             }
         }
         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.", "search"),
-                };
-            }
             const signature = intent.search?.signature;
             const familyKey = intent.search?.familyKey;
-            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.", "search"),
-                };
+            if (signature && this.trailingNoProgressCount((entry) => entry.signature === signature) >= this.budget.warningExactRepeats) {
+                this.warnOnce(`search:${signature}`, "This search is very similar to one you already ran and it did not produce new evidence. Change the query/path, follow a concrete lead, or summarize the strongest findings.");
             }
             if (familyKey) {
                 const familyNoProgress = this.trailingNoProgressCount((entry) => entry.familyKey === familyKey);
-                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.", "search"),
-                    };
-                }
                 if (familyNoProgress >= this.budget.warningFamilyRepeats && !this.warnedFamilies.has(familyKey)) {
                     this.warnedFamilies.add(familyKey);
-                    this.reminderQueue.push(buildLoopWarningReminder("Repeated searches are yielding little new evidence. Change your hypothesis, narrow the path, or summarize current findings instead of repeating variants."));
+                    this.reminderQueue.push(buildLoopWarningReminder("Repeated searches in the same family are yielding little new evidence. Change your hypothesis, narrow the path, follow a specific file lead, or summarize current findings instead of repeating variants."));
                 }
             }
         }
@@ -194,9 +131,6 @@ export class ExecutionGovernor {
         if (intent.family === "read") {
             this.readSteps += 1;
         }
-        if (isExplorationIntent(intent) && !this.codeChanged) {
-            this.explorationStepsWithoutWrite += 1;
-        }
         this.maybeWarnOnSoftBudgets(intent.family === "search", intent.family === "read");
         return {};
     }
@@ -211,23 +145,19 @@ export class ExecutionGovernor {
             signature: intent.search?.signature ?? intent.read?.signature,
             familyKey: intent.search?.familyKey ?? intent.read?.familyKey,
             progress,
+            mutationVersion: this.mutationVersion,
         });
         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.`);
+            this.mutationVersion += 1;
         }
     }
     trailingNoProgressCount(predicate) {
         let count = 0;
         for (let index = this.history.length - 1; index >= 0; index--) {
             const entry = this.history[index];
+            if (entry.mutationVersion !== this.mutationVersion) {
+                break;
+            }
             if (!predicate(entry)) {
                 break;
             }
@@ -238,27 +168,15 @@ export class ExecutionGovernor {
         }
         return count;
     }
-    freezeSearch(reason) {
-        if (this.searchFrozen) {
-            return;
-        }
-        this.searchFrozen = true;
-        this.reminderQueue.push(buildSearchFreezeReminder(reason));
+    hasCurrentMutationObservation(predicate) {
+        return this.history.some((entry) => entry.mutationVersion === this.mutationVersion && predicate(entry));
     }
-    enterModifyPhase(reason) {
-        if (this.explorationFrozen) {
+    warnOnce(key, reason) {
+        if (this.warnedSignatures.has(key)) {
             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);
+        this.warnedSignatures.add(key);
+        this.reminderQueue.push(buildLoopWarningReminder(reason));
     }
     maybeWarnOnSoftBudgets(isSearchStep, isReadStep) {
         if (!this.softTotalWarned && this.totalSteps >= this.budget.softTotalSteps) {
@@ -275,28 +193,12 @@ export class ExecutionGovernor {
         }
     }
 }
-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) {
     if (result.status === "blocked" || result.status === "timeout" || result.status === "command_error") {
         return false;
@@ -314,14 +216,3 @@ function inferProgress(intent, result) {
     }
     return !result.isError;
 }
-function blockedResult(content, status, reason, kind = "security") {
-    return {
-        content,
-        isError: true,
-        status,
-        metadata: {
-            kind,
-            reason,
-        },
-    };
-}

package/dist/main.js

@@ -125,9 +125,8 @@ async function main() {
         const { registry: slashRegistry } = await import("./slash-commands/index.js");
         slashRegistry.addDynamicSource(() => mcpManager.getPromptCommands());
     }
-    // Signal-based shutdown for Ctrl-C / kill. For /quit the command handler
-    // shuts MCP down directly — process.once("exit", ...)
-    // runs synchronously and can't await async work, so relying on it is a trap.
+    // Signal-based shutdown for Ctrl-C / kill. Normal /quit cleanup happens after
+    // the TUI renderer has been destroyed, avoiding native teardown races.
     const shutdownMcp = async () => {
         try {
             await mcpManager.shutdown();
@@ -261,6 +260,18 @@ async function main() {
         // Codex-style memory runs at startup over historical rollouts. Exit should
         // not perform an ad-hoc extraction of the just-finished session.
     };
+    const shutdownRuntime = async () => {
+        const results = await Promise.allSettled([
+            flushMemory(),
+            shutdownMcp(),
+            lspService.shutdown(),
+        ]);
+        for (const result of results) {
+            if (result.status === "rejected") {
+                // Shutdown is best-effort; never turn exit into a fatal error.
+            }
+        }
+    };
     const runMemoryCompaction = async () => formatMemoryStartupResult(await runMemoryStartupPipeline({
         cwd: args.cwd,
         complete: (messages, completeOptions) => agent.complete(messages, completeOptions),
@@ -296,49 +307,53 @@ async function main() {
             console.log(chalk.dim(`Resumed session: ${sessionManager.getSessionFile()}`));
         }
     }
-    // Print mode: single prompt, then exit
-    if (args.print || args.prompt) {
-        const prompt = args.prompt || (await readPipedStdin()) || "";
-        if (!prompt) {
-            console.error(chalk.red("Error: No prompt provided."));
-            process.exit(1);
-        }
-        for await (const event of agent.run(prompt, args.cwd)) {
-            if (event.type === "text_delta") {
-                process.stdout.write(event.content);
-            }
-            else if (event.type === "tool_start") {
-                console.log(chalk.cyan(`\n[Tool: ${event.name}]`));
+    try {
+        // Print mode: single prompt, then exit
+        if (args.print || args.prompt) {
+            const prompt = args.prompt || (await readPipedStdin()) || "";
+            if (!prompt) {
+                console.error(chalk.red("Error: No prompt provided."));
+                process.exit(1);
             }
-            else if (event.type === "tool_end") {
-                const color = event.result.isError ? chalk.red : chalk.dim;
-                console.log(color(`[Result: ${event.result.content.slice(0, 200)}${event.result.content.length > 200 ? "..." : ""}]`));
+            for await (const event of agent.run(prompt, args.cwd)) {
+                if (event.type === "text_delta") {
+                    process.stdout.write(event.content);
+                }
+                else if (event.type === "tool_start") {
+                    console.log(chalk.cyan(`\n[Tool: ${event.name}]`));
+                }
+                else if (event.type === "tool_end") {
+                    const color = event.result.isError ? chalk.red : chalk.dim;
+                    console.log(color(`[Result: ${event.result.content.slice(0, 200)}${event.result.content.length > 200 ? "..." : ""}]`));
+                }
             }
+            console.log();
+            return;
         }
-        console.log();
-        return;
+        // Interactive mode: OpenTUI uses Bun native FFI, matching opencode's TUI stack.
+        const { runTui } = await import("./tui/run.js");
+        await runTui(agent, args, {
+            sessionManager,
+            createProvider,
+            registry,
+            skillRegistry,
+            planHandlerRef,
+            approvalHandlerRef,
+            questionController,
+            bashAllowlist,
+            settingsManager,
+            lspService,
+            mcpManager,
+            theme: userConfig.getTheme(),
+            flushMemory,
+            runMemoryCompaction,
+            runMemorySummary,
+            runMemoryRefresh,
+        });
+    }
+    finally {
+        await shutdownRuntime();
     }
-    // Interactive mode: OpenTUI uses Bun native FFI, matching opencode's TUI stack.
-    const { runTui } = await import("./tui/run.js");
-    await runTui(agent, args, {
-        sessionManager,
-        createProvider,
-        registry,
-        skillRegistry,
-        planHandlerRef,
-        approvalHandlerRef,
-        questionController,
-        bashAllowlist,
-        settingsManager,
-        lspService,
-        mcpManager,
-        theme: userConfig.getTheme(),
-        flushMemory,
-        runMemoryCompaction,
-        runMemorySummary,
-        runMemoryRefresh,
-    });
-    await flushMemory();
 }
 async function readPipedStdin() {
     if (process.stdin.isTTY)

package/dist/orchestrator/default-hooks.js

@@ -36,18 +36,15 @@ export function createDefaultHooks() {
             },
             beforeModelCall(ctx) {
                 ctx.agent.compactResidentHistory();
-                if (ctx.state.governor) {
-                    ctx.toolEntries = ctx.state.governor.filterToolDefinitions(ctx.toolEntries);
-                }
                 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: ctx.state.governor.snapshot().searchFrozen,
+                        searchFrozen: false,
                     });
                     ctx.state.workflowPhase = phase;
                     const summary = formatCoverageSummary(coverage);
-                    const key = `${phase}:${ctx.state.evidenceTracker.key()}:${ctx.state.governor.snapshot().searchFrozen ? "1" : "0"}`;
+                    const key = `${phase}:${ctx.state.evidenceTracker.key()}:0`;
                     if (ctx.state.workflowKey !== key) {
                         ctx.state.workflowKey = key;
                         ctx.queueReminder(buildWorkflowPhaseReminder({
@@ -66,10 +63,7 @@ export function createDefaultHooks() {
             beforeToolCall(ctx) {
                 const arbitration = arbitrateToolCall(ctx.toolCall);
                 ctx.replaceToolCall({ ...arbitration.toolCall, ...(arbitration.note ? { arbiterNote: arbitration.note } : {}) });
-                const decision = ctx.state.governor?.beforeToolCall(ctx.toolCall);
-                if (decision?.blockedResult) {
-                    ctx.blockToolCall(decision.blockedResult);
-                }
+                ctx.state.governor?.beforeToolCall(ctx.toolCall);
             },
             afterToolCall(ctx) {
                 if (ctx.toolCall.arbiterNote) {
@@ -149,12 +143,6 @@ export function createDefaultHooks() {
                     ctx.requestTextOnlyTurn("Core security investigation evidence has been collected. Summarize the findings instead of continuing with more tool calls.");
                     return;
                 }
-                const allSearchResultsWereLowSignal = ctx.toolCalls.length > 0
-                    && ctx.toolCalls.every((toolCall) => ["glob", "grep", "bash", "web_search", "web_fetch"].includes(toolCall.name))
-                    && ctx.toolResults.every((result) => result.status === "no_match" || result.status === "blocked");
-                if (ctx.state.governor?.snapshot().searchFrozen && allSearchResultsWereLowSignal) {
-                    ctx.requestTextOnlyTurn("Search continuation has become low-yield. Summarize the strongest evidence already collected instead of continuing broad exploration.");
-                }
                 // Verification reminders intentionally removed. See afterToolCall.
             },
             afterTurn() {

package/dist/prompt/reminders.d.ts

@@ -41,7 +41,8 @@ export declare function buildTaskSummaryReminder(): string;
 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. Just prevents a 3rd / 4th re-read.
+ * 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;
 /**

package/dist/prompt/reminders.js

@@ -200,12 +200,13 @@ Stop retrying the same call. Pick one of:
 }
 /**
  * Fired the FIRST time the model re-reads a file it already read in this turn.
- * Soft — does not freeze the tool. Just prevents a 3rd / 4th re-read.
+ * 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 function buildRedundantReadReminder(path) {
     return wrapInSystemReminder(`
-You already read ${path} earlier in this turn. Use the content already in context rather than re-reading.
-Only re-read this path if a subsequent tool call (edit/write/bash) modified it since.
+You already read ${path} earlier in this turn. If that content is still available and nothing changed, rely on it rather than re-reading.
+It is okay to re-read when you need to recover pruned context, inspect a different range, or verify a later edit/write/bash change.
 `);
 }
 /**

package/dist/slash-commands/commands.js

@@ -274,24 +274,7 @@ const builtinSlashCommandEntries = [
         name: "quit",
         description: "Exit the application",
         async handler(args, ctx) {
-            // Shut MCP stdio children down first; their stdout/stderr listeners
-            // otherwise hold the Node event loop open even after ink unmounts.
-            try {
-                await ctx.mcpManager?.shutdown();
-            }
-            catch {
-                // ignore — we're quitting anyway
-            }
-            try {
-                await ctx.flushMemory?.();
-            }
-            catch {
-                // memory shutdown hooks are best-effort during exit
-            }
             ctx.exit();
-            // Belt-and-braces: if anything else (raw-mode tty handle, pending
-            // timer, etc.) still holds the loop, force-exit shortly after.
-            setTimeout(() => process.exit(0), 100).unref();
         },
     },
     {

package/package.json

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