tau-all-agent 0.2.0 → 0.3.1

package/extensions/websearch/README.md

@@ -8,7 +8,14 @@ Optionally create `websearch.json` in your Pi agent directory (normally `~/.pi/a
 
 ```json
 {
-  "routes": ["pi:openai-codex", "pi:anthropic", "pi:gemini", "firefox:gemini", "chromium:gemini"],
+  "routes": [
+    "pi:openai-codex",
+    "pi:openai",
+    "pi:anthropic",
+    "pi:gemini",
+    "firefox:gemini",
+    "chromium:gemini"
+  ],
   "profiles": {
     "firefox": "default-release",
     "chromium": "Default"

package/extensions/websearch/config.ts

@@ -8,6 +8,7 @@ const WEBSEARCH_CONFIG_PATH = path.join(getAgentDir(), "websearch.json");
 
 const DEFAULT_ROUTES: WebsearchRouteId[] = [
   "pi:openai-codex",
+  "pi:openai",
   "pi:anthropic",
   "pi:gemini",
   "firefox:gemini",
@@ -26,7 +27,7 @@ function sanitizeRoutes(value: unknown): WebsearchRouteId[] {
   for (const item of value) {
     if (item === "firefox:openai-codex" || item === "chromium:openai-codex") {
       throw new Error(
-        `Invalid websearch route: ${item} (removed). Use pi:openai-codex and sign in with Pi /login.`,
+        `Invalid websearch route: ${item} (removed). Use pi:openai-codex or pi:openai and sign in with Pi /login.`,
       );
     }
     if (typeof item !== "string" || !valid.has(item as WebsearchRouteId)) {

package/extensions/websearch/index.ts

@@ -19,7 +19,11 @@ import { limitOutput } from "./output.js";
 import { isPiAnthropicModel, searchWithPiAnthropic } from "./providers/anthropic.pi.js";
 import { browserGemini } from "./providers/gemini.browser.js";
 import { isPiGeminiModel, searchWithPiGemini } from "./providers/gemini.pi.js";
-import { isPiOpenAICodexModel, searchWithPiOpenAICodex } from "./providers/openai-codex.pi.js";
+import {
+  isPiOpenAICodexModel,
+  isPiOpenAIModel,
+  searchWithPiOpenAI,
+} from "./providers/openai.pi.js";
 import type { PiModelSelection } from "./providers/pi-model.shared.js";
 import { getPiModelCandidates, selectNextPiModel } from "./providers/pi-model.shared.js";
 import { isModelUnavailableError } from "./providers/shared.js";
@@ -37,8 +41,13 @@ type PiRouteId = `pi:${WebsearchBackendId}`;
 const PI_ROUTE_HANDLERS: Record<PiRouteId, PiRouteHandler> = {
   "pi:openai-codex": {
     predicate: isPiOpenAICodexModel,
-    search: searchWithPiOpenAICodex,
-    fallbackModels: ["gpt-5.6-luna", "gpt-5.5"],
+    search: searchWithPiOpenAI,
+    fallbackModels: ["gpt-6-luna", "gpt-6.1-sol"],
+  },
+  "pi:openai": {
+    predicate: isPiOpenAIModel,
+    search: searchWithPiOpenAI,
+    fallbackModels: ["gpt-6-luna", "gpt-6.1-sol"],
   },
   "pi:anthropic": {
     predicate: isPiAnthropicModel,
@@ -246,24 +255,24 @@ export default function (pi: ExtensionAPI) {
         query: Type.String({ description: "What to search for" }),
       }),
       renderShell: "self",
-      renderCall(args, theme) {
-        return new Text(formatWebsearchCall(args.query, theme), 0, 0);
+      renderCall(args, theme, { outputPad }) {
+        return new Text(formatWebsearchCall(args.query, theme), outputPad, 0);
       },
-      renderResult(result, { expanded }, theme) {
+      renderResult(result, { expanded }, theme, { outputPad }) {
         const content = result.content.find((item) => item.type === "text");
         const text = content?.type === "text" ? content.text : "";
 
         if (!expanded) {
-          return new Text(formatCollapsedWebsearchResult(text, theme), 0, 0);
+          return new Text(formatCollapsedWebsearchResult(text, theme), outputPad, 0);
         }
 
         if (!text.trim()) {
-          return new Text(`\n${theme.fg("muted", "(no output)")}`, 0, 0);
+          return new Text(`\n${theme.fg("muted", "(no output)")}`, outputPad, 0);
         }
 
         const container = new Container();
         container.addChild(new Spacer(1));
-        container.addChild(new Markdown(text.trim(), 0, 0, getMarkdownTheme()));
+        container.addChild(new Markdown(text.trim(), outputPad, 0, getMarkdownTheme()));
         return container;
       },
       async execute(_toolCallId, params, signal, _onUpdate, ctx) {

package/extensions/websearch/providers/{openai-codex.pi.ts → openai.pi.ts}

@@ -6,19 +6,20 @@ import type { PiModelSelection } from "./pi-model.shared.js";
 import { buildWebsearchPrompt, WEBSEARCH_SYSTEM_PROMPT } from "./search-prompt.shared.js";
 import { applyResolvedHeaders, getResolvedHeader, readEventStream, withTimeout } from "./shared.js";
 
-export async function searchWithPiOpenAICodex(
+export async function searchWithPiOpenAI(
   selection: PiModelSelection,
   query: string,
   signal?: AbortSignal,
 ): Promise<WebsearchResult> {
   const apiKey = resolveApiKey(selection);
   if (!apiKey) {
-    throw new Error("OpenAI Codex auth is not configured.");
+    throw new Error("OpenAI auth is not configured.");
   }
 
-  const result = await runOpenAICodexSearch({
+  const backend = selection.model.provider === "openai-codex" ? "openai-codex" : "openai";
+  const result = await runOpenAISearch({
     apiKey,
-    accountId: decodeJwtAccountId(apiKey),
+    backend,
     model: selection.model.id,
     query,
     baseUrl: selection.model.baseUrl,
@@ -27,13 +28,17 @@ export async function searchWithPiOpenAICodex(
   });
 
   return {
-    backend: "openai-codex",
+    backend,
     authSource: "pi",
     answer: result.answer,
     sources: result.sources,
   };
 }
 
+export function isPiOpenAIModel(model: Model<Api>): boolean {
+  return model.api === "openai-responses" && model.provider === "openai";
+}
+
 export function isPiOpenAICodexModel(model: Model<Api>): boolean {
   return model.api === "openai-codex-responses" && model.provider === "openai-codex";
 }
@@ -48,25 +53,27 @@ function resolveApiKey(selection: PiModelSelection): string | undefined {
   return match?.[1];
 }
 
-async function runOpenAICodexSearch(options: {
+async function runOpenAISearch(options: {
   apiKey: string;
+  backend: "openai" | "openai-codex";
   model: string;
   query: string;
   baseUrl?: string;
-  accountId?: string;
   headers?: Record<string, string | null>;
   signal?: AbortSignal;
 }): Promise<{ answer: string; sources: WebsearchSource[] }> {
-  const response = await fetch(resolveCodexUrl(options.baseUrl), {
+  const codex = options.backend === "openai-codex";
+  const accountId = codex ? decodeJwtAccountId(options.apiKey) : undefined;
+  const url = codex ? resolveCodexUrl(options.baseUrl) : resolveResponsesUrl(options.baseUrl);
+  const response = await fetch(url, {
     method: "POST",
     headers: applyResolvedHeaders(
       {
         authorization: `Bearer ${options.apiKey}`,
-        ...(options.accountId ? { "chatgpt-account-id": options.accountId } : {}),
+        ...(accountId ? { "chatgpt-account-id": accountId } : {}),
         "content-type": "application/json",
         accept: "text/event-stream",
-        "OpenAI-Beta": "responses=experimental",
-        originator: "pi-websearch",
+        ...(codex ? { "OpenAI-Beta": "responses=experimental", originator: "pi-websearch" } : {}),
       },
       options.headers,
     ),
@@ -82,6 +89,7 @@ async function runOpenAICodexSearch(options: {
     signal: withTimeout(options.signal, 120_000),
   });
 
+  const sources: WebsearchSource[] = [];
   let answer = "";
   let fallbackAnswer = "";
   let completed = false;
@@ -110,6 +118,7 @@ async function runOpenAICodexSearch(options: {
           .filter((text): text is string => typeof text === "string")
           .join("\n");
         if (fullText) fallbackAnswer = fullText;
+        sources.push(...extractAnnotationSources(content));
       }
 
       if (
@@ -119,7 +128,7 @@ async function runOpenAICodexSearch(options: {
       ) {
         const result = event.response as Record<string, unknown> | undefined;
         if (event.type === "response.incomplete" || result?.status !== "completed") {
-          throw new Error("OpenAI Codex search did not complete successfully.");
+          throw new Error("OpenAI search did not complete successfully.");
         }
         completed = true;
       }
@@ -137,7 +146,7 @@ async function runOpenAICodexSearch(options: {
             throw new Error((error as Record<string, unknown>).message as string);
           }
         }
-        throw new Error(eventMessage ?? "OpenAI Codex search failed.");
+        throw new Error(eventMessage ?? "OpenAI search failed.");
       }
     } catch (error) {
       if (error instanceof SyntaxError) return;
@@ -146,20 +155,46 @@ async function runOpenAICodexSearch(options: {
   });
 
   if (!completed) {
-    throw new Error("OpenAI Codex stream ended before search completed.");
+    throw new Error("OpenAI stream ended before search completed.");
   }
 
   const finalAnswer = (answer || fallbackAnswer).trim();
   if (!finalAnswer) {
-    throw new Error("OpenAI Codex returned an empty response.");
+    throw new Error("OpenAI returned an empty response.");
   }
 
   return {
     answer: finalAnswer,
-    sources: dedupeSources(extractMarkdownSources(finalAnswer)),
+    sources: dedupeSources([...sources, ...extractMarkdownSources(finalAnswer)]),
   };
 }
 
+function extractAnnotationSources(content: unknown[]): WebsearchSource[] {
+  const sources: WebsearchSource[] = [];
+  for (const part of content) {
+    if (!part || typeof part !== "object" || !("annotations" in part)) continue;
+    if (!Array.isArray(part.annotations)) continue;
+    for (const annotation of part.annotations) {
+      if (
+        annotation?.type !== "url_citation" ||
+        typeof annotation.url !== "string" ||
+        !/^https?:\/\//i.test(annotation.url)
+      )
+        continue;
+      sources.push({
+        url: annotation.url,
+        title: typeof annotation.title === "string" ? annotation.title : "",
+      });
+    }
+  }
+  return sources;
+}
+
+function resolveResponsesUrl(baseUrl?: string): string {
+  const normalized = (baseUrl || "https://api.openai.com/v1").replace(/\/+$/, "");
+  return normalized.endsWith("/responses") ? normalized : `${normalized}/responses`;
+}
+
 function resolveCodexUrl(baseUrl = "https://chatgpt.com/backend-api"): string {
   const normalized = String(baseUrl || "https://chatgpt.com/backend-api").replace(/\/+$/, "");
   if (normalized.endsWith("/codex/responses")) return normalized;

package/extensions/websearch/providers/shared.ts

@@ -7,15 +7,22 @@ export function isModelUnavailableError(error: unknown, model: Model<Api>): bool
   if (!isRecord(error.body)) return false;
 
   const detail = isRecord(error.body.error) ? error.body.error : undefined;
-  if (model.provider === "openai-codex" && model.api === "openai-codex-responses") {
+  const codex = model.provider === "openai-codex" && model.api === "openai-codex-responses";
+  const openai = model.provider === "openai" && model.api === "openai-responses";
+  if (codex || openai) {
     return (
-      (error.status === 400 &&
+      (codex &&
+        error.status === 400 &&
         Boolean(model.id) &&
         error.body.detail ===
           `The '${model.id}' model is not supported when using Codex with a ChatGPT account.`) ||
       detail?.code === "model_not_found" ||
       detail?.code === "model_not_supported" ||
-      detail?.code === "unsupported_model"
+      detail?.code === "unsupported_model" ||
+      (openai &&
+        error.status === 400 &&
+        detail?.code === "subscription_sharing_unsupported_capability" &&
+        detail.param === "model")
     );
   }
 

package/extensions/websearch/types.ts

@@ -1,8 +1,9 @@
-export type WebsearchBackendId = "openai-codex" | "anthropic" | "gemini";
+export type WebsearchBackendId = "openai-codex" | "openai" | "anthropic" | "gemini";
 export type WebsearchAuthSource = "pi" | "firefox" | "chromium";
 export type WebsearchBrowserFamily = "firefox" | "chromium";
 export type WebsearchRouteId =
   | "pi:openai-codex"
+  | "pi:openai"
   | "pi:anthropic"
   | "pi:gemini"
   | "firefox:gemini"

package/extensions/worktree.ts

@@ -19,25 +19,14 @@
  */
 
 import type { ExtensionAPI, ExtensionCommandContext, Theme } from "@earendil-works/pi-coding-agent";
-import {
-  DynamicBorder,
-  SessionManager,
-  highlightCode,
-  type SessionHeader,
-} from "@earendil-works/pi-coding-agent";
-import {
-  Box,
-  Container,
-  type SelectItem,
-  SelectList,
-  Text,
-  matchesKey,
-} from "@earendil-works/pi-tui";
+import { SessionManager, highlightCode, type SessionHeader } from "@earendil-works/pi-coding-agent";
+import { Box, Text } from "@earendil-works/pi-tui";
 import { spawnSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
 
 const STATUS_KEY = "0-worktree";
+const LIST_ENTRY_TYPE = "worktree-list";
 const MANUAL_OPEN_ENTRY_TYPE = "worktree-open-command";
 const RESTORE_STASH_ENTRY_TYPE = "worktree-restore-command";
 const SCRIPT_RERUN_ENTRY_TYPE = "worktree-script-rerun-command";
@@ -200,7 +189,7 @@ function showCommandMessage(
   command: string,
 ): void {
   const copiedToClipboard = copyToClipboard(command);
-  if (!ctx.hasUI) {
+  if (ctx.mode === "print") {
     console.log(formatCommandMessageIntro(intro, copiedToClipboard));
     console.log(command);
     return;
@@ -1262,8 +1251,8 @@ function hasValidSessionFile(sessionFile: string): boolean {
 function createFreshSessionFile(targetCwd: string, sessionDir?: string): string {
   const session = SessionManager.create(targetCwd, sessionDir);
   const sessionFile = session.getSessionFile()!;
-  // Pi defers its first write until an assistant reply. Persist the native header
-  // now so switchSession can open an otherwise empty conversation.
+  // Pi persists the session on its first user or assistant message. Persist the
+  // native header so switchSession can open an otherwise empty conversation.
   fs.writeFileSync(sessionFile, `${JSON.stringify(session.getHeader())}\n`, { flag: "wx" });
   return sessionFile;
 }
@@ -1308,9 +1297,13 @@ async function switchToWorktree(
   // including when the source has not been persisted yet.
   const storage = SessionManager.create(ctx.sessionManager.getCwd(), currentSessionDir);
   const sessionDir = storage.usesDefaultSessionDir() ? undefined : currentSessionDir;
-  const hasAssistantReply = ctx.sessionManager
+  const hasPersistedMessage = ctx.sessionManager
     .getEntries()
-    .some((entry) => entry.type === "message" && entry.message.role === "assistant");
+    .some(
+      (entry) =>
+        entry.type === "message" &&
+        (entry.message.role === "user" || entry.message.role === "assistant"),
+    );
 
   let sessionFile: string;
   if (hasValidSessionFile(currentSessionFile)) {
@@ -1326,13 +1319,13 @@ async function switchToWorktree(
     }
     sessionFile = forkedSessionFile;
   } else {
-    if (hasAssistantReply) {
+    if (hasPersistedMessage) {
       throw new Error(`Current session file is missing or invalid: ${currentSessionFile}`);
     }
 
     const message = "Current session has no persisted history yet. Switching with a fresh session.";
     if (ctx.hasUI) ctx.ui.notify(message, "warning");
-    else console.log(message);
+    else console.error(message);
 
     sessionFile = createFreshSessionFile(targetPath, sessionDir);
   }
@@ -1965,6 +1958,11 @@ async function handleList(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promi
     return { repo, items };
   });
 
+  if (ctx.mode === "json") {
+    pi.appendEntry(LIST_ENTRY_TYPE, { items });
+    return;
+  }
+
   if (ctx.mode !== "tui") {
     const output = items
       .map((item) => {
@@ -1985,80 +1983,26 @@ async function handleList(pi: ExtensionAPI, ctx: ExtensionCommandContext): Promi
     return;
   }
 
-  const theme = ctx.ui.theme;
-
-  const selectItems: SelectItem[] = items.map((item) => ({
-    value: item.wt.path,
-    label: formatWorktreeLabel(item, theme),
-  }));
-
-  const itemByValue = new Map(items.map((item) => [item.wt.path, item]));
+  const options = items.map((item) => formatWorktreeLabel(item, ctx.ui.theme));
+  const choice = await ctx.ui.select("Choose worktree", options);
+  if (choice === undefined) return;
 
-  type ListResult = { action: "switch" | "archive"; item: WorktreeDisplayItem } | null;
+  const item = items[options.indexOf(choice)];
+  if (!item) return;
 
-  const result = await ctx.ui.custom<ListResult>((tui, theme, _kb, done) => {
-    const container = new Container();
-    container.addChild(new DynamicBorder((s: string) => theme.fg("borderMuted", s)));
-
-    const selectList = new SelectList(selectItems, Math.min(selectItems.length, 15), {
-      selectedPrefix: (t) => theme.fg("accent", t),
-      selectedText: (t) => theme.fg("accent", t),
-      description: (t) => t,
-      scrollInfo: (t) => theme.fg("dim", t),
-      noMatch: (t) => theme.fg("warning", t),
-    });
-    selectList.onSelect = (si) => {
-      const item = itemByValue.get(si.value);
-      if (item) done({ action: "switch", item });
-      else done(null);
-    };
-    selectList.onCancel = () => done(null);
-    container.addChild(selectList);
-
-    container.addChild(
-      new Text(theme.fg("dim", " ↑↓ navigate  enter switch  a archive  esc close"), 0, 0),
-    );
-    container.addChild(new DynamicBorder((s: string) => theme.fg("borderMuted", s)));
-
-    return {
-      render: (w) => container.render(w),
-      invalidate: () => container.invalidate(),
-      handleInput: (data) => {
-        if (matchesKey(data, "a")) {
-          const si = selectList.getSelectedItem();
-          if (si) {
-            const item = itemByValue.get(si.value);
-            if (item) {
-              done({ action: "archive", item });
-              return;
-            }
-          }
-        }
-        selectList.handleInput(data);
-        tui.requestRender();
-      },
-    };
-  });
-
-  if (!result) return;
-
-  if (result.action === "switch") {
-    await switchToWorktree(pi, ctx, result.item.wt.path, repo.currentRoot);
+  const action = await ctx.ui.select(`Worktree: ${collapsePath(item.wt.path)}`, [
+    "Switch",
+    "Archive",
+  ]);
+  if (action === "Switch") {
+    await switchToWorktree(pi, ctx, item.wt.path, repo.currentRoot);
     return;
   }
 
-  if (result.action === "archive") {
-    await withSpinnerStatus(ctx, `archiving ${result.item.branch}`, async () => {
+  if (action === "Archive") {
+    await withSpinnerStatus(ctx, `archiving ${item.branch}`, async () => {
       const defaultMain = await getDefaultMainBranch(pi, repo.mainRoot);
-      await archiveWorktree(
-        pi,
-        ctx,
-        repo,
-        result.item.branch,
-        "prompt",
-        defaultMain,
-        result.item.wt,
-      );
+      await archiveWorktree(pi, ctx, repo, item.branch, "prompt", defaultMain, item.wt);
     });
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tau-all-agent",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Full Tau package for Pi with coding workflows, web search, sandboxing, memory, Telegram, Home Assistant, OpenSCAD, skills, and a theme",
   "keywords": [
     "agent-tools",

package/skills/oracle/SKILL.md

@@ -7,11 +7,13 @@ description: "Get independent reviews, second opinions, or help getting unstuck
 
 Use this skill when you want a second opinion from a capable model in a different family than the current session.
 
-The oracle workflow bundles selected files into a standalone prompt, selects an alternate model with `pi --list-models`, and sends the bundle to `pi -p --no-tools`. It is read-only by default because the oracle receives the selected context directly and does not get tools.
+The oracle workflow bundles selected files into a standalone prompt, selects an alternate model with `pi --list-models`, and sends the bundle to `pi -p --no-tools`.
+
+Discovery and generation disable extensions, skills, prompt templates, themes, and context files (`AGENTS.md` / `CLAUDE.md`). A fixed system prompt and empty append prompt replace discovered `SYSTEM.md` / `APPEND_SYSTEM.md`. The bundle supplies the task and project context. Pi retains normal authentication and configuration, but has no tools or persisted session. This isolates instructions, not the process. It is not a filesystem sandbox or a read-only guarantee.
 
 ## Model selection
 
-The `./scripts/oracle` wrapper chooses the strongest known model it can find in the first usable family from this order:
+The `scripts/oracle` wrapper chooses the strongest known model it can find in the first usable family from this order:
 
 | Current family     | Oracle preference                                     |
 | ------------------ | ----------------------------------------------------- |
@@ -33,24 +35,28 @@ If the current model is not obvious to the script, pass it explicitly with `--cu
 
 ## Commands
 
-Run commands from this skill directory:
+Run from the repository being reviewed, not this skill directory. Use the installed scripts' absolute paths. In the examples, replace `/absolute/path/to/oracle` with the directory containing this `SKILL.md`.
+
+The wrapper resolves the invocation's Git root once (or uses the invocation directory outside Git) and uses it for model discovery, bundling, and generation. Relative file selectors are rooted there, even when invoked from a repository subdirectory.
 
 ```bash
 # Preview selected files
-./scripts/oracle-bundle --dry-run -p "<task>" --file "src/**" --file "!**/*.test.*"
+/absolute/path/to/oracle/scripts/oracle-bundle --dry-run \
+  -p "<task>" --file "src/**" --file "!**/*.test.*"
 
 # Preview the full bundle
-./scripts/oracle-bundle -p "<task>" --file "src/**" --file "!**/*.test.*"
+/absolute/path/to/oracle/scripts/oracle-bundle \
+  -p "<task>" --file "src/**" --file "!**/*.test.*"
 
 # Show which oracle model would be selected
-./scripts/oracle --list-models --current openai-codex/gpt-6-astra
+/absolute/path/to/oracle/scripts/oracle --list-models --current openai-codex/gpt-6-astra
 
 # Ask the automatically selected oracle model
-./scripts/oracle --current openai-codex/gpt-6-astra \
+/absolute/path/to/oracle/scripts/oracle --current openai-codex/gpt-6-astra \
   -p "<task>" --file "src/**" --file "!**/*.test.*"
 
 # Override the oracle model when the automatic choice is wrong
-./scripts/oracle --model anthropic/claude-fable-5 \
+/absolute/path/to/oracle/scripts/oracle --model anthropic/claude-fable-5-1 \
   -p "<task>" --file "src/**" --file "!**/*.test.*"
 ```