pum-agent 0.2.35-beta.1 → 0.2.36-beta.1

package/README.md

@@ -23,8 +23,8 @@ pum
 PUM opens the login panel automatically on the first start. Press `?` on an
 empty prompt to see every control.
 
-Select a model in `Ctrl+P`. GPT-6 Astra is listed for OpenAI and Codex;
-using it requires access on your provider account. Press `r` in the model
+Select a model in `Ctrl+P`. GPT-6 Astra, Luna and Sol are listed for OpenAI
+and Codex. To use them, your provider account must have access. Press `r` in the model
 list to refresh providers that support catalog discovery.
 
 Use `/model <name or provider/model-id> [effort]` to change the main-agent model.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pum-agent",
-  "version": "0.2.35-beta.1",
+  "version": "0.2.36-beta.1",
   "description": "A compact terminal coding agent powered by pi and OpenTUI.",
   "license": "MIT",
   "type": "module",
@@ -50,9 +50,8 @@
     "pack:check": "bun run scripts/validate-pack.ts"
   },
   "dependencies": {
-    "@earendil-works/pi-ai": "^0.85.0",
-    "@earendil-works/pi-coding-agent": "^0.85.0",
-    "@earendil-works/pi-server": "^0.85.0",
+    "@earendil-works/pi-ai": "^0.87.1",
+    "@earendil-works/pi-coding-agent": "^0.87.1",
     "@opentui/core": "^0.5.1",
     "@opentui/react": "^0.5.1",
     "react": "^19.2.8",

package/src/context-window.ts

@@ -1,12 +1,13 @@
 import { Type } from "typebox";
 import { createHash } from "node:crypto";
 import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { getCurrentSystemMessage, getCurrentSystemPrompt, getCurrentTools, type Message, type Tool } from "@earendil-works/pi-ai";
 import {
-  sessionEntryToContextMessages,
   type AgentSession,
   type ExtensionAPI,
   type InlineExtension,
   type SessionEntry,
+  type SessionProjection,
   type TurnEndEvent,
 } from "@earendil-works/pi-coding-agent";
 import { registerTranscriptHistoryTool } from "./transcript-history";
@@ -72,7 +73,7 @@ function boundaryData(value: unknown): BoundaryData {
   const { handoff } = handoffParams({ handoff: value.handoff });
   return { version: 1, ...(handoff === undefined ? {} : { handoff }) };
 }
-function header(id: string, handoff?: string, navigation?: { userId?: string; previousId?: string | null }, recovery = ""): AgentMessage {
+function createHeader(id: string, handoff?: string, navigation?: { userId?: string; previousId?: string | null }, recovery = ""): AgentMessage {
   return {
     role: "custom", customType: CONTEXT_WINDOW_CUSTOM_TYPE, display: false, timestamp: 0,
     content: `Fresh PUM context window: ${id}. Earlier transcript entries remain retained in the full session transcript. The rollover generated no summary. Current system instructions still apply. ${recovery}`
@@ -83,6 +84,12 @@ function header(id: string, handoff?: string, navigation?: { userId?: string; pr
 function isBoundary(entry: SessionEntry): boolean {
   return entry.type === "custom" && entry.customType === CONTEXT_WINDOW_CUSTOM_TYPE;
 }
+// System messages carry the prompt and tool declarations, which the meter
+// fingerprints separately. Message lists and indexes here exclude them.
+function conversation(messages: readonly AgentMessage[]): AgentMessage[] {
+  return messages.filter((message) => message.role !== "system");
+}
+const transcript = (messages: readonly AgentMessage[]) => messages as readonly Message[];
 const textResult = (details: Record<string, unknown>) => ({
   content: [{ type: "text" as const, text: JSON.stringify(details, null, 2) }], details,
 });
@@ -91,8 +98,8 @@ const textResult = (details: Record<string, unknown>) => ({
 export class ContextWindowController {
   private session?: AgentSession;
   private pending?: Pending;
-  private refreshPending = false;
   private windowId: string | null = null;
+  private windowHeader?: { id: string; message: AgentMessage };
   private observedExtraTokens = 0;
   private modelKey?: string;
   private usageFloor = 0;
@@ -122,7 +129,7 @@ export class ContextWindowController {
         if (key !== this.modelKey) {
           this.modelKey = key;
           this.generation++;
-          this.usageFloor = this.session?.agent.state.messages.length ?? 0;
+          this.usageFloor = this.session ? this.activeConversation().length : 0;
         }
       });
       pi.on("before_agent_start", (event) => {
@@ -209,22 +216,31 @@ export class ContextWindowController {
     this.disableAutomaticCompaction();
     this.restore();
     const transform = session.agent.transformContext;
-    session.agent.transformContext = async (messages, signal) => {
-      const originalTokens = messages.reduce((sum, message) => sum + estimateTokens(message), 0);
+    session.agent.transformContext = async (input, signal) => {
+      // pi rebuilds request history from the session projection. The rollover
+      // window is applied here, before extension context handlers inject memory.
+      const messages = this.windowRequest(input);
+      const source = conversation(messages);
+      const originalTokens = source.reduce((sum, message) => sum + estimateTokens(message), 0);
       const stateSystemPrompt = fingerprint(session.agent.state.systemPrompt);
       const stateTools = this.toolSchemas();
-      const prompt = this.preparedPrompt ?? { systemPrompt: stateSystemPrompt, tools: stateTools, modelKey: modelIdentity(session.model) };
       this.requestSnapshot = undefined;
       const generation = this.generation;
       const windowId = this.windowId;
-      const sourceHash = messageHash(messages);
-      const sourceCount = messages.length;
+      const sourceHash = messageHash(source);
+      const sourceCount = source.length;
       const transformed = transform ? await transform.call(session.agent, messages, signal) : messages;
       // Observe the complete extension chain, including memory injected after our
       // extension. Return it unchanged; memory and dynamic instructions stay active.
       if (generation === this.generation && !signal?.aborted) {
-        this.observedExtraTokens = Math.max(0, transformed.reduce((sum, message) => sum + estimateTokens(message), 0)
-          - originalTokens);
+        const prompt: PromptSnapshot = {
+          systemPrompt: fingerprint(getCurrentSystemPrompt(transcript(transformed))),
+          tools: this.toolSchemas(getCurrentTools(transcript(transformed))),
+          modelKey: modelIdentity(session.model),
+        };
+        this.preparedPrompt = prompt;
+        const transformedTokens = conversation(transformed).reduce((sum, message) => sum + estimateTokens(message), 0);
+        this.observedExtraTokens = Math.max(0, transformedTokens - originalTokens);
         const measured = this.latestUsageSnapshot;
         if (measured?.generation === generation && measured.modelKey === prompt.modelKey) {
           // A failed request may have observed growth followed by shrinkage
@@ -236,8 +252,7 @@ export class ContextWindowController {
         }
         this.requestSnapshot = { ...prompt, windowId, generation, stateSystemPrompt, stateTools,
           injectedTokens: this.observedExtraTokens, sourceHash, sourceCount,
-          estimatedInputTokens: transformed.reduce((sum, message) => sum + estimateTokens(message), 0)
-            + prompt.systemPrompt.tokens + prompt.tools.tokens };
+          estimatedInputTokens: transformedTokens + prompt.systemPrompt.tokens + prompt.tools.tokens };
       }
       return transformed;
     };
@@ -245,14 +260,7 @@ export class ContextWindowController {
     const legacy = session.agent.prepareNextTurn;
     session.agent.prepareNextTurnWithContext = async (turn, signal) => {
       this.disableAutomaticCompaction();
-      const fresh = this.refreshPending;
-      this.refreshPending = false;
-      const input = fresh ? { ...turn, context: { ...turn.context, messages: session.agent.state.messages.slice() } } : turn;
-      const update = previous ? await previous.call(session.agent, input, signal) : await legacy?.call(session.agent, signal);
-      const context = update?.context ?? input.context;
-      this.preparedPrompt = { systemPrompt: fingerprint(context.systemPrompt), tools: this.toolSchemas(context.tools),
-        modelKey: modelIdentity(update?.model ?? session.model) };
-      return fresh ? { ...update, context } : update;
+      return previous ? await previous.call(session.agent, turn, signal) : await legacy?.call(session.agent, signal);
     };
   }
 
@@ -272,6 +280,7 @@ export class ContextWindowController {
     const branch = session.sessionManager.getBranch();
     const index = branch.findLastIndex(isBoundary);
     this.windowId = index < 0 ? null : branch[index]!.id;
+    this.windowHeader = undefined;
     this.generation++;
     this.usageFloor = 0;
     this.modelKey = modelIdentity(session.model);
@@ -279,28 +288,57 @@ export class ContextWindowController {
     this.preparedPrompt = undefined;
     this.usageSnapshots = new WeakMap();
     this.latestUsageSnapshot = undefined;
-    if (index < 0) { this.restoreUsageFloor(branch); return; }
+    // Validate now so tree and session events report a corrupt boundary. Every
+    // request validates again and fails closed.
+    if (index >= 0) this.activeWindow();
+    this.restoreUsageFloor(branch);
+  }
+  /**
+   * The request messages of the active window, or undefined without a boundary.
+   * The projection is authoritative: pi builds every request from it.
+   */
+  private activeWindow(projection?: SessionProjection): AgentMessage[] | undefined {
+    const manager = this.requireSession().sessionManager;
+    const branch = manager.getBranch();
+    const index = branch.findLastIndex(isBoundary);
+    if (index < 0) return undefined;
     const boundary = branch[index]!;
-    if (boundary.type !== "custom") return;
-    let data: BoundaryData;
-    try { data = boundaryData(boundary.data); }
-    catch (error) {
-      // A tree-event handler can fail after pi has restored unfiltered messages.
-      // Leave no old-window messages available even if its caller catches errors.
-      session.agent.state.messages = [];
-      this.refreshPending = true;
-      throw error;
+    if (boundary.type !== "custom") return undefined;
+    let header = this.windowHeader?.id === boundary.id ? this.windowHeader.message : undefined;
+    if (!header) {
+      const data = boundaryData(boundary.data);
+      const latestUser = branch.slice(0, index).findLast((entry) => entry.type === "message" && entry.message.role === "user");
+      header = createHeader(boundary.id, data.handoff, { userId: latestUser?.id, previousId: boundary.parentId },
+        this.recoveryGuidance());
+      // Keep the header bytes stable for the whole window. Tool changes after
+      // rollover must not rewrite the start of every later request.
+      this.windowHeader = { id: boundary.id, message: header };
     }
     // Legacy sessions can contain a later compaction. Filter its kept entries
     // at the boundary, but never discard the boundary's literal handoff.
     const activeIds = new Set(branch.slice(index + 1).map((entry) => entry.id));
-    const entries = session.sessionManager.buildContextEntries().filter((entry) => activeIds.has(entry.id));
-    const latestUser = branch.slice(0, index).findLast((entry) => entry.type === "message" && entry.message.role === "user");
-    session.agent.state.messages = [header(boundary.id, data.handoff, {
-      userId: latestUser?.id, previousId: boundary.parentId,
-    }, this.recoveryGuidance()), ...entries.flatMap(sessionEntryToContextMessages)];
-    this.restoreUsageFloor(branch);
-    this.refreshPending = true;
+    projection ??= manager.buildSessionProjection();
+    const archived = projection.entries.filter((entry) => !activeIds.has(entry.sourceEntry.id)).flatMap((entry) => entry.messages);
+    const active = projection.entries.filter((entry) => activeIds.has(entry.sourceEntry.id)).flatMap((entry) => entry.messages);
+    // Archived system messages still define the prompt and tools that apply.
+    const system = getCurrentSystemMessage(transcript(archived.filter((message) => message.role === "system")));
+    return [...(system ? [system as AgentMessage] : []), header, ...active];
+  }
+  private windowRequest(input: AgentMessage[]): AgentMessage[] {
+    const projection = this.requireSession().sessionManager.buildSessionProjection();
+    const active = this.activeWindow(projection);
+    if (!active) return input;
+    // Request input must be the persisted projection. Refuse an unexpected
+    // shape rather than send messages from an archived window.
+    if (conversation(input).length !== conversation(projection.messages).length) {
+      throw new Error("PUM context-window request does not match the persisted session. Refusing to send older context.");
+    }
+    return active;
+  }
+  /** Conversation messages that the next request of the active window contains. */
+  private activeConversation(): AgentMessage[] {
+    const projection = this.requireSession().sessionManager.buildSessionProjection();
+    return conversation(this.activeWindow(projection) ?? projection.messages);
   }
   private restoreUsageFloor(branch: SessionEntry[]): void {
     const change = branch.findLastIndex((entry) => entry.type === "model_change" || entry.type === "compaction");
@@ -309,7 +347,7 @@ export class ContextWindowController {
     // identity fallback for runtimes that copy their state on restoration.
     const older = new Set(branch.slice(0, change).filter((entry) => entry.type === "message")
       .map((entry) => JSON.stringify(entry.message)));
-    const messages = this.requireSession().agent.state.messages;
+    const messages = this.activeConversation();
     for (let index = 0; index < messages.length; index++) {
       if (older.has(JSON.stringify(messages[index]))) this.usageFloor = index + 1;
     }
@@ -349,7 +387,7 @@ export class ContextWindowController {
     const capacity = model?.contextWindow;
     const branch = session.sessionManager.getBranch();
     const latestUser = branch.findLast((entry) => entry.type === "message" && entry.message.role === "user");
-    const freshTokens = estimateTokens(header("pending", handoff, {
+    const freshTokens = estimateTokens(createHeader("pending", handoff, {
       userId: latestUser?.id, previousId: session.sessionManager.getLeafId(),
     }, this.recoveryGuidance())) + this.overheadTokens();
     const configuredReserve = this.reserveTokens();
@@ -377,7 +415,7 @@ export class ContextWindowController {
     const factor = typeof meter.calibrationFactor === "number" ? meter.calibrationFactor : 1;
     return Math.max(0, Math.floor(available / factor) - CONTEXT_MESSAGE_TOKENS);
   }
-  private toolSchemas(tools = this.requireSession().agent.state.tools): EstimateFingerprint {
+  private toolSchemas(tools: readonly Tool[] = this.requireSession().agent.state.tools): EstimateFingerprint {
     const schema = fingerprint(JSON.stringify(tools.map((tool) => ({
       name: tool.name, description: tool.description, parameters: tool.parameters,
     }))));
@@ -408,7 +446,7 @@ export class ContextWindowController {
   private remaining(): Record<string, unknown> {
     const session = this.requireSession();
     const model = session.model;
-    const messages = session.agent.state.messages;
+    const messages = this.activeConversation();
     const key = modelIdentity(model);
     if (key !== this.modelKey) { this.modelKey = key; this.generation++; this.usageFloor = messages.length; }
     let usageIndex = -1;

package/src/headless.ts

@@ -12,7 +12,6 @@ import { conversationBranchState } from "./conversation-branch";
 import { isPlanModeActive, planModeExtension } from "./plan-mode";
 import { createFilesystemSandboxExtension } from "./filesystem-sandbox";
 import { bindFileCheckpointSession, createFileCheckpointExtension } from "./file-checkpoints";
-import { installModelCatalogFallbacks } from "./model-catalog";
 import { AGENT_DIR, AUTH_PATH, MODELS_PATH } from "./config";
 import { createMemoryExtension, hasMemoryContextExtension, MEMORY_EDIT_TOOL_NAME, MEMORY_READ_TOOL_NAME } from "./memory";
 import { ContextWindowController, CONTEXT_TOOL_NAMES } from "./context-window";
@@ -172,7 +171,6 @@ async function runPromptSession(
     authPath: AUTH_PATH,
     modelsPath: MODELS_PATH,
   });
-  installModelCatalogFallbacks(modelRuntime);
   if ((await modelRuntime.getAvailable()).length === 0) {
     process.stderr.write("pum: no provider is available. Run 'pum login' first.\n");
     return 1;

package/src/main.tsx

@@ -24,7 +24,6 @@ import { checkPathsForProject, loadSettings } from "./settings";
 import { setBashOutputSettingsIfPresent } from "./bash-output";
 import { bindSearchSession, installWebSearch, revokeSearchSession, webSearch } from "./web-search";
 import { bindRuntimeSettingsActivity, isRuntimeIdle, runtimeSettings } from "./runtime-settings";
-import { installModelCatalogFallbacks } from "./model-catalog";
 import { identityExtension } from "./identity";
 import { setWritingStyle, writingStyleExtension } from "./writing-style";
 import { checkModePromptExtension, setSandboxModeSource } from "./check-mode-prompt";
@@ -112,7 +111,6 @@ export async function start(
     authPath: AUTH_PATH,
     modelsPath: MODELS_PATH,
   });
-  installModelCatalogFallbacks(modelRuntime);
   const loginRequired = options.login || (await modelRuntime.getAvailable()).length === 0;
 
   const settings = loadSettings();

package/src/project-validation.ts

@@ -129,7 +129,6 @@ export class ProjectValidationController {
   private generation = 0;
   private batchHasMutations = false;
   private latest?: ValidationEvidence;
-  private refreshEvidence = false;
   private unbindHooks?: () => void;
   private readonly cwd: string;
   private readonly readonly: boolean;
@@ -187,30 +186,17 @@ export class ProjectValidationController {
     liveControllers.set(session.sessionId, this);
     const dispose = session.dispose.bind(session);
     session.dispose = () => { this.dispose(); dispose(); };
-    // Agent-core owns a separate context snapshot. SDK custom-message persistence
-    // does not refresh that snapshot unless compaction ran. Refresh only after our
-    // turn-end evidence flushed, before delegating to existing context/compaction.
-    const prepare = session.agent.prepareNextTurnWithContext;
-    const legacy = session.agent.prepareNextTurn;
-    const prepareWrapper: NonNullable<typeof session.agent.prepareNextTurnWithContext> = async (turn, signal) => {
-      if (this.retired) return prepare ? await prepare.call(session.agent, turn, signal) : legacy ? await legacy.call(session.agent, signal) : undefined;
-      signal?.throwIfAborted();
-      const refresh = this.refreshEvidence;
-      this.refreshEvidence = false;
-      const input = refresh ? { ...turn, context: { ...turn.context, messages: session.agent.state.messages.slice() } } : turn;
-      const update = prepare ? await prepare.call(session.agent, input, signal) : await legacy?.call(session.agent, signal);
-      return refresh ? { ...update, context: update?.context ?? input.context } : update;
+    // pi dispatches turn_end, and so runs validation, inside its finishTurn hook.
+    // Delegate first, then end the run when that batch was cancelled.
+    const finish = session.agent.finishTurn;
+    const finishWrapper: NonNullable<typeof session.agent.finishTurn> = async (turn, signal) => {
+      const decision = await finish?.call(session.agent, turn, signal);
+      if (!this.retired && signal?.aborted) return { action: "end" };
+      return decision ?? undefined;
     };
-    session.agent.prepareNextTurnWithContext = prepareWrapper;
-    const stop = session.agent.shouldStopAfterTurn;
-    const stopWrapper: NonNullable<typeof session.agent.shouldStopAfterTurn> = async (turn, signal) => {
-      if (!this.retired && signal?.aborted) return true;
-      return await stop?.call(session.agent, turn, signal) ?? false;
-    };
-    session.agent.shouldStopAfterTurn = stopWrapper;
+    session.agent.finishTurn = finishWrapper;
     this.unbindHooks = () => {
-      if (session.agent.prepareNextTurnWithContext === prepareWrapper) session.agent.prepareNextTurnWithContext = prepare;
-      if (session.agent.shouldStopAfterTurn === stopWrapper) session.agent.shouldStopAfterTurn = stop;
+      if (session.agent.finishTurn === finishWrapper) session.agent.finishTurn = finish;
     };
   }
   extension(): InlineExtension {
@@ -241,7 +227,6 @@ export class ProjectValidationController {
     this.latest = evidence;
     if (this.retired || !this.session) return;
     await this.session.sendCustomMessage({ customType: VALIDATION_CUSTOM_TYPE, content: validationEvidenceText(evidence), display: true, details: evidence }, { triggerTurn: false });
-    this.refreshEvidence = true;
   }
   private stillApproved(proposal: Proposal, generation: number): boolean {
     if (this.retired || this.proposal !== proposal || this.generation !== generation) return false;
@@ -290,7 +275,7 @@ export class ProjectValidationController {
           const tool = session.agent.state.tools.find((entry) => entry.name === "bash");
           if (!tool || !session.agent.beforeToolCall) throw new Error("Checked Bash is unavailable.");
           const { id, args } = createSyntheticCheckCall({ command: command.command, timeout: command.timeoutSeconds, max_bytes: OUTPUT_BYTES });
-          const context = { systemPrompt: session.agent.state.systemPrompt, messages: session.agent.state.messages, tools: session.agent.state.tools };
+          const context = { messages: session.agent.state.messages, tools: session.agent.state.tools };
           // Exactly the session's Check hooks and native-sandbox registered Bash.
           // Never executeBash(): that API deliberately bypasses model Check policy.
           const toolCall = { type: "toolCall" as const, id, name: "bash", arguments: args };

package/src/runtime-settings.ts

@@ -143,7 +143,7 @@ export function bindRuntimeSettingsActivity(session: AgentSession, coordinator =
   // an older run's extension hook. Async scope follows the SDK's entire
   // _runAgentPrompt (including retry/queued continuations and true settlement).
   // Never settle by session key: extensions run before ordinary subscribers.
-  type Admission = { epoch: number; started: boolean; released: boolean; parent?: Admission; release: () => void };
+  type Admission = { epoch: number; started: boolean; released: boolean; parent?: Admission; outer?: Admission; release: () => void };
   let epoch = 0;
   let disposed = false;
   let frozen = false;
@@ -170,27 +170,36 @@ export function bindRuntimeSettingsActivity(session: AgentSession, coordinator =
   // compatibility lease separate; unscoped events cannot release scoped work.
   let unscoped: Admission | undefined = session.isStreaming || session.agent?.state?.isStreaming ? reserve() : undefined;
   if (unscoped) unscoped.started = true;
+  // The async scope in which the unscoped lease started. Only a settled event
+  // from that same scope ends it.
+  let unscopedScope: Admission | undefined;
   const unsubscribe = session.subscribe((event) => {
     const admission = scopes.getStore();
     // A cancelled preflight may unwind after a newer accepted prompt starts.
     // Its SDK finally still emits settled; that event does not own the new run.
     if (disposed) return;
+    // pi defers a run requested from agent_settled until those handlers finish.
+    // It starts in the settled admission's scope, after that admission released,
+    // and needs its own lease until its own settled event in that scope.
+    const leaseRun = (scope: Admission | undefined) => {
+      if (!unscoped) { unscoped = reserve(); unscopedScope = scope; }
+      unscoped.started = true;
+    };
     if (event.type === "agent_start") {
-      if (admission) {
-        if (admission.epoch === epoch && !admission.released) {
+      if (admission && !admission.released) {
+        if (admission.epoch === epoch) {
           admission.started = true;
           if (admission.parent && !admission.parent.released) admission.parent.started = true;
+          if (admission.outer) leaseRun(admission.outer);
         }
-      } else {
-        unscoped ??= reserve();
-        unscoped.started = true;
-      }
+      } else if (!admission || admission.epoch === epoch) leaseRun(admission);
     } else if (event.type === "agent_settled") {
-      if (admission) admission.release();
-      else {
+      if (admission && !admission.released) admission.release();
+      else if (unscoped && unscopedScope === admission) {
         const settled = unscoped;
         unscoped = undefined;
-        settled?.release();
+        unscopedScope = undefined;
+        settled.release();
       }
     }
   });
@@ -222,6 +231,7 @@ export function bindRuntimeSettingsActivity(session: AgentSession, coordinator =
     // Its promise, not the session's shared idle flag, proves completion.
     direct.started = true;
     if (admission && !admission.released) direct.parent = admission;
+    else if (admission && admission.epoch === epoch) direct.outer = admission;
     try {
       if (disposed || frozen || direct.released || direct.epoch !== epoch) throw new Error("Runtime admission was cancelled");
       return await scopes.run(direct, run);
@@ -310,7 +320,7 @@ export function bindRuntimeSettingsActivity(session: AgentSession, coordinator =
       // SDK waitForIdle can return early after a stale preflight finally resets
       // isStreaming. Scoped execution still needs its own settled/promise proof.
       cancelledUnscoped?.release();
-      if (unscoped?.released) unscoped = undefined;
+      if (unscoped?.released) { unscoped = undefined; unscopedScope = undefined; }
     } finally {
       for (const admission of cancelled) if (!admission.started) admission.release();
     }
@@ -323,6 +333,7 @@ export function bindRuntimeSettingsActivity(session: AgentSession, coordinator =
     finally {
       unsubscribe();
       unscoped = undefined;
+      unscopedScope = undefined;
       for (const admission of admissions) admission.release();
       admissions.clear();
       for (const release of shellReleases) release();

package/src/tool-groups.ts

@@ -1,3 +1,5 @@
+import type { AgentMessage } from "@earendil-works/pi-agent-core";
+import { getCurrentSystemMessage, type Message } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, InlineExtension } from "@earendil-works/pi-coding-agent";
 import { companionFileFor, readCompanion, writeCompanion } from "./session-companion";
 import { Type } from "typebox";
@@ -414,11 +416,33 @@ export class ToolGroupsController {
     });
   }
 
+  /** Sort tools into the canonical role-allowlist order. Unknown tools keep their order at the end. */
+  canonicalOrder<T extends { name: string }>(tools: readonly T[]): T[] {
+    const allowlist = this.audience === "main" ? mainAllowedToolNames(this.isReadonly) : childAllowedToolNames(this.isReadonly);
+    const rank = new Map(allowlist.map((name, index) => [name, index]));
+    return tools.map((tool, index) => ({ tool, index }))
+      .sort((a, b) => (rank.get(a.tool.name) ?? allowlist.length) - (rank.get(b.tool.name) ?? allowlist.length) || a.index - b.index)
+      .map(({ tool }) => tool);
+  }
+
   /** The inline extension that registers `enable_tools` for one session. */
   extension(): InlineExtension {
     return {
       name: `pum-tool-groups-${this.audience}`,
-      factory: (pi) => this.registerTool(pi),
+      factory: (pi) => {
+        this.registerTool(pi);
+        // pi declares revealed tools in the transcript in reveal order. Send the
+        // canonical order, so that a request does not depend on that history.
+        pi.on("context_with_system", (event) => {
+          const head = getCurrentSystemMessage(event.messages as Message[]);
+          const tools = head?.toolsAdded;
+          if (!head || !tools) return undefined;
+          const ordered = this.canonicalOrder(tools);
+          if (ordered.every((tool, index) => tool === tools[index])) return undefined;
+          return { messages: [{ ...head, toolsAdded: ordered } as AgentMessage,
+            ...event.messages.filter((message) => message.role !== "system")] };
+        });
+      },
     };
   }
 }

package/src/model-catalog.ts

@@ -1,47 +0,0 @@
-import type { Model, Provider } from "@earendil-works/pi-ai";
-import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
-
-const ASTRA_ID = "gpt-6-astra";
-
-/** Temporary catalog fallback until pi includes Astra. Never replace upstream metadata. */
-export function withAstraModel(base: Provider): Provider {
-  if (base.id !== "openai" && base.id !== "openai-codex") return base;
-  if (base.getModels().some((model) => model.id === ASTRA_ID)) return base;
-  const codex = base.id === "openai-codex";
-  // https://developers.openai.com/api/docs/models/gpt-6-astra
-  const astra: Model<any> = {
-    id: ASTRA_ID,
-    name: "GPT-6 Astra",
-    provider: base.id,
-    api: codex ? "openai-codex-responses" : "openai-responses",
-    baseUrl: base.baseUrl ?? (codex ? "https://chatgpt.com/backend-api" : "https://api.openai.com/v1"),
-    reasoning: true,
-    input: ["text", "image"],
-    // Keep pi's conservative Codex context budget until that transport publishes one.
-    contextWindow: codex ? 272000 : 1050000,
-    maxTokens: 128000,
-    cost: {
-      input: 10, output: 50, cacheRead: 1, cacheWrite: 12.5,
-      tiers: [{ inputTokensAbove: 272000, input: 20, output: 75, cacheRead: 2, cacheWrite: 25 }],
-    },
-    thinkingLevelMap: {
-      off: null, minimal: null, low: "low", medium: "medium",
-      high: "high", xhigh: "xhigh", max: "max",
-    },
-  };
-  const wrapped: Provider = Object.create(base);
-  wrapped.getModels = () => {
-    const models = base.getModels();
-    return models.some((model) => model.id === ASTRA_ID) ? models : [...models, astra];
-  };
-  return wrapped;
-}
-
-export function installModelCatalogFallbacks(runtime: ModelRuntime): void {
-  for (const id of ["openai", "openai-codex"]) {
-    const base = runtime.getProvider(id);
-    if (!base) continue;
-    const provider = withAstraModel(base);
-    if (provider !== base) runtime.registerNativeProvider(provider);
-  }
-}