tau-all-agent 0.1.4 → 0.1.6

package/README.md

@@ -27,7 +27,7 @@ pi install -l npm:tau-all-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,
@@ -94,14 +95,19 @@ interface ModelRequestAuth {
   model: Model<Api>;
   apiKey?: string;
   headers?: Record<string, string>;
+  env?: Record<string, string>;
 }
 
 type ModelAuthLookup = {
   find: (provider: string, modelId: string) => Model<Api> | undefined;
-  getApiKeyAndHeaders: (
-    model: Model<Api>,
-  ) => Promise<
-    { ok: true; apiKey?: string; headers?: Record<string, string> } | { ok: false; error: string }
+  getApiKeyAndHeaders: (model: Model<Api>) => Promise<
+    | {
+        ok: true;
+        apiKey?: string;
+        headers?: Record<string, string>;
+        env?: Record<string, string>;
+      }
+    | { ok: false; error: string }
   >;
 };
 
@@ -148,7 +154,7 @@ async function resolveModelRequestAuth(
   model: Model<Api>,
 ): Promise<ModelRequestAuth | null> {
   const auth = await modelRegistry.getApiKeyAndHeaders(model);
-  return auth.ok ? { model, apiKey: auth.apiKey, headers: auth.headers } : null;
+  return auth.ok ? { model, apiKey: auth.apiKey, headers: auth.headers, env: auth.env } : null;
 }
 
 /**
@@ -178,12 +184,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 +198,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;
+
+  get focused(): boolean {
+    return this._focused;
+  }
+
+  set focused(value: boolean) {
+    this._focused = value;
+    this.editor.focused = value;
+  }
 
-  constructor(questions: ExtractedQuestion[], tui: TUI, onDone: (result: string | null) => void) {
+  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 +243,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 +372,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 +385,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 +398,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 +409,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 +430,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 +441,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 +458,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 +478,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;
       }
 
@@ -536,6 +547,7 @@ export default function (pi: ExtensionAPI) {
               {
                 apiKey: extractionSelection.apiKey,
                 headers: extractionSelection.headers,
+                env: extractionSelection.env,
                 signal: loader.signal,
               },
             );
@@ -571,8 +583,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

@@ -1,7 +1,13 @@
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
-import type { AssistantMessage, ThinkingLevel } from "@earendil-works/pi-ai";
+import {
+  InMemoryCredentialStore,
+  type AssistantMessage,
+  type Provider,
+  type ThinkingLevel,
+} from "@earendil-works/pi-ai";
 import {
   DefaultResourceLoader,
+  ModelRuntime,
   SessionManager,
   buildSessionContext,
   createAgentSession,
@@ -59,6 +65,15 @@ type ActiveBtwRequest = {
   abort?: () => Promise<void>;
 };
 
+type BtwModelRegistry = ExtensionCommandContext["modelRegistry"];
+
+type BtwModelRuntimeState = {
+  runtime: ModelRuntime;
+  providers: Map<string, Provider>;
+};
+
+const btwModelRuntimes = new WeakMap<BtwModelRegistry, Promise<BtwModelRuntimeState>>();
+
 export default function btwExtension(pi: ExtensionAPI): void {
   let activeRequest: ActiveBtwRequest | null = null;
   let statusTimer: ReturnType<typeof setInterval> | null = null;
@@ -116,8 +131,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;
       }
 
@@ -227,11 +242,12 @@ async function runBtwRequest(
   });
   await resourceLoader.reload();
 
+  const modelRuntime = await createBtwModelRuntime(snapshot.modelRegistry, snapshot.model.provider);
   const { session } = await createAgentSession({
     cwd: snapshot.cwd,
     model: snapshot.model,
     thinkingLevel: snapshot.thinkingLevel,
-    modelRegistry: snapshot.modelRegistry,
+    modelRuntime,
     resourceLoader,
     tools: BTW_TOOL_NAMES,
     sessionManager,
@@ -269,6 +285,61 @@ async function runBtwRequest(
   }
 }
 
+async function createBtwModelRuntime(
+  modelRegistry: BtwModelRegistry,
+  providerId: string,
+): Promise<ModelRuntime> {
+  const provider = modelRegistry.getProvider(providerId);
+  if (!provider) {
+    throw new Error(`Model provider is unavailable: ${providerId}`);
+  }
+
+  const state = await getBtwModelRuntimeState(modelRegistry);
+  if (state.providers.get(providerId) !== provider) {
+    state.runtime.registerNativeProvider(withParentAuth(provider, modelRegistry));
+    state.providers.set(providerId, provider);
+  }
+  return state.runtime;
+}
+
+async function getBtwModelRuntimeState(
+  modelRegistry: BtwModelRegistry,
+): Promise<BtwModelRuntimeState> {
+  let state = btwModelRuntimes.get(modelRegistry);
+  if (!state) {
+    state = ModelRuntime.create({
+      credentials: new InMemoryCredentialStore(),
+      modelsPath: null,
+    }).then((runtime) => ({ runtime, providers: new Map() }));
+    btwModelRuntimes.set(modelRegistry, state);
+  }
+
+  try {
+    return await state;
+  } catch (error) {
+    if (btwModelRuntimes.get(modelRegistry) === state) {
+      btwModelRuntimes.delete(modelRegistry);
+    }
+    throw error;
+  }
+}
+
+function withParentAuth(provider: Provider, modelRegistry: BtwModelRegistry): Provider {
+  return {
+    ...provider,
+    refreshModels: undefined, // The parent runtime owns model catalog refreshes.
+    auth: {
+      ...provider.auth,
+      apiKey: {
+        name: `${provider.name} session authentication`,
+        async resolve() {
+          return modelRegistry.getProviderAuth(provider.id);
+        },
+      },
+    },
+  };
+}
+
 function seedSessionManager(sessionManager: SessionManager, messages: AgentMessage[]): void {
   type SessionMessageInput = Parameters<SessionManager["appendMessage"]>[0];
 
@@ -278,8 +349,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);