tau-coding-agent 0.1.4 → 0.1.5

package/README.md

@@ -27,7 +27,7 @@ pi install -l npm:tau-coding-agent
 | `git-diff-stats`    | —                    | Status bar diff stats for local changes in the current repo.                                                              |
 | `git-pr-status`     | —                    | Status bar PR number and link for the current branch.                                                                     |
 | `insights`          | `/insights`          | Analyze Pi sessions and suggest reusable instructions, templates, skills, and extensions.                                 |
-| `interlude`         | `alt+x`              | Stash the current message draft, send one interlude message, then restore the draft.                                      |
+| `stash`             | `alt+x`              | Stash the current message draft, send one message, then restore it.                                                       |
 | `loop`              | `/loop`              | Repeat a prompt until the agent signals success.                                                                          |
 | `memory`            | `/memory`            | Opt-in project-local memory for learning and continuity across sessions.                                                  |
 | `notify`            | —                    | Terminal notification when the agent is waiting for input.                                                                |

package/extensions/answer.ts

@@ -10,13 +10,14 @@
  * 4. Submits the compiled answers when done
  */
 
-import { complete, type Model, type Api, type UserMessage } from "@earendil-works/pi-ai";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { BorderedLoader } from "@earendil-works/pi-coding-agent";
+import { complete } from "@earendil-works/pi-ai/compat";
+import type { Model, Api, UserMessage } from "@earendil-works/pi-ai";
+import { BorderedLoader, type ExtensionAPI, type Theme } from "@earendil-works/pi-coding-agent";
 import {
   type Component,
   Editor,
   type EditorTheme,
+  type Focusable,
   Key,
   matchesKey,
   truncateToWidth,
@@ -178,12 +179,13 @@ function parseExtractionResult(text: string): ExtractionResult | null {
 /**
  * Interactive Q&A component for answering extracted questions
  */
-class QnAComponent implements Component {
+class QnAComponent implements Component, Focusable {
   private questions: ExtractedQuestion[];
   private answers: string[];
   private currentIndex: number = 0;
   private editor: Editor;
   private tui: TUI;
+  private theme: Theme;
   private onDone: (result: string | null) => void;
   private showingConfirmation: boolean = false;
 
@@ -191,30 +193,38 @@ class QnAComponent implements Component {
   private cachedWidth?: number;
   private cachedLines?: string[];
 
-  // Colors - using proper reset sequences
-  private dim = (s: string) => `\x1b[2m${s}\x1b[0m`;
-  private bold = (s: string) => `\x1b[1m${s}\x1b[0m`;
-  private cyan = (s: string) => `\x1b[36m${s}\x1b[0m`;
-  private green = (s: string) => `\x1b[32m${s}\x1b[0m`;
-  private yellow = (s: string) => `\x1b[33m${s}\x1b[0m`;
-  private gray = (s: string) => `\x1b[90m${s}\x1b[0m`;
+  private _focused = false;
 
-  constructor(questions: ExtractedQuestion[], tui: TUI, onDone: (result: string | null) => void) {
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.editor.focused = value;
+  }
+
+  constructor(
+    questions: ExtractedQuestion[],
+    tui: TUI,
+    theme: Theme,
+    onDone: (result: string | null) => void,
+  ) {
     this.questions = questions;
     this.answers = questions.map(() => "");
     this.tui = tui;
+    this.theme = theme;
     this.onDone = onDone;
 
-    // Create a minimal theme for the editor
-    const selectedLine = (s: string) => `\x1b[44m${s}\x1b[0m`;
+    const selectedLine = (s: string) => theme.bg("selectedBg", s);
     const editorTheme: EditorTheme = {
-      borderColor: this.dim,
+      borderColor: (s) => theme.fg("dim", s),
       selectList: {
         selectedPrefix: selectedLine,
         selectedText: selectedLine,
-        description: this.gray,
-        scrollInfo: this.gray,
-        noMatch: this.gray,
+        description: (s) => theme.fg("muted", s),
+        scrollInfo: (s) => theme.fg("muted", s),
+        noMatch: (s) => theme.fg("warning", s),
       },
     };
 
@@ -228,11 +238,6 @@ class QnAComponent implements Component {
     };
   }
 
-  private allQuestionsAnswered(): boolean {
-    this.saveCurrentAnswer();
-    return this.answers.every((a) => (a?.trim() || "").length > 0);
-  }
-
   private saveCurrentAnswer(): void {
     this.answers[this.currentIndex] = this.editor.getText();
   }
@@ -362,6 +367,7 @@ class QnAComponent implements Component {
       return this.cachedLines;
     }
 
+    const theme = this.theme;
     const lines: string[] = [];
     const boxWidth = Math.min(width - 4, 120); // Allow wider box
     const contentWidth = boxWidth - 4; // 2 chars padding on each side
@@ -374,11 +380,11 @@ class QnAComponent implements Component {
       const paddedContent = " ".repeat(leftPad) + content;
       const contentLen = visibleWidth(paddedContent);
       const rightPad = Math.max(0, boxWidth - contentLen - 2);
-      return this.dim("│") + paddedContent + " ".repeat(rightPad) + this.dim("│");
+      return theme.fg("dim", "│") + paddedContent + " ".repeat(rightPad) + theme.fg("dim", "│");
     };
 
     const emptyBoxLine = (): string => {
-      return this.dim("│") + " ".repeat(boxWidth - 2) + this.dim("│");
+      return theme.fg("dim", "│") + " ".repeat(boxWidth - 2) + theme.fg("dim", "│");
     };
 
     const padToWidth = (line: string): string => {
@@ -387,10 +393,10 @@ class QnAComponent implements Component {
     };
 
     // Title
-    lines.push(padToWidth(this.dim("╭" + horizontalLine(boxWidth - 2) + "╮")));
-    const title = `${this.bold(this.cyan("Questions"))} ${this.dim(`(${this.currentIndex + 1}/${this.questions.length})`)}`;
+    lines.push(padToWidth(theme.fg("dim", "╭" + horizontalLine(boxWidth - 2) + "╮")));
+    const title = `${theme.bold(theme.fg("accent", "Questions"))} ${theme.fg("dim", `(${this.currentIndex + 1}/${this.questions.length})`)}`;
     lines.push(padToWidth(boxLine(title)));
-    lines.push(padToWidth(this.dim("├" + horizontalLine(boxWidth - 2) + "┤")));
+    lines.push(padToWidth(theme.fg("dim", "├" + horizontalLine(boxWidth - 2) + "┤")));
 
     // Progress indicator
     const progressParts: string[] = [];
@@ -398,11 +404,11 @@ class QnAComponent implements Component {
       const answered = (this.answers[i]?.trim() || "").length > 0;
       const current = i === this.currentIndex;
       if (current) {
-        progressParts.push(this.cyan("●"));
+        progressParts.push(theme.fg("accent", "●"));
       } else if (answered) {
-        progressParts.push(this.green("●"));
+        progressParts.push(theme.fg("success", "●"));
       } else {
-        progressParts.push(this.dim("○"));
+        progressParts.push(theme.fg("dim", "○"));
       }
     }
     lines.push(padToWidth(boxLine(progressParts.join(" "))));
@@ -419,7 +425,7 @@ class QnAComponent implements Component {
     // Context if present
     if (q.context) {
       lines.push(padToWidth(emptyBoxLine()));
-      const contextText = this.gray(`${q.context}`);
+      const contextText = theme.fg("muted", `${q.context}`);
       const wrappedContext = wrapTextWithAnsi(contextText, contentWidth - 2);
       for (const line of wrappedContext) {
         lines.push(padToWidth(boxLine(line)));
@@ -430,7 +436,7 @@ class QnAComponent implements Component {
 
     // Render the editor component (multi-line input) with padding
     // Skip the first and last lines (editor's own border lines)
-    const answerPrefix = this.bold("A: ");
+    const answerPrefix = theme.bold("A: ");
     const editorWidth = contentWidth - 4 - 3; // Extra padding + space for "A: "
     const editorLines = this.editor.render(editorWidth);
     for (let i = 1; i < editorLines.length - 1; i++) {
@@ -447,15 +453,15 @@ class QnAComponent implements Component {
 
     // Confirmation dialog or footer with controls
     if (this.showingConfirmation) {
-      lines.push(padToWidth(this.dim("├" + horizontalLine(boxWidth - 2) + "┤")));
-      const confirmMsg = `${this.yellow("Submit all answers?")} ${this.dim("(Enter/y to confirm, Esc/n to cancel)")}`;
+      lines.push(padToWidth(theme.fg("dim", "├" + horizontalLine(boxWidth - 2) + "┤")));
+      const confirmMsg = `${theme.fg("warning", "Submit all answers?")} ${theme.fg("dim", "(Enter/y to confirm, Esc/n to cancel)")}`;
       lines.push(padToWidth(boxLine(truncateToWidth(confirmMsg, contentWidth))));
     } else {
-      lines.push(padToWidth(this.dim("├" + horizontalLine(boxWidth - 2) + "┤")));
-      const controls = `${this.dim("Tab/Enter")} next · ${this.dim("Shift+Tab")} prev · ${this.dim("Shift+Enter")} newline · ${this.dim("Esc")} cancel`;
+      lines.push(padToWidth(theme.fg("dim", "├" + horizontalLine(boxWidth - 2) + "┤")));
+      const controls = `${theme.fg("dim", "Tab/Enter")} next · ${theme.fg("dim", "Shift+Tab")} prev · ${theme.fg("dim", "Shift+Enter")} newline · ${theme.fg("dim", "Esc")} cancel`;
       lines.push(padToWidth(boxLine(truncateToWidth(controls, contentWidth))));
     }
-    lines.push(padToWidth(this.dim("╰" + horizontalLine(boxWidth - 2) + "╯")));
+    lines.push(padToWidth(theme.fg("dim", "╰" + horizontalLine(boxWidth - 2) + "╯")));
 
     this.cachedWidth = width;
     this.cachedLines = lines;
@@ -467,8 +473,8 @@ export default function (pi: ExtensionAPI) {
   pi.registerCommand("answer", {
     description: "Extract questions from last assistant message into interactive Q&A",
     handler: async (_args, ctx) => {
-      if (!ctx.hasUI) {
-        ctx.ui.notify("answer requires interactive mode", "error");
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify("answer requires TUI mode", "error");
         return;
       }
 
@@ -571,8 +577,8 @@ export default function (pi: ExtensionAPI) {
       }
 
       // Show the Q&A component
-      const answersResult = await ctx.ui.custom<string | null>((tui, _theme, _kb, done) => {
-        return new QnAComponent(extractionResult.questions, tui, done);
+      const answersResult = await ctx.ui.custom<string | null>((tui, theme, _kb, done) => {
+        return new QnAComponent(extractionResult.questions, tui, theme, done);
       });
 
       if (answersResult === null) {

package/extensions/branch-term.ts

@@ -13,7 +13,7 @@ import { Box, Text } from "@earendil-works/pi-tui";
 
 const TERMINAL_FLAG = "branch-term";
 const TMUX_LAYOUT_FLAG = "branch-tmux-layout";
-const BRANCH_MESSAGE_TYPE = "branch-term-message";
+const BRANCH_ENTRY_TYPE = "branch-term-message";
 const MANUAL_RESUME_INTRO =
   "Branch session ready. Run this command in a separate terminal or tmux pane";
 
@@ -220,15 +220,10 @@ function showCommandMessage(
     return;
   }
 
-  pi.sendMessage({
-    customType: BRANCH_MESSAGE_TYPE,
-    content: intro,
-    display: true,
-    details: {
-      intro,
-      command,
-      copiedToClipboard,
-    } satisfies CommandMessageDetails,
+  pi.appendEntry<CommandMessageDetails>(BRANCH_ENTRY_TYPE, {
+    intro,
+    command,
+    copiedToClipboard,
   });
 }
 
@@ -266,10 +261,10 @@ function createFreshSessionFile(cwd: string, sessionDir: string): string {
 }
 
 export default function (pi: ExtensionAPI) {
-  pi.registerMessageRenderer(BRANCH_MESSAGE_TYPE, (message, _options, theme) => {
-    const details = message.details as CommandMessageDetails | undefined;
+  pi.registerEntryRenderer<CommandMessageDetails>(BRANCH_ENTRY_TYPE, (entry, _options, theme) => {
+    const details = entry.data;
     if (!details || typeof details.intro !== "string" || typeof details.command !== "string") {
-      return new Text(typeof message.content === "string" ? message.content : "", 0, 0);
+      return undefined;
     }
 
     const box = new Box(1, 1, (text) => theme.bg("customMessageBg", text));

package/extensions/btw.ts

@@ -116,8 +116,8 @@ export default function btwExtension(pi: ExtensionAPI): void {
         return;
       }
 
-      if (!ctx.hasUI) {
-        ctx.ui.notify("btw requires interactive mode", "error");
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify("btw requires TUI mode", "error");
         return;
       }
 
@@ -278,8 +278,8 @@ function seedSessionManager(sessionManager: SessionManager, messages: AgentMessa
 }
 
 async function showResultDialog(ctx: ExtensionContext, result: BtwResult): Promise<void> {
-  await ctx.ui.custom<void>((tui, _theme, _keybindings, done) => {
-    return new BtwResultComponent(result, tui, ctx.ui.theme, done);
+  await ctx.ui.custom<void>((tui, theme, _keybindings, done) => {
+    return new BtwResultComponent(result, tui, theme, done);
   });
 }
 

package/extensions/ghostty.ts

@@ -3,6 +3,7 @@
  *
  * - Shows project/session in the terminal title
  * - Shows a braille spinner in the title while the agent is working
+ * - Shows the braille spinner backwards while context is compacting
  * - Shows a ? marker while an extension prompt is waiting for input
  * - Updates title with the current tool name during tool execution
  * - Treats background /review runs as working state via review:start/review:end events
@@ -22,6 +23,7 @@ let sessionName: string | undefined;
 let sessionCwd: string | undefined;
 let currentTool: string | undefined;
 let isWorking = false;
+let isCompacting = false;
 let frameIndex = 0;
 let spinnerTimer: ReturnType<typeof setInterval> | undefined;
 let pendingPromptCount = 0;
@@ -47,6 +49,15 @@ function currentFrame(): string {
   return STATUS_SPINNER_FRAMES[frameIndex % STATUS_SPINNER_FRAMES.length];
 }
 
+function resetFrame(): void {
+  frameIndex = 0;
+}
+
+function advanceFrame(): void {
+  const step = isCompacting ? -1 : 1;
+  frameIndex = (frameIndex + step + STATUS_SPINNER_FRAMES.length) % STATUS_SPINNER_FRAMES.length;
+}
+
 function hasPendingPrompts(): boolean {
   return pendingPromptCount > 0;
 }
@@ -69,11 +80,12 @@ function hasActiveReviewRuns(): boolean {
 }
 
 function isBusy(): boolean {
-  return isWorking || hasActiveReviewRuns();
+  return isWorking || isCompacting || hasActiveReviewRuns();
 }
 
 function getWorkingExtra(): string | undefined {
   if (currentTool) return currentTool;
+  if (isCompacting) return "compacting";
   if (!isWorking && hasActiveReviewRuns()) return "review";
   return undefined;
 }
@@ -105,7 +117,7 @@ function startSpinnerTimer(ctx: ExtensionContext): void {
   clearSpinnerTimer();
   spinnerTimer = setInterval(() => {
     if (!isBusy() || hasPendingPrompts()) return;
-    frameIndex = (frameIndex + 1) % STATUS_SPINNER_FRAMES.length;
+    advanceFrame();
     renderWorkingTitle(ctx);
   }, STATUS_SPINNER_INTERVAL_MS);
 }
@@ -114,7 +126,7 @@ function startSpinner(ctx: ExtensionContext): void {
   clearSpinnerTimer();
   isWorking = true;
   currentTool = undefined;
-  frameIndex = 0;
+  resetFrame();
   renderActiveTitle(ctx);
 
   if (!hasPendingPrompts()) {
@@ -132,7 +144,7 @@ function stopSpinner(ctx: ExtensionContext): void {
     return;
   }
 
-  if (hasActiveReviewRuns()) {
+  if (isBusy()) {
     renderWorkingTitle(ctx);
     startSpinnerTimer(ctx);
     return;
@@ -161,6 +173,38 @@ function handlePromptEnd(ctx: ExtensionContext): void {
   renderActiveTitle(ctx);
 }
 
+function startCompaction(ctx: ExtensionContext, signal: AbortSignal): void {
+  isWorking = false;
+  isCompacting = true;
+  currentTool = undefined;
+  resetFrame();
+  signal.addEventListener("abort", () => stopCompaction(ctx), { once: true });
+
+  renderActiveTitle(ctx);
+  if (!hasPendingPrompts()) {
+    startSpinnerTimer(ctx);
+  }
+}
+
+function stopCompaction(ctx: ExtensionContext, options?: { render?: boolean }): void {
+  if (!isCompacting) return;
+
+  isCompacting = false;
+
+  if (options?.render === false) return;
+
+  if (isBusy()) {
+    renderActiveTitle(ctx);
+    if (!hasPendingPrompts()) {
+      startSpinnerTimer(ctx);
+    }
+    return;
+  }
+
+  clearSpinnerTimer();
+  renderActiveTitle(ctx);
+}
+
 function syncSessionTitle(ctx: ExtensionContext): void {
   renderActiveTitle(ctx);
 }
@@ -181,17 +225,12 @@ function handleReviewStart(ctx: ExtensionContext): void {
 }
 
 function handleReviewEnd(ctx: ExtensionContext): void {
-  if (isWorking) {
-    renderActiveTitle(ctx);
-    return;
-  }
-
   if (hasPendingPrompts()) {
     renderActiveTitle(ctx);
     return;
   }
 
-  if (hasActiveReviewRuns()) {
+  if (isBusy()) {
     renderActiveTitle(ctx);
     startSpinnerTimer(ctx);
     return;
@@ -218,10 +257,11 @@ export default function (pi: ExtensionAPI) {
   pi.on("agent_start", async (_event, ctx) => {
     if (!ctx.hasUI) return;
     latestCtx = ctx;
+    stopCompaction(ctx, { render: false });
     startSpinner(ctx);
   });
 
-  pi.on("agent_end", async (_event, ctx) => {
+  pi.on("agent_settled", async (_event, ctx) => {
     if (!ctx.hasUI) return;
     latestCtx = ctx;
     stopSpinner(ctx);
@@ -243,6 +283,18 @@ export default function (pi: ExtensionAPI) {
     renderActiveTitle(ctx);
   });
 
+  pi.on("session_before_compact", async (event, ctx) => {
+    if (!ctx.hasUI) return;
+    latestCtx = ctx;
+    startCompaction(ctx, event.signal);
+  });
+
+  pi.on("session_compact", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+    latestCtx = ctx;
+    stopCompaction(ctx);
+  });
+
   pi.events.on("ui:prompt_start", () => {
     pendingPromptCount += 1;
 
@@ -287,6 +339,7 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_shutdown", async (_event, ctx) => {
     clearSpinnerTimer();
     isWorking = false;
+    isCompacting = false;
     currentTool = undefined;
     pendingPromptCount = 0;
     const sessionKey = getSessionKey(ctx);

package/extensions/insights.ts

@@ -1,4 +1,5 @@
-import { complete, type Api, type Model, type UserMessage } from "@earendil-works/pi-ai";
+import { complete } from "@earendil-works/pi-ai/compat";
+import type { Api, Model, UserMessage } from "@earendil-works/pi-ai";
 import {
   BorderedLoader,
   SessionManager,
@@ -480,8 +481,8 @@ async function runInsightsCommand(
     return;
   }
 
-  if (!ctx.hasUI) {
-    ctx.ui.notify("/insights currently requires interactive mode", "warning");
+  if (ctx.mode !== "tui") {
+    ctx.ui.notify("/insights currently requires TUI mode", "warning");
     return;
   }
 

package/extensions/loop.ts

@@ -7,7 +7,8 @@
  */
 
 import { Type } from "typebox";
-import { complete, type Api, type Model, type UserMessage } from "@earendil-works/pi-ai";
+import { complete } from "@earendil-works/pi-ai/compat";
+import type { Api, Model, UserMessage } from "@earendil-works/pi-ai";
 import {
   compact,
   defineTool,
@@ -213,6 +214,8 @@ async function loadState(ctx: ExtensionContext): Promise<LoopStateData> {
 
 export default function loopExtension(pi: ExtensionAPI): void {
   let loopState: LoopStateData = { active: false };
+  let lastAgentEndMessages: Array<{ role?: string; stopReason?: string }> = [];
+  let pendingLoopPrompt: ReturnType<typeof setImmediate> | undefined;
 
   function persistState(state: LoopStateData): void {
     pi.appendEntry(LOOP_STATE_ENTRY, state);
@@ -271,6 +274,23 @@ export default function loopExtension(pi: ExtensionAPI): void {
     );
   }
 
+  function scheduleLoopPrompt(ctx: ExtensionContext): void {
+    if (pendingLoopPrompt) return;
+
+    pendingLoopPrompt = setImmediate(() => {
+      pendingLoopPrompt = undefined;
+      if (!loopState.active || !ctx.isIdle()) return;
+      triggerLoopPrompt(ctx);
+    });
+    pendingLoopPrompt.unref?.();
+  }
+
+  function cancelScheduledLoopPrompt(): void {
+    if (!pendingLoopPrompt) return;
+    clearImmediate(pendingLoopPrompt);
+    pendingLoopPrompt = undefined;
+  }
+
   async function showLoopSelector(ctx: ExtensionContext): Promise<LoopStateData | null> {
     const items: SelectItem[] = LOOP_PRESETS.map((preset) => ({
       value: preset.value,
@@ -385,11 +405,11 @@ export default function loopExtension(pi: ExtensionAPI): void {
       name: "signal_loop_success",
       label: "Signal Loop Success",
       description:
-        "Stop the active loop when the breakout condition is satisfied. Only call this tool when explicitly instructed to do so by the user, tool or system prompt.",
+        "Stop the active loop when the breakout condition is satisfied. Only call signal_loop_success when explicitly instructed to do so by the user, tool, or system prompt.",
       promptSnippet: "Signal that the active /loop breakout condition has been satisfied",
       promptGuidelines: [
-        "Call this tool only when the active loop's breakout condition is actually satisfied.",
-        "Do not call this tool unless a loop is currently active.",
+        "Call signal_loop_success only when the active loop's breakout condition is actually satisfied.",
+        "Do not call signal_loop_success unless a loop is currently active.",
       ],
       parameters: Type.Object({}),
       async execute(_toolCallId, _params, _signal, _onUpdate, ctx) {
@@ -416,7 +436,7 @@ export default function loopExtension(pi: ExtensionAPI): void {
     handler: async (args, ctx) => {
       let nextState = parseArgs(args);
       if (!nextState) {
-        if (!ctx.hasUI) {
+        if (ctx.mode !== "tui") {
           ctx.ui.notify("Usage: /loop tests | /loop custom <condition> | /loop self", "warning");
           return;
         }
@@ -458,10 +478,14 @@ export default function loopExtension(pi: ExtensionAPI): void {
     },
   });
 
-  pi.on("agent_end", async (event, ctx) => {
+  pi.on("agent_end", async (event) => {
+    lastAgentEndMessages = event.messages;
+  });
+
+  pi.on("agent_settled", async (_event, ctx) => {
     if (!loopState.active) return;
 
-    if (ctx.hasUI && wasLastAssistantAborted(event.messages)) {
+    if (ctx.hasUI && wasLastAssistantAborted(lastAgentEndMessages)) {
       const confirm = await withPromptSignal(pi, () =>
         ctx.ui.confirm("Break active loop?", "Operation aborted. Break out of the loop?"),
       );
@@ -471,13 +495,13 @@ export default function loopExtension(pi: ExtensionAPI): void {
       }
     }
 
-    triggerLoopPrompt(ctx);
+    scheduleLoopPrompt(ctx);
   });
 
   pi.on("session_before_compact", async (event, ctx) => {
     if (!loopState.active || !loopState.mode || !ctx.model) return;
     const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
-    if (!auth.ok || !auth.apiKey) return;
+    if (!auth.ok) return;
 
     const instructionParts = [
       event.customInstructions,
@@ -526,4 +550,8 @@ export default function loopExtension(pi: ExtensionAPI): void {
   pi.on("session_start", async (_event, ctx) => {
     await restoreLoopState(ctx);
   });
+
+  pi.on("session_shutdown", async () => {
+    cancelScheduledLoopPrompt();
+  });
 }

package/extensions/memory.ts

@@ -1,10 +1,5 @@
-import {
-  complete,
-  StringEnum,
-  type Api,
-  type Model,
-  type UserMessage,
-} from "@earendil-works/pi-ai";
+import { complete } from "@earendil-works/pi-ai/compat";
+import { StringEnum, type Api, type Model, type UserMessage } from "@earendil-works/pi-ai";
 import {
   defineTool,
   withFileMutationQueue,
@@ -1710,7 +1705,7 @@ export default function memoryExtension(pi: ExtensionAPI): void {
         description: `Update one .agents/memory/core block while enforcing the shared ${CORE_LINE_CAP}-line and ${CORE_CHAR_CAP}-character caps`,
         promptSnippet: `Update one core memory block in .agents/memory/core with ${CORE_LINE_CAP}-line and ${CORE_CHAR_CAP}-character cap enforcement`,
         promptGuidelines: [
-          "Use this tool when updating .agents/memory/core/directives.md, context.md, focus.md, or pending.md.",
+          "Use memory_update_block when updating .agents/memory/core/directives.md, context.md, focus.md, or pending.md.",
           `If a write would exceed the ${CORE_LINE_CAP}-line or ${CORE_CHAR_CAP}-character core cap, run memory_dream or remove content first.`,
         ],
         parameters: MEMORY_UPDATE_BLOCK_PARAMS,
@@ -1741,7 +1736,7 @@ export default function memoryExtension(pi: ExtensionAPI): void {
         description: "Append an entry to .agents/memory/log.md using the repo memory log format",
         promptSnippet: "Append an entry to the repo memory log at .agents/memory/log.md",
         promptGuidelines: [
-          "Use this tool for important decisions, discoveries, plans, experiments, prompt ingests, and attachment additions worth remembering.",
+          "Use memory_append_log for important decisions, discoveries, plans, experiments, prompt ingests, and attachment additions worth remembering.",
           "Use importance labels high, medium, or low.",
           "If this entry replaces or corrects prior memory, set supersedes and/or invalidates links explicitly.",
           "The memory log is append-only. Do not rewrite or truncate older entries.",
@@ -1779,7 +1774,7 @@ export default function memoryExtension(pi: ExtensionAPI): void {
         promptSnippet: "Consolidate repo memory with dream-based core compression",
         promptGuidelines: [
           "Dream is the only consolidation mechanism for .agents/memory/core.",
-          "Use this tool when logs have accumulated, core needs compression, or recent compaction context should be folded into memory.",
+          "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) {