tau-all-agent 0.2.0 → 0.3.1

package/extensions/insights.ts

@@ -18,6 +18,7 @@ import {
   matchesKey,
   truncateToWidth,
   type Component,
+  type KeybindingsManager,
   type TUI,
   visibleWidth,
   wrapTextWithAnsi,
@@ -43,7 +44,9 @@ const REDUCED_TRANSCRIPT_HEAD_CHARS = 12_000;
 const REDUCED_TRANSCRIPT_TAIL_CHARS = 12_000;
 const REDUCED_TRANSCRIPT_MAX_CHARS = FULL_TRANSCRIPT_MAX_CHARS;
 
-const MIN_REPORT_WIDTH = 42; // Existing 40-column box plus its outer margin.
+const MIN_REPORT_WIDTH = 42;
+const REPORT_CHROME_ROWS = 6;
+const MIN_REPORT_ROWS = REPORT_CHROME_ROWS + 3; // Two overlay margins and one reading row.
 
 const AGENT_ROOT = getAgentDir();
 const CACHE_ROOT = path.join(AGENT_ROOT, "insights");
@@ -309,8 +312,6 @@ class InsightsReportComponent implements Component {
   private readonly markdown: Markdown;
   private scrollOffset = 0;
   private renderWidth?: number;
-  private cachedWidth?: number;
-  private cachedLines?: string[];
   private cachedBodyWidth?: number;
   private cachedBodyLines?: string[];
 
@@ -318,14 +319,13 @@ class InsightsReportComponent implements Component {
     private readonly result: InsightsResult,
     private readonly tui: TUI,
     private readonly theme: Theme,
+    private readonly keybindings: KeybindingsManager,
     private readonly onDone: () => void,
   ) {
     this.markdown = new Markdown(result.reportMarkdown, 0, 0, getMarkdownTheme());
   }
 
   invalidate(): void {
-    this.cachedWidth = undefined;
-    this.cachedLines = undefined;
     this.cachedBodyWidth = undefined;
     this.cachedBodyLines = undefined;
     this.markdown.invalidate();
@@ -343,52 +343,60 @@ class InsightsReportComponent implements Component {
     }
 
     const width = this.renderWidth ?? this.tui.terminal.columns;
-    if (width < MIN_REPORT_WIDTH) return;
+    if (width < MIN_REPORT_WIDTH || this.tui.terminal.rows < MIN_REPORT_ROWS) return;
 
     const bodyHeight = this.getBodyHeight();
-    const boxWidth = this.getBoxWidth(width);
+    const boxWidth = width;
     const bodyLines = this.getBodyLines(this.getContentWidth(boxWidth));
     const maxScroll = Math.max(0, bodyLines.length - bodyHeight);
 
-    if (matchesKey(data, Key.up) || data.toLowerCase() === "k") {
-      this.scrollOffset = Math.max(0, this.scrollOffset - 1);
-    } else if (matchesKey(data, Key.down) || data.toLowerCase() === "j") {
-      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + 1);
-    } else if (matchesKey(data, Key.pageUp)) {
-      this.scrollOffset = Math.max(0, this.scrollOffset - Math.max(4, bodyHeight - 2));
-    } else if (matchesKey(data, Key.pageDown)) {
-      this.scrollOffset = Math.min(maxScroll, this.scrollOffset + Math.max(4, bodyHeight - 2));
-    } else if (matchesKey(data, Key.home)) {
+    this.scrollOffset = clamp(this.scrollOffset, 0, maxScroll);
+    const kb = this.keybindings;
+    if (kb.matches(data, "tui.altScreen.pageUp")) {
+      this.scrollOffset -= bodyHeight;
+    } else if (kb.matches(data, "tui.altScreen.pageDown")) {
+      this.scrollOffset += bodyHeight;
+    } else if (kb.matches(data, "tui.altScreen.halfPageUp")) {
+      this.scrollOffset -= Math.max(1, Math.floor(bodyHeight / 2));
+    } else if (kb.matches(data, "tui.altScreen.halfPageDown")) {
+      this.scrollOffset += Math.max(1, Math.floor(bodyHeight / 2));
+    } else if (kb.matches(data, "tui.altScreen.top")) {
       this.scrollOffset = 0;
-    } else if (matchesKey(data, Key.end)) {
+    } else if (kb.matches(data, "tui.altScreen.bottom")) {
       this.scrollOffset = maxScroll;
+    } else if (kb.matches(data, "tui.altScreen.lineUp")) {
+      this.scrollOffset -= 1;
+    } else if (kb.matches(data, "tui.altScreen.lineDown")) {
+      this.scrollOffset += 1;
+    } else if (matchesKey(data, Key.up) || data.toLowerCase() === "k") {
+      this.scrollOffset -= 1;
+    } else if (matchesKey(data, Key.down) || data.toLowerCase() === "j") {
+      this.scrollOffset += 1;
     } else {
       return;
     }
 
-    this.invalidateFrame();
+    this.scrollOffset = clamp(this.scrollOffset, 0, maxScroll);
     this.tui.requestRender();
   }
 
   render(width: number): string[] {
     this.renderWidth = width;
-    if (width < MIN_REPORT_WIDTH) {
-      if (width < 1) return [];
+    if (width < 1 || this.tui.terminal.rows <= 2) return [];
+    if (width < MIN_REPORT_WIDTH || this.tui.terminal.rows < MIN_REPORT_ROWS) {
       return [
         truncateToWidth(
-          this.theme.fg("muted", `Resize to ${MIN_REPORT_WIDTH}+ columns to view insights.`),
+          this.theme.fg(
+            "muted",
+            `Esc close · Resize to ${MIN_REPORT_WIDTH + 2}+ columns, ${MIN_REPORT_ROWS}+ rows.`,
+          ),
           width,
           "",
         ),
-        truncateToWidth(this.theme.fg("dim", "Enter/Esc close"), width, ""),
       ];
     }
 
-    if (this.cachedWidth === width && this.cachedLines) {
-      return this.cachedLines;
-    }
-
-    const boxWidth = this.getBoxWidth(width);
+    const boxWidth = width;
     const contentWidth = this.getContentWidth(boxWidth);
     const bodyLines = this.getBodyLines(contentWidth);
     const bodyHeight = this.getBodyHeight();
@@ -396,20 +404,9 @@ class InsightsReportComponent implements Component {
     this.scrollOffset = clamp(this.scrollOffset, 0, maxScroll);
 
     const title = this.theme.fg("accent", this.theme.bold("Insights"));
-    const metadata = [
-      `${this.result.aggregate.scope} scope · ${formatCount(this.result.aggregate.sessionsAnalyzed)} analyzed · ${formatCount(this.result.aggregate.sessionsWithFacets)} classified`,
-      `${this.result.modelId ?? "current model"} · generated ${formatIsoShort(this.result.generatedAt)}`,
-    ];
-
     const lines: string[] = [];
     lines.push(this.borderLine("╭", "╮", boxWidth));
     lines.push(this.boxLine(title, boxWidth));
-    for (const line of metadata) {
-      for (const wrapped of wrapTextWithAnsi(this.theme.fg("muted", line), contentWidth)) {
-        lines.push(this.boxLine(wrapped, boxWidth));
-      }
-    }
-    lines.push(this.separatorLine(boxWidth));
 
     const visibleBody = bodyLines.slice(this.scrollOffset, this.scrollOffset + bodyHeight);
     for (const line of visibleBody) {
@@ -421,22 +418,30 @@ class InsightsReportComponent implements Component {
 
     lines.push(this.separatorLine(boxWidth));
     const scrollText = `${formatCount(Math.min(bodyLines.length, this.scrollOffset + 1))}-${formatCount(Math.min(bodyLines.length, this.scrollOffset + visibleBody.length))}/${formatCount(bodyLines.length)}`;
-    const controls = `${this.theme.fg("dim", "↑↓ scroll · PgUp/PgDn jump · Home/End · Enter/Esc close")} ${this.theme.fg("muted", scrollText)}`;
-    lines.push(this.boxLine(truncateToWidth(controls, contentWidth), boxWidth));
+    const navigation = [
+      ["pageUp", "pageDown", "page"],
+      ["top", "bottom", "ends"],
+    ] as const;
+    const hints = [
+      "↑↓/j/k scroll",
+      ...navigation.flatMap(([up, down, label]) => {
+        const keys = [up, down].map((action) =>
+          this.keybindings
+            .getKeys(`tui.altScreen.${action}`)
+            .find((key) => !["enter", "escape", "ctrl+c", "q"].includes(key)),
+        );
+        return keys.some(Boolean) ? [`${keys.map((key) => key ?? "—").join("/")} ${label}`] : [];
+      }),
+    ];
+    lines.push(this.boxLine(this.theme.fg("dim", hints.join(" · ")), boxWidth));
+    lines.push(this.boxLine(this.theme.fg("dim", `Enter/Esc close · ${scrollText}`), boxWidth));
     lines.push(this.borderLine("╰", "╯", boxWidth));
 
-    this.cachedWidth = width;
-    this.cachedLines = lines;
     return lines;
   }
 
   private getBodyHeight(): number {
-    return Math.max(10, this.tui.terminal.rows - 10);
-  }
-
-  private invalidateFrame(): void {
-    this.cachedWidth = undefined;
-    this.cachedLines = undefined;
+    return this.tui.terminal.rows - 2 - REPORT_CHROME_ROWS;
   }
 
   private getBodyLines(contentWidth: number): string[] {
@@ -444,16 +449,20 @@ class InsightsReportComponent implements Component {
       return this.cachedBodyLines;
     }
 
-    const lines = this.markdown.render(contentWidth);
+    const metadata = [
+      `${this.result.aggregate.scope} scope · ${formatCount(this.result.aggregate.sessionsAnalyzed)} analyzed · ${formatCount(this.result.aggregate.sessionsWithFacets)} classified`,
+      `${this.result.modelId ?? "current model"} · generated ${formatIsoShort(this.result.generatedAt)}`,
+    ];
+    const lines = [
+      ...metadata.flatMap((line) => wrapTextWithAnsi(this.theme.fg("muted", line), contentWidth)),
+      "",
+      ...this.markdown.render(contentWidth),
+    ];
     this.cachedBodyWidth = contentWidth;
     this.cachedBodyLines = lines;
     return lines;
   }
 
-  private getBoxWidth(width: number): number {
-    return Math.min(width - 2, 140);
-  }
-
   private getContentWidth(boxWidth: number): number {
     return boxWidth - 4;
   }
@@ -586,9 +595,14 @@ async function runInsightsCommand(
     ctx.ui.notify(`Failed to save insights report: ${message}`, "warning");
   }
 
-  await ctx.ui.custom<void>((tui, theme, _kb, done) => {
-    return new InsightsReportComponent(result, tui, theme, done);
-  });
+  await ctx.ui.custom<void>(
+    (tui, theme, keybindings, done) =>
+      new InsightsReportComponent(result, tui, theme, keybindings, done),
+    {
+      overlay: true,
+      overlayOptions: { anchor: "bottom-center", width: "100%", maxHeight: "100%", margin: 1 },
+    },
+  );
 
   if (reportPath) {
     ctx.ui.notify(`Insights report saved to ${reportPath}`, "info");

package/extensions/loop.ts

@@ -11,21 +11,19 @@ import type { Api, Model, UserMessage } from "@earendil-works/pi-ai";
 import {
   compact,
   defineTool,
-  DynamicBorder,
   type ExtensionAPI,
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { Container, type SelectItem, SelectList, Text } from "@earendil-works/pi-tui";
 
 const LOOP_PRESETS = [
-  { value: "tests", label: "Until tests pass", description: "" },
-  { value: "custom", label: "Until custom condition", description: "" },
-  { value: "self", label: "Self driven (agent decides)", description: "" },
+  { value: "tests", label: "Until tests pass" },
+  { value: "custom", label: "Until custom condition" },
+  { value: "self", label: "Self driven (agent decides)" },
 ] as const;
 
 const LOOP_STATE_ENTRY = "loop-state";
-const OPENAI_FAST_MODEL_ID = "gpt-5.6-luna";
-const ANTHROPIC_FAST_MODEL_ID = "claude-haiku-4-5";
+const OPENAI_FAST_MODEL_ID = "gpt-6-luna";
+const ANTHROPIC_FAST_MODEL_ID = "claude-haiku-5-5";
 
 const SUMMARY_SYSTEM_PROMPT = `You summarize loop breakout conditions for a status widget.
 Return a concise phrase (max 6 words) that says when the loop should stop.
@@ -315,49 +313,13 @@ export default function loopExtension(pi: ExtensionAPI): void {
   }
 
   async function showLoopSelector(ctx: ExtensionContext): Promise<LoopStateData | null> {
-    const items: SelectItem[] = LOOP_PRESETS.map((preset) => ({
-      value: preset.value,
-      label: preset.label,
-      description: preset.description,
-    }));
-
-    const selection = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
-      const container = new Container();
-      container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
-      container.addChild(new Text(theme.fg("accent", theme.bold("Select a loop preset"))));
-
-      const selectList = new SelectList(items, Math.min(items.length, 10), {
-        selectedPrefix: (text) => theme.fg("accent", text),
-        selectedText: (text) => theme.fg("accent", text),
-        description: (text) => theme.fg("muted", text),
-        scrollInfo: (text) => theme.fg("dim", text),
-        noMatch: (text) => theme.fg("warning", text),
-      });
-
-      selectList.onSelect = (item) => done(item.value);
-      selectList.onCancel = () => done(null);
-
-      container.addChild(selectList);
-      container.addChild(new Text(theme.fg("dim", "Press enter to confirm or esc to cancel")));
-      container.addChild(new DynamicBorder((str) => theme.fg("accent", str)));
-
-      return {
-        render(width: number) {
-          return container.render(width);
-        },
-        invalidate() {
-          container.invalidate();
-        },
-        handleInput(data: string) {
-          selectList.handleInput(data);
-          tui.requestRender();
-        },
-      };
-    });
-
-    if (!selection) return null;
+    const selection = await ctx.ui.select(
+      "Select a loop preset",
+      LOOP_PRESETS.map((preset) => preset.label),
+    );
+    const preset = LOOP_PRESETS.find((preset) => preset.label === selection);
 
-    switch (selection) {
+    switch (preset?.value) {
       case "tests":
         return { active: true, mode: "tests", prompt: buildPrompt("tests") };
       case "self":
@@ -492,16 +454,16 @@ export default function loopExtension(pi: ExtensionAPI): void {
     )?.stopReason;
   });
 
-  pi.on("agent_settled", async (_event, ctx) => {
+  pi.on("agent_settled", async (event, ctx) => {
     if (!loopState.active) return;
 
-    if (lastAssistantStopReason === "error") {
+    if (lastAssistantStopReason === "error" && !event.aborted) {
       await clearLoopState(ctx);
       ctx.ui.notify("Loop stopped after an agent error", "error");
       return;
     }
 
-    if (lastAssistantStopReason === "aborted") {
+    if (event.aborted || lastAssistantStopReason === "aborted") {
       const generation = loopGeneration;
       const confirm =
         !ctx.hasUI ||

package/extensions/memory.ts

@@ -233,13 +233,14 @@ async function toolDream(
   cwd: string,
   ctx: ExtensionContext,
   reason?: string,
+  signal = ctx.signal,
 ): Promise<{
   content: Array<{ type: "text"; text: string }>;
   details: DreamResult;
   usage?: Usage;
 }> {
   try {
-    const execution = await runMemoryDream(cwd, ctx, reason);
+    const execution = await runMemoryDream(cwd, ctx, reason, signal);
     return {
       content: [{ type: "text", text: execution.result.summary }],
       details: execution.result,
@@ -331,10 +332,11 @@ async function updateCoreBlock(
   cwd: string,
   name: MemoryBlockName,
   content: string,
+  signal?: AbortSignal,
 ): Promise<{ totalLines: number; totalChars: number }> {
   const paths = getMemoryPaths(cwd);
   return withMemoryMutationQueue(Object.values(paths.coreFiles), async () =>
-    updateCoreBlockUnsafe(cwd, name, content),
+    updateCoreBlockUnsafe(cwd, name, content, signal),
   );
 }
 
@@ -348,18 +350,23 @@ async function appendMemoryLog(
     supersedes?: string[];
     invalidates?: string[];
   },
+  signal?: AbortSignal,
 ): Promise<LogEntry> {
   const paths = getMemoryPaths(cwd);
   return withMemoryMutationQueue([paths.logFile, paths.stateFile], async () =>
-    appendMemoryLogUnsafe(cwd, {
-      timestamp: nowIso(),
-      type: entry.type,
-      importance: entry.importance ?? DEFAULT_LOG_IMPORTANCE,
-      title: normalizeTitle(entry.title) || "Memory log entry",
-      body: normalizeMarkdownBlock(entry.body),
-      supersedes: normalizeMemoryReferences(entry.supersedes),
-      invalidates: normalizeMemoryReferences(entry.invalidates),
-    }),
+    appendMemoryLogUnsafe(
+      cwd,
+      {
+        timestamp: nowIso(),
+        type: entry.type,
+        importance: entry.importance ?? DEFAULT_LOG_IMPORTANCE,
+        title: normalizeTitle(entry.title) || "Memory log entry",
+        body: normalizeMarkdownBlock(entry.body),
+        supersedes: normalizeMemoryReferences(entry.supersedes),
+        invalidates: normalizeMemoryReferences(entry.invalidates),
+      },
+      signal,
+    ),
   );
 }
 
@@ -398,6 +405,7 @@ async function runMemoryDream(
   cwd: string,
   ctx: ExtensionContext,
   reason?: string,
+  signal = ctx.signal,
 ): Promise<DreamExecution> {
   const paths = getMemoryPaths(cwd);
   const lockPaths = [
@@ -409,6 +417,7 @@ async function runMemoryDream(
   ];
 
   const snapshot = await withMemoryMutationQueue(lockPaths, async () => {
+    signal?.throwIfAborted();
     ensureMemoryInitialized(await pathExists(paths.memoryRoot));
 
     const replay = await collectDreamReplay(cwd);
@@ -419,6 +428,7 @@ async function runMemoryDream(
     };
   });
 
+  signal?.throwIfAborted();
   if (!shouldRunDream(snapshot.replay, reason)) {
     const summary = "Memory dream: nothing to consolidate.";
     notify(ctx, summary, "info");
@@ -436,15 +446,17 @@ async function runMemoryDream(
   }
 
   const selection = await selectDreamModel(ctx);
+  signal?.throwIfAborted();
   const response = await ctx.modelRegistry.complete(
     selection.model,
     {
       systemPrompt: MEMORY_DREAM_SYSTEM_PROMPT,
       messages: [buildDreamUserMessage(snapshot.replay, reason)],
     },
-    { signal: ctx.signal },
+    { signal },
   );
 
+  signal?.throwIfAborted();
   if (response.stopReason === "aborted") {
     throw new Error("Memory dream aborted.");
   }
@@ -481,6 +493,7 @@ async function runMemoryDream(
   }
 
   const result = await withMemoryMutationQueue(lockPaths, async () => {
+    signal?.throwIfAborted();
     ensureMemoryInitialized(await pathExists(paths.memoryRoot));
 
     const currentReplay = await collectDreamReplay(cwd);
@@ -488,7 +501,9 @@ async function runMemoryDream(
       throw new Error("Memory changed while dream was running. Retry /memory dream.");
     }
 
-    await writeCoreBlocksUnsafe(cwd, finalBlocks);
+    // Once the core writes start, finish the whole commit without cancellation checkpoints.
+    signal?.throwIfAborted();
+    await writeCoreBlocksUnsafe(cwd, finalBlocks, signal);
 
     const previousState = await readStateUnsafe(cwd);
     const dreamTimestamp = nowIso();
@@ -650,7 +665,9 @@ async function updateCoreBlockUnsafe(
   cwd: string,
   name: MemoryBlockName,
   content: string,
+  signal?: AbortSignal,
 ): Promise<{ totalLines: number; totalChars: number }> {
+  signal?.throwIfAborted();
   const paths = getMemoryPaths(cwd);
   ensureMemoryInitialized(await pathExists(paths.memoryRoot));
 
@@ -673,12 +690,19 @@ async function updateCoreBlockUnsafe(
     );
   }
 
+  signal?.throwIfAborted();
   await ensureDir(paths.coreDir);
+  signal?.throwIfAborted();
   await fs.writeFile(paths.coreFiles[name], nextBlocks[name], "utf8");
   return { totalLines, totalChars };
 }
 
-async function appendMemoryLogUnsafe(cwd: string, entry: LogEntry): Promise<LogEntry> {
+async function appendMemoryLogUnsafe(
+  cwd: string,
+  entry: LogEntry,
+  signal?: AbortSignal,
+): Promise<LogEntry> {
+  signal?.throwIfAborted();
   const paths = getMemoryPaths(cwd);
   ensureMemoryInitialized(await pathExists(paths.memoryRoot));
 
@@ -688,6 +712,7 @@ async function appendMemoryLogUnsafe(cwd: string, entry: LogEntry): Promise<LogE
     renderLogEntryBody(entry),
   ].join("\n");
 
+  signal?.throwIfAborted();
   await ensureDir(path.dirname(paths.logFile));
   let writeFreshLog = false;
   try {
@@ -700,6 +725,8 @@ async function appendMemoryLogUnsafe(cwd: string, entry: LogEntry): Promise<LogE
     }
   }
 
+  // Keep the log append and its state update together once mutation starts.
+  signal?.throwIfAborted();
   if (writeFreshLog) {
     await fs.writeFile(paths.logFile, `# Memory log\n\n${chunk}\n`, "utf8");
   } else {
@@ -739,9 +766,14 @@ async function collectDreamReplay(cwd: string): Promise<DreamReplay> {
   };
 }
 
-async function writeCoreBlocksUnsafe(cwd: string, blocks: CoreBlocks): Promise<void> {
+async function writeCoreBlocksUnsafe(
+  cwd: string,
+  blocks: CoreBlocks,
+  signal?: AbortSignal,
+): Promise<void> {
   const paths = getMemoryPaths(cwd);
   await ensureDir(paths.coreDir);
+  signal?.throwIfAborted();
 
   await Promise.all(
     CORE_BLOCK_NAMES.map((name) =>
@@ -1077,7 +1109,6 @@ function validatePendingDispositions(
 
 function buildMemoryPrompt(readme: string, blocks: CoreBlocks, researchFiles: string[]): string {
   const sections = [
-    "<repo_memory>",
     "Use repo memory for continuity across sessions in this repo.",
     "Source-of-truth memory rules:",
     "<memory-readme>",
@@ -1095,7 +1126,6 @@ function buildMemoryPrompt(readme: string, blocks: CoreBlocks, researchFiles: st
     `### focus.md\n${blocks.focus.trimEnd() || "(empty)"}`,
     "",
     `### pending.md\n${blocks.pending.trimEnd() || "(empty)"}`,
-    "</repo_memory>",
   ];
   return sections.join("\n");
 }
@@ -1785,8 +1815,8 @@ export default function memoryExtension(pi: ExtensionAPI): void {
           `If memory_update_block would exceed the ${CORE_LINE_CAP}-line or ${CORE_CHAR_CAP}-character core cap, use memory_dream for consolidation. Do not discard unresolved work to fit.`,
         ],
         parameters: MEMORY_UPDATE_BLOCK_PARAMS,
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-          const result = await updateCoreBlock(ctx.cwd, params.name, params.content);
+        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+          const result = await updateCoreBlock(ctx.cwd, params.name, params.content, signal);
 
           return {
             content: [
@@ -1817,15 +1847,19 @@ export default function memoryExtension(pi: ExtensionAPI): void {
           "The memory log is append-only. Do not rewrite or truncate older entries.",
         ],
         parameters: MEMORY_APPEND_LOG_PARAMS,
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-          const entry = await appendMemoryLog(ctx.cwd, {
-            type: params.type,
-            title: params.title,
-            body: params.body,
-            importance: params.importance,
-            supersedes: params.supersedes,
-            invalidates: params.invalidates,
-          });
+        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+          const entry = await appendMemoryLog(
+            ctx.cwd,
+            {
+              type: params.type,
+              title: params.title,
+              body: params.body,
+              importance: params.importance,
+              supersedes: params.supersedes,
+              invalidates: params.invalidates,
+            },
+            signal,
+          );
 
           return {
             content: [
@@ -1852,8 +1886,8 @@ export default function memoryExtension(pi: ExtensionAPI): void {
           "Use memory_dream when logs have accumulated, core needs compression, or recent compaction context should be folded into memory.",
         ],
         parameters: MEMORY_DREAM_PARAMS,
-        async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
-          return toolDream(ctx.cwd, ctx, params.reason);
+        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+          return toolDream(ctx.cwd, ctx, params.reason, signal);
         },
       }),
     );
@@ -1910,9 +1944,7 @@ export default function memoryExtension(pi: ExtensionAPI): void {
         return;
       }
 
-      return {
-        systemPrompt: `${event.systemPrompt}\n\n${prompt}`,
-      };
+      event.systemPromptOptions.sections.repo_memory = prompt;
     } catch (error) {
       if (error instanceof MemoryReadmeMissingError) {
         notify(ctx, `Repo memory disabled: ${error.message}`, "warning");

package/extensions/notify.ts

@@ -3,7 +3,7 @@
  *
  * Sends native terminal notifications when Pi is waiting for input.
  * - Agent finished and ready for the next prompt
- * - Extension prompt is waiting for a question/confirmation answer
+ * - Standard extension dialogs are waiting for input (custom UI stays silent)
  * Supports multiple terminal protocols:
  * - OSC 9: Ghostty, Supacode, iTerm2, WezTerm
  * - OSC 99: Kitty
@@ -114,9 +114,11 @@ export default function (pi: ExtensionAPI) {
     currentSessionKey = getSessionKey(ctx);
   });
 
-  pi.on("ui_prompt_start", async () => {
+  pi.on("ui_prompt_start", async (event) => {
     promptPending = true;
-    notify("Pi", "Waiting for input");
+    if (event.kind !== "custom") {
+      notify("Pi", "Waiting for input");
+    }
   });
 
   pi.on("ui_prompt_end", async () => {