bermudis-pi-goodies 0.2.0 → 0.4.0

package/README.md

@@ -1,16 +1,17 @@
 # bermudis-pi-goodies
 
 A bundle of small, frequently-used [Pi](https://github.com/earendil-works/pi)
-extensions. One entry point, nine independent features.
+extensions. One entry point, ten independent features.
 
 | Feature | Command / hook | What it does |
 |---------|----------------|--------------|
 | `copy-with-model` | `/copy-with-model` | Copy last assistant message to the clipboard in a code fence tagged with the model name. |
+| `copy-trajectory` | `/copy-trajectory [thinking]` | Copy the whole conversation (user + assistant text, tool calls stripped) to the clipboard; `thinking` also includes assistant thinking blocks. |
 | `name-with-ai` | `/name-with-ai [name]` | Generate a short session name from the first user message (or set one manually). |
 | `zed` | `/z` | Open Zed editor on the current working directory. |
 | `prefer-tools` | hook (no command) | Nudge toward modern CLIs: `rg` over `grep`, `fd` over `find`, `uv` over bare `python`/`pip`/`pytest`/`mypy`. |
 | `model-thinking` | hook + `/model-thinking` | Apply provider/model thinking defaults and explicitly save per-model defaults. |
-| `fixed-defaults` | hook + `/fixed-defaults` | Keep the global startup provider, model, and thinking defaults fixed while allowing in-session model changes; `/fixed-defaults set` pins the current model and thinking level. |
+| `fixed-defaults` | hook + `/fixed-defaults` | Keep the global startup provider and model fixed while allowing in-session model changes; `/fixed-defaults set` pins the current model. |
 | `kilo` | provider | Access Kilo Gateway models via `/login kilo` or `KILO_API_KEY`. |
 | `provider-balance` | footer (no command) | Show remaining Kilo or OpenRouter credits, z.ai token-plan quota, or OpenAI Codex quota on the right side of the working-directory footer line. |
 | `tps` | hook (no command) | Notify tokens/sec and in/out/cache token usage at the end of each agent turn. |
@@ -20,7 +21,7 @@ extensions. One entry point, nine independent features.
 After publishing the package to npm:
 
 ```bash
-pi install npm:bermudis-pi-goodies@0.2.0
+pi install npm:bermudis-pi-goodies@0.4.0
 ```
 
 Remove any old `bermudis-pi-goodies.ts` symlink before reloading Pi. Each
@@ -52,35 +53,47 @@ config and overwrites an existing entry. Manual thinking-level changes in Pi do
 not modify this file. All current Pi levels are accepted:
 `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, and `max`.
 `/model-thinking` shows the active resolution and config path;
-`/model-thinking reset` deletes the whole config.
+`/model-thinking reset` deletes the whole config. A malformed config is reported
+and ignored; `/model-thinking set` refuses to overwrite it until you repair the
+file or reset it.
 
-## Fixed startup defaults
+## Fixed startup model
 
 Pi normally saves the last model and thinking level selected in the global
-settings file. The bundle pins those cross-session defaults to:
+settings file. `fixed-defaults` pins only the cross-session provider and model;
+`model-thinking` is the sole owner of model-specific thinking levels.
+
+Create `~/.pi/agent/fixed-defaults.json` to pin a startup model:
 
 ```json
 {
-  "defaultProvider": "openai-codex",
-  "defaultModel": "gpt-5.6-luna",
-  "defaultThinkingLevel": "max"
+  "provider": "openai-codex",
+  "model": "gpt-5.6-luna"
 }
 ```
 
 Selecting a different model still changes the active session and its transcript;
-`fixed-defaults` only restores the startup values after Pi persists a selection.
-
-The pinned values are the built-ins above, optionally overridden per field by
-`~/.pi/agent/fixed-defaults.json` — omit a field to keep the built-in value for
-it, and hand edits are picked up without a reload. Manage it from Pi:
-
-- `/fixed-defaults set` — pin the currently active model and thinking level as
-  the new startup defaults (written to the override file and applied to
-  `settings.json` immediately).
-- `/fixed-defaults` — show the effective pin, the active model, and the
-  override file path.
-- `/fixed-defaults reset` — delete the override file and fall back to the
-  built-in values.
+`fixed-defaults` restores the startup model after Pi persists a selection. Pi
+chooses the initial model before extensions receive `session_start`, so if you
+manually create or edit a pin for B while settings still name A, the current
+session remains on A and B starts with the next fresh session. Resuming an
+existing session restores that session's model instead.
+
+Older config files may contain `thinkingLevel`; that field is accepted for
+compatibility but ignored and should be managed in `model-thinking.json` instead.
+`fixed-defaults` logs a warning and shows the migration in its status when it
+finds the legacy field. The `/fixed-defaults set` command rewrites the file in
+the provider/model-only format.
+
+Manage the pin from Pi:
+
+- `/fixed-defaults set` — pin the currently active model as the startup model
+  (written to the override file and applied to `settings.json` immediately).
+- `/fixed-defaults` — show the active model, pinned startup model, and override
+  path.
+- `/fixed-defaults reset` — save the currently active model as Pi's last
+  selection, then delete the override file and stop pinning. With no active
+  model, it refuses to remove the pin.
 
 ## Provider and balance details
 

package/copy-trajectory.ts

@@ -0,0 +1,166 @@
+/**
+ * copy-trajectory — /copy-trajectory
+ *
+ * Copies the current session's trajectory to the system clipboard as plain
+ * text, keeping only the human-readable conversation: user messages and
+ * assistant text. Tool calls, tool results, and session metadata are stripped.
+ *
+ *   /copy-trajectory            copy user + assistant text
+ *   /copy-trajectory thinking   also include assistant thinking blocks
+ *
+ * Uses ctx.sessionManager.getBranch() for the active (compaction-aware) branch
+ * and @earendil-works/pi-coding-agent's copyToClipboard for the clipboard write.
+ */
+
+import {
+  copyToClipboard,
+  type ExtensionAPI,
+  type SessionEntry,
+} from "@earendil-works/pi-coding-agent";
+
+const isRecord = (v: unknown): v is Record<string, unknown> =>
+  typeof v === "object" && v !== null;
+
+/** Extract `text` content blocks from a message body (string or block array). */
+const extractTextParts = (content: unknown): string[] => {
+  if (typeof content === "string") return [content];
+  if (!Array.isArray(content)) return [];
+  const parts: string[] = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (block.type === "text" && typeof block.text === "string") {
+      parts.push(block.text);
+    }
+  }
+  return parts;
+};
+
+/** Extract `thinking` content blocks from an assistant message body. */
+const extractThinkingParts = (content: unknown): string[] => {
+  if (!Array.isArray(content)) return [];
+  const parts: string[] = [];
+  for (const block of content) {
+    if (!isRecord(block)) continue;
+    if (block.type === "thinking" && typeof block.thinking === "string") {
+      parts.push(block.thinking);
+    }
+  }
+  return parts;
+};
+
+type Turn = {
+  role: "User" | "Assistant";
+  /** For assistant turns: the model that actually served the reply (or the
+   *  requested model when the provider doesn't report the resolved one). */
+  model?: string;
+  body: string;
+};
+
+/** Build the readable turns from a branch of session entries. */
+function buildTrajectory(
+  entries: readonly SessionEntry[],
+  includeThinking: boolean,
+): Turn[] {
+  const turns: Turn[] = [];
+
+  for (const entry of entries) {
+    // getBranch() returns the full SessionEntry union; the `message` member
+    // is discriminated by `type: "message"`.
+    if (entry.type !== "message") continue;
+    const message = entry.message;
+    if (message.role !== "user" && message.role !== "assistant") continue;
+
+    const chunks: string[] = [...extractTextParts(message.content)];
+
+    let model: string | undefined;
+    if (message.role === "assistant") {
+      // AssistantMessage carries both the requested `model` and, when the
+      // provider echoes it back, `responseModel` (the model that actually ran).
+      model = message.responseModel ?? message.model;
+      if (includeThinking) {
+        for (const t of extractThinkingParts(message.content)) {
+          chunks.push(
+            t
+              .split("\n")
+              .map((line) => `> ${line}`)
+              .join("\n"),
+          );
+        }
+      }
+    }
+
+    const body = chunks.join("\n").trim();
+    if (!body) continue; // skip empty / tool-only turns
+
+    turns.push({
+      role: message.role === "user" ? "User" : "Assistant",
+      model,
+      body,
+    });
+  }
+
+  return turns;
+}
+
+const renderTrajectory = (turns: readonly Turn[]): string =>
+  turns
+    .map((t) => {
+      const header =
+        t.role === "Assistant" && t.model
+          ? `## Assistant (${t.model})`
+          : `## ${t.role}`;
+      return `${header}\n\n${t.body}`;
+    })
+    .join("\n\n");
+
+export default function (pi: ExtensionAPI) {
+  pi.registerCommand("copy-trajectory", {
+    description:
+      "Copy the conversation (user + assistant text, no tool calls) to the clipboard",
+    getArgumentCompletions: (prefix) => {
+      const opts = ["thinking"].filter((o) => o.startsWith(prefix));
+      return opts.length > 0 ? opts.map((o) => ({ value: o, label: o })) : null;
+    },
+    handler: async (args, ctx) => {
+      // Don't snapshot a half-streamed message.
+      await ctx.waitForIdle();
+
+      const arg = args.trim();
+      if (arg !== "" && arg !== "thinking") {
+        ctx.ui.notify(
+          `Unknown argument ${JSON.stringify(arg)}. Usage: /copy-trajectory [thinking]`,
+          "warning",
+        );
+        return;
+      }
+      const includeThinking = arg === "thinking";
+
+      const turns = buildTrajectory(
+        ctx.sessionManager.getBranch(),
+        includeThinking,
+      );
+
+      if (turns.length === 0) {
+        ctx.ui.notify("No messages to copy yet", "warning");
+        return;
+      }
+
+      const text = renderTrajectory(turns);
+
+      try {
+        await copyToClipboard(text);
+      } catch (err) {
+        ctx.ui.notify(
+          `Failed to copy: ${err instanceof Error ? err.message : String(err)}`,
+          "error",
+        );
+        return;
+      }
+
+      ctx.ui.notify(
+        `Copied ${turns.length} message${turns.length === 1 ? "" : "s"} (${text.length.toLocaleString()} chars) to clipboard`,
+        "info",
+      );
+    },
+  });
+}

package/fixed-defaults.ts

@@ -4,38 +4,27 @@ import {
   type ExtensionAPI,
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import {
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, join } from "node:path";
+  describeError,
+  unlinkIfPresent,
+  writeJsonFileAtomic,
+} from "./json-file.ts";
 
 const CONFIG_FILENAME = "fixed-defaults.json";
-const ALL_LEVELS = [
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max",
-] as const;
-
-type ThinkingLevel = ReturnType<ExtensionAPI["getThinkingLevel"]>;
-
 /**
- * Values read from the override file. `thinkingLevel` may layer independently;
- * `provider` and `model` are a coupled pair — a model id is meaningless without
- * its provider, so both must be present if either is. Missing fields fall back
- * to the built-in defaults.
+ * Values read from the override file. `provider` and `model` are a coupled
+ * pair — a model id is meaningless without its provider, so both must be
+ * present if either is.
+ *
+ * `thinkingLevel` was accepted by older versions. It is deliberately ignored
+ * for compatibility; model-thinking.ts is now the sole owner of thinking
+ * policy.
  */
 interface FixedDefaultsOverride {
   provider?: string;
   model?: string;
-  thinkingLevel?: ThinkingLevel;
 }
 
 interface FixedDefaultsOptions {
@@ -45,17 +34,6 @@ interface FixedDefaultsOptions {
   configPath?: string;
 }
 
-function describeError(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-function isThinkingLevel(value: unknown): value is ThinkingLevel {
-  return (
-    typeof value === "string" &&
-    (ALL_LEVELS as readonly string[]).includes(value)
-  );
-}
-
 function parseOverride(value: unknown): FixedDefaultsOverride {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("the top level must be an object");
@@ -82,18 +60,11 @@ function parseOverride(value: unknown): FixedDefaultsOverride {
     }
     override.model = input.model;
   }
-  if (input.thinkingLevel !== undefined) {
-    if (!isThinkingLevel(input.thinkingLevel)) {
-      throw new Error(
-        `\`thinkingLevel\` must be one of: ${ALL_LEVELS.join(", ")}`,
-      );
-    }
-    override.thinkingLevel = input.thinkingLevel;
-  }
 
   // provider and model are a coupled pair — a model id is meaningless without
   // its provider. Require both if either is present so a hand-edited partial
-  // file can't pin a broken default. thinkingLevel may still layer alone.
+  // file can't pin a broken default. The legacy thinkingLevel field is
+  // intentionally ignored; model-thinking.ts owns thinking policy.
   if (
     (override.provider !== undefined && override.model === undefined) ||
     (override.model !== undefined && override.provider === undefined)
@@ -106,6 +77,15 @@ function parseOverride(value: unknown): FixedDefaultsOverride {
   return override;
 }
 
+function hasLegacyThinkingLevel(value: unknown): boolean {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.prototype.hasOwnProperty.call(value, "thinkingLevel")
+  );
+}
+
 /**
  * Read/write the override file. Reads are uncached (the file is tiny and the
  * events are rare), so hand edits are picked up without a reload. Writes are
@@ -113,27 +93,43 @@ function parseOverride(value: unknown): FixedDefaultsOverride {
  */
 class DefaultsStore {
   readonly path: string;
+  private warnedLegacyThinkingLevel = false;
 
   constructor(path: string) {
     this.path = path;
   }
 
-  /** Load the override; returns { override: {}, error: null } when missing. */
+  /** Load the override; an absent file is a valid, inactive configuration. */
   load(): LoadResult {
     let raw: string;
     try {
       raw = readFileSync(this.path, "utf8");
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code === "ENOENT") {
-        return { override: {}, error: null };
+        return {
+          present: false,
+          override: {},
+          error: null,
+          legacyThinkingLevel: false,
+        };
       }
       throw error;
     }
 
     try {
+      const value = JSON.parse(raw) as unknown;
+      const legacyThinkingLevel = hasLegacyThinkingLevel(value);
+      if (legacyThinkingLevel && !this.warnedLegacyThinkingLevel) {
+        console.warn(
+          `[fixed-defaults] legacy thinkingLevel found in ${this.path}; it is ignored. Add the policy to model-thinking.json instead.`,
+        );
+        this.warnedLegacyThinkingLevel = true;
+      }
       return {
-        override: parseOverride(JSON.parse(raw) as unknown),
+        present: true,
+        override: parseOverride(value),
         error: null,
+        legacyThinkingLevel,
       };
     } catch (error) {
       const message = describeError(error);
@@ -141,61 +137,51 @@ class DefaultsStore {
         `[fixed-defaults] invalid config at ${this.path}:`,
         message,
       );
-      return { override: {}, error: message };
+      return {
+        present: true,
+        override: {},
+        error: message,
+        legacyThinkingLevel: false,
+      };
     }
   }
 
   save(override: FixedDefaultsOverride): void {
-    mkdirSync(dirname(this.path), { recursive: true });
-    const temporaryPath = `${this.path}.${process.pid}.${Date.now()}.tmp`;
-
-    try {
-      writeFileSync(temporaryPath, `${JSON.stringify(override, null, 2)}\n`, {
-        encoding: "utf8",
-        mode: 0o600,
-      });
-      renameSync(temporaryPath, this.path);
-    } catch (error) {
-      try {
-        unlinkSync(temporaryPath);
-      } catch {
-        // The temporary file usually does not exist when the initial write failed.
-      }
-      throw error;
-    }
+    writeJsonFileAtomic(this.path, override);
+    this.warnedLegacyThinkingLevel = false;
   }
 
-  reset(): boolean {
-    try {
-      unlinkSync(this.path);
-      return true;
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
-      throw error;
-    }
+  reset(): void {
+    // Deletion is intentionally idempotent: if another process removes the
+    // pin after it was loaded, reset has still reached the requested end state.
+    unlinkIfPresent(this.path);
+    this.warnedLegacyThinkingLevel = false;
   }
 }
 
 /** Result of reading the override file: the parsed values plus any error. */
 interface LoadResult {
+  /** Whether the override file existed when it was read. */
+  present: boolean;
   override: FixedDefaultsOverride;
   /** Non-null when the file existed but failed to parse or validate. */
   error: string | null;
+  /** True when an old, ignored thinkingLevel field should be migrated. */
+  legacyThinkingLevel: boolean;
 }
 
 /**
- * Keep Pi's cross-session defaults stable while still allowing model changes in
- * the current session. Pi intentionally saves the last selected model and
- * thinking level, so this runs after those notifications and restores the
- * configured startup defaults in the global settings file.
+ * Keep Pi's cross-session provider/model defaults stable while still allowing
+ * model changes in the current session. Pi intentionally saves the last
+ * selected model, so this runs after model-selection notifications and restores
+ * the configured startup model in the global settings file.
  *
  * The pin lives in `<agentDir>/fixed-defaults.json` and is the sole source of
  * truth — there are no built-in defaults, so with no override file the
  * extension is dormant and Pi's native last-selection behavior is preserved.
- * `thinkingLevel` may layer independently; `provider` and `model` are a
- * coupled pair. `/fixed-defaults set` pins the currently active model and
- * thinking level; `/fixed-defaults reset` stops pinning; `/fixed-defaults`
- * shows the active pin.
+ * `provider` and `model` are a coupled pair. Thinking policy belongs to
+ * model-thinking.ts. `/fixed-defaults set` pins the currently active model;
+ * `/fixed-defaults reset` stops pinning; `/fixed-defaults` shows the active pin.
  */
 export default function fixedDefaults(
   pi: ExtensionAPI,
@@ -207,25 +193,15 @@ export default function fixedDefaults(
   );
   let pending = Promise.resolve();
 
-  async function restore(ctx: ExtensionContext): Promise<void> {
-    const { override, error } = store.load();
-    // A broken or absent override means no pin: leave settings untouched so
-    // Pi's native last-selection behavior is preserved rather than guessed at.
-    if (error) return;
-    const hasModelPin =
-      override.provider !== undefined && override.model !== undefined;
-    const hasThinkingPin = override.thinkingLevel !== undefined;
-    if (!hasModelPin && !hasThinkingPin) return;
-
+  async function persistModel(
+    ctx: ExtensionContext,
+    provider: string,
+    modelId: string,
+  ): Promise<void> {
     const settings = SettingsManager.create(ctx.cwd, agentDir, {
       projectTrusted: ctx.isProjectTrusted(),
     });
-    if (hasModelPin) {
-      settings.setDefaultModelAndProvider(override.provider!, override.model!);
-    }
-    if (hasThinkingPin) {
-      settings.setDefaultThinkingLevel(override.thinkingLevel!);
-    }
+    settings.setDefaultModelAndProvider(provider, modelId);
     await settings.flush();
 
     const errors = settings.drainErrors();
@@ -237,23 +213,47 @@ export default function fixedDefaults(
     }
   }
 
-  function schedule(ctx: ExtensionContext): Promise<void> {
-    const operation = pending.then(() => restore(ctx));
-    // Keep later notifications serviceable after one failed write. The
-    // original operation is still returned so Pi can report that failure.
-    pending = operation.catch((error: unknown) => {
-      console.error("[fixed-defaults] failed to restore defaults:", error);
-    });
-    return operation;
+  async function restore(ctx: ExtensionContext): Promise<void> {
+    const { override, error } = store.load();
+    // A broken or absent override means no pin: leave settings untouched so
+    // Pi's native last-selection behavior is preserved rather than guessed at.
+    if (error) return;
+    const hasModelPin =
+      override.provider !== undefined && override.model !== undefined;
+    if (!hasModelPin) return;
+
+    await persistModel(ctx, override.provider!, override.model!);
+  }
+
+  function enqueue<T>(
+    operation: () => Promise<T>,
+    failureMessage: string,
+  ): Promise<T> {
+    const queued = pending.then(operation);
+    // Log once at the queue boundary, then recover only the internal tail so a
+    // failed write does not prevent later operations. The returned promise
+    // still rejects, allowing commands to notify the user.
+    pending = queued.then(
+      () => undefined,
+      (error: unknown) => {
+        console.error(failureMessage, error);
+      },
+    );
+    return queued;
+  }
+
+  function schedule(
+    ctx: ExtensionContext,
+    failureMessage = "[fixed-defaults] failed to restore defaults:",
+  ): Promise<void> {
+    return enqueue(() => restore(ctx), failureMessage);
   }
 
   pi.on("session_start", (_event, ctx) => schedule(ctx));
   pi.on("model_select", (_event, ctx) => schedule(ctx));
-  pi.on("thinking_level_select", (_event, ctx) => schedule(ctx));
 
   pi.registerCommand("fixed-defaults", {
-    description:
-      "Show, set, or reset the pinned startup model/thinking defaults",
+    description: "Show, set, or reset the pinned startup model",
     handler: async (args, ctx) => {
       const command = args.trim();
 
@@ -267,11 +267,9 @@ export default function fixedDefaults(
           return;
         }
 
-        const level = pi.getThinkingLevel();
         const override: FixedDefaultsOverride = {
           provider: model.provider,
           model: model.id,
-          thinkingLevel: level,
         };
         try {
           store.save(override);
@@ -283,10 +281,9 @@ export default function fixedDefaults(
 
         try {
           // Bring settings.json in line with the new pin right away instead
-          // of waiting for the next model/thinking/session event.
-          await schedule(ctx);
-        } catch (error) {
-          console.error("[fixed-defaults] failed to apply override:", error);
+          // of waiting for the next model/session event.
+          await schedule(ctx, "[fixed-defaults] failed to apply override:");
+        } catch {
           ctx.ui.notify(
             "Defaults saved, but applying them to settings.json failed.",
             "warning",
@@ -295,31 +292,74 @@ export default function fixedDefaults(
         }
 
         ctx.ui.notify(
-          `Pinned ${model.provider}/${model.id} · thinking ${level} as startup defaults`,
+          `Pinned ${model.provider}/${model.id} as the startup model`,
           "info",
         );
         return;
       }
 
       if (command === "reset") {
-        let removed: boolean;
+        type ResetResult =
+          | { status: "missing" }
+          | { status: "removed-inactive" }
+          | { status: "no-active-model" }
+          | {
+              status: "removed";
+              model: NonNullable<ExtensionContext["model"]>;
+            };
+
         try {
-          removed = store.reset();
-        } catch (error) {
-          console.error("[fixed-defaults] failed to reset override:", error);
-          ctx.ui.notify("Failed to reset fixed defaults.", "error");
-          return;
+          const result = await enqueue<ResetResult>(async () => {
+            // Load and validate before touching settings. Invalid, legacy-only,
+            // and partial files are inactive, so remove them without replacing
+            // Pi's last selection with the currently active model.
+            const loaded = store.load();
+            if (!loaded.present) return { status: "missing" };
+
+            const hasModelPin =
+              loaded.error === null &&
+              loaded.override.provider !== undefined &&
+              loaded.override.model !== undefined;
+            if (!hasModelPin) {
+              store.reset();
+              return { status: "removed-inactive" };
+            }
+
+            const model = ctx.model;
+            if (!model) return { status: "no-active-model" };
+
+            // Save the active model before removing the valid pin. Otherwise
+            // the old pinned model remains in settings.json and wins at the
+            // next fresh start.
+            await persistModel(ctx, model.provider, model.id);
+            store.reset();
+            return { status: "removed", model };
+          }, "[fixed-defaults] failed to reset override:");
+
+          if (result.status === "missing") {
+            ctx.ui.notify("No fixed-defaults override file to reset.", "info");
+          } else if (result.status === "removed-inactive") {
+            ctx.ui.notify(
+              "Inactive or invalid fixed-defaults override removed; settings were left unchanged.",
+              "info",
+            );
+          } else if (result.status === "no-active-model") {
+            ctx.ui.notify(
+              "Cannot reset fixed defaults without an active model; the pin was left in place.",
+              "warning",
+            );
+          } else {
+            ctx.ui.notify(
+              `Fixed-defaults pin removed. Pi will use ${result.model.provider}/${result.model.id} as its last selection.`,
+              "info",
+            );
+          }
+        } catch {
+          ctx.ui.notify(
+            "Failed to reset fixed defaults. Pin removal could not be confirmed; settings may already reflect the active model.",
+            "error",
+          );
         }
-
-        // Removing the override makes future events no-ops; there is nothing
-        // to apply to settings.json now. Existing defaults are left as-is so
-        // reset means "stop pinning," not "revert to an earlier state."
-        ctx.ui.notify(
-          removed
-            ? "Fixed-defaults pin removed. Pi will use your last selection."
-            : "No fixed-defaults override file to reset.",
-          "info",
-        );
         return;
       }
 
@@ -328,11 +368,10 @@ export default function fixedDefaults(
         return;
       }
 
-      const { override, error } = store.load();
+      const { override, error, legacyThinkingLevel } = store.load();
       const model = ctx.model;
       const lines = [
         `model: ${model ? `${model.provider}/${model.id}` : "none"}`,
-        `thinking: ${pi.getThinkingLevel()}`,
         "",
       ];
       if (error) {
@@ -344,14 +383,17 @@ export default function fixedDefaults(
           lines.push(`pinned provider: ${override.provider}`);
           lines.push(`pinned model: ${override.model}`);
         }
-        if (override.thinkingLevel !== undefined) {
-          lines.push(`pinned thinking: ${override.thinkingLevel}`);
-        }
+      }
+      if (legacyThinkingLevel) {
+        lines.push(
+          "",
+          "⚠ legacy thinkingLevel is present but ignored; manage it with /model-thinking",
+        );
       }
       lines.push("", `override file: ${store.path}`);
       lines.push(
         "",
-        "run `/fixed-defaults set` to pin the current model and thinking level; `/fixed-defaults reset` to stop pinning",
+        "run `/fixed-defaults set` to pin the current model; `/fixed-defaults reset` to stop pinning",
       );
       const message = lines.join("\n");
 

package/index.ts

@@ -4,16 +4,18 @@
  * Composes independent modules, each registering its own commands/hooks
  * against the shared ExtensionAPI:
  *   - copy-with-model  /copy-with-model  copy last reply tagged with the model
+ *   - copy-trajectory  /copy-trajectory  copy the whole conversation (text only) to the clipboard
  *   - name-with-ai     /name-with-ai     generate a session name via the model
  *   - zed              /z                open Zed on cwd
  *   - prefer-tools     hook              block legacy tools (use trash/rg/fd/uv)
  *   - model-thinking   hook + command    remember thinking levels by provider/model
- *   - fixed-defaults   hook + command    keep startup defaults stable; /fixed-defaults set pins the current model
+ *   - fixed-defaults   hook + command    keep startup provider/model stable; /fixed-defaults set pins the current model
  *   - kilo             provider          access Kilo Gateway models
  *   - provider-balance footer            show Kilo credits or Codex quota in the footer
  *   - tps              hook              notify tokens/sec and usage at each agent turn end
  */
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import copyTrajectory from "./copy-trajectory.ts";
 import copyWithModel from "./copy-with-model.ts";
 import fixedDefaults from "./fixed-defaults.ts";
 import kilo from "./kilo.ts";
@@ -26,6 +28,7 @@ import preferTools from "./prefer-tools.ts";
 
 export default function bermudisPiGoodies(pi: ExtensionAPI): void {
   copyWithModel(pi);
+  copyTrajectory(pi);
   nameWithAi(pi);
   zed(pi);
   preferTools(pi);

package/json-file.ts

@@ -0,0 +1,44 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+export function describeError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+/** Write JSON atomically without exposing a partially written config file. */
+export function writeJsonFileAtomic(path: string, value: unknown): void {
+  mkdirSync(dirname(path), { recursive: true });
+  const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+
+  try {
+    writeFileSync(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, {
+      encoding: "utf8",
+      mode: 0o600,
+    });
+    renameSync(temporaryPath, path);
+  } catch (writeError) {
+    try {
+      unlinkSync(temporaryPath);
+    } catch (cleanupError) {
+      if ((cleanupError as NodeJS.ErrnoException).code !== "ENOENT") {
+        throw new AggregateError(
+          [writeError, cleanupError],
+          `failed to write ${path} and clean up ${temporaryPath}`,
+        );
+      }
+    }
+    throw writeError;
+  }
+}
+
+/** Delete a file if present; surface every error except an absent file. */
+export function unlinkIfPresent(path: string): boolean {
+  try {
+    unlinkSync(path);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    throw error;
+  }
+}

package/model-thinking.ts

@@ -3,15 +3,13 @@ import {
   type ExtensionAPI,
   type ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
+import { readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
 import {
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { dirname, join } from "node:path";
+  describeError,
+  unlinkIfPresent,
+  writeJsonFileAtomic,
+} from "./json-file.ts";
 
 const CONFIG_FILENAME = "model-thinking.json";
 const ALL_LEVELS = [
@@ -99,86 +97,81 @@ function fileStamp(path: string): string | undefined {
   }
 }
 
+interface ConfigLoadResult {
+  config: ModelThinkingConfig;
+  /** Non-null when the file exists but could not be read or validated. */
+  error: string | null;
+}
+
 class ConfigStore {
   readonly path: string;
   private initialized = false;
   private cachedStamp: string | undefined;
-  private cachedConfig: ModelThinkingConfig = {};
+  private cachedResult: ConfigLoadResult = { config: {}, error: null };
 
   constructor(path: string) {
     this.path = path;
   }
 
-  load(): ModelThinkingConfig {
+  load(): ConfigLoadResult {
     let stamp: string | undefined;
     try {
       stamp = fileStamp(this.path);
     } catch (error) {
-      console.error(`[model-thinking] failed to stat ${this.path}:`, error);
-      return {};
+      const message = describeError(error);
+      console.error(`[model-thinking] failed to stat ${this.path}:`, message);
+      return { config: {}, error: message };
     }
 
-    if (this.initialized && stamp === this.cachedStamp) {
-      return this.cachedConfig;
+    // Keep retrying a file that previously failed to load. A repair can leave
+    // its size and mtime unchanged, so an error result must not be cached by
+    // the same stamp as a successful read.
+    if (
+      this.initialized &&
+      stamp === this.cachedStamp &&
+      this.cachedResult.error === null
+    ) {
+      return this.cachedResult;
     }
 
     this.initialized = true;
     this.cachedStamp = stamp;
     if (stamp === undefined) {
-      this.cachedConfig = {};
-      return this.cachedConfig;
+      this.cachedResult = { config: {}, error: null };
+      return this.cachedResult;
     }
 
     try {
-      this.cachedConfig = parseConfig(
-        JSON.parse(readFileSync(this.path, "utf8")) as unknown,
-      );
+      this.cachedResult = {
+        config: parseConfig(
+          JSON.parse(readFileSync(this.path, "utf8")) as unknown,
+        ),
+        error: null,
+      };
     } catch (error) {
+      const message = describeError(error);
       console.error(
         `[model-thinking] invalid config at ${this.path}:`,
-        error instanceof Error ? error.message : error,
+        message,
       );
-      this.cachedConfig = {};
+      this.cachedResult = { config: {}, error: message };
     }
-    return this.cachedConfig;
+    return this.cachedResult;
   }
 
   save(config: ModelThinkingConfig): void {
-    mkdirSync(dirname(this.path), { recursive: true });
-    const temporaryPath = `${this.path}.${process.pid}.${Date.now()}.tmp`;
-
-    try {
-      writeFileSync(temporaryPath, `${JSON.stringify(config, null, 2)}\n`, {
-        encoding: "utf8",
-        mode: 0o600,
-      });
-      renameSync(temporaryPath, this.path);
-    } catch (error) {
-      try {
-        unlinkSync(temporaryPath);
-      } catch {
-        // The temporary file usually does not exist when the initial write failed.
-      }
-      throw error;
-    }
-
-    this.cachedConfig = config;
+    writeJsonFileAtomic(this.path, config);
+    this.cachedResult = { config, error: null };
     this.cachedStamp = fileStamp(this.path);
     this.initialized = true;
   }
 
   reset(): boolean {
-    try {
-      unlinkSync(this.path);
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
-      throw error;
-    }
-
+    const removed = unlinkIfPresent(this.path);
     this.initialized = true;
     this.cachedStamp = undefined;
-    this.cachedConfig = {};
-    return true;
+    this.cachedResult = { config: {}, error: null };
+    return removed;
   }
 }
 
@@ -207,8 +200,13 @@ export default function modelThinking(
   );
   function apply(ctx: ExtensionContext, silent: boolean): void {
     const model = ctx.model;
-    const level = resolveThinkingLevel(store.load(), model);
-    if (!model || level === undefined) return;
+    const loaded = store.load();
+    // Never treat a broken file as an empty policy: doing so would hide the
+    // error and make a later `/model-thinking set` overwrite it.
+    if (loaded.error || !model) return;
+
+    const level = resolveThinkingLevel(loaded.config, model);
+    if (level === undefined) return;
 
     const before = pi.getThinkingLevel();
     pi.setThinkingLevel(level);
@@ -246,10 +244,18 @@ export default function modelThinking(
         const key = modelKey(model);
         const level = pi.getThinkingLevel();
         try {
-          const config = store.load();
+          const loaded = store.load();
+          if (loaded.error) {
+            ctx.ui.notify(
+              `Cannot save model-thinking config: ${loaded.error}. Repair ${store.path} or run /model-thinking reset first.`,
+              "error",
+            );
+            return;
+          }
+
           store.save({
-            ...config,
-            models: { ...config.models, [key]: level },
+            ...loaded.config,
+            models: { ...loaded.config.models, [key]: level },
           });
           ctx.ui.notify(`Saved ${key}: ${level}`, "info");
         } catch (error) {
@@ -284,14 +290,19 @@ export default function modelThinking(
       }
 
       const model = ctx.model;
-      const config = store.load();
-      const resolved = resolveThinkingLevel(config, model);
+      const loaded = store.load();
+      const resolved = loaded.error
+        ? undefined
+        : resolveThinkingLevel(loaded.config, model);
       const lines = [
         `model: ${model ? modelKey(model) : "none"}`,
         `managed: ${resolved === undefined ? "no" : "yes"}`,
         `file: ${store.path}`,
         `saved: ${resolved ?? "none — pi handles this model natively"}`,
         `current: ${pi.getThinkingLevel()}`,
+        ...(loaded.error
+          ? [`⚠ config invalid — no policy applied: ${loaded.error}`]
+          : []),
         "",
         "run `/model-thinking set` to save this model and level; `/model-thinking reset` to clear all configured levels",
       ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bermudis-pi-goodies",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "private": false,
   "description": "A bundle of small, frequently-used Pi extensions.",
   "keywords": ["pi-package"],

package/provider-balance.ts

@@ -5,6 +5,8 @@ import type {
   ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { readFileSync, renameSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
 
 const KILO_API_BASE = process.env.KILO_API_URL || "https://api.kilo.ai";
 const KILO_BALANCE_ENDPOINT = `${KILO_API_BASE}/api/profile/balance`;
@@ -23,6 +25,23 @@ const BALANCE_FETCH_TIMEOUT_MS = 5_000;
 /** Refresh the footer balance every Nth turn end during a run. See turn_end handler. */
 const REFRESH_EVERY_N_TURNS = 5;
 
+/**
+ * Balance cache shared across every pi process on the machine, keyed by
+ * provider. Two motivations:
+ *
+ * 1. The user runs several pi instances against the same metered account
+ *    (quota/credits are per-account, not per-session), so every session may
+ *    show the freshest reading any instance fetched.
+ * 2. On session switch pi tears this runtime down and reloads the extension
+ *    for the new session (session_shutdown reason "resume" -> session_start
+ *    reason "resume"), wiping in-memory state. Without a shared cache the new
+ *    session's footer is blank/stale until its own first fetch lands, which
+ *    can be agent_settled or the 5th turn_end.
+ */
+const BALANCE_CACHE_FILE = `${process.env.HOME ?? ""}/.pi/agent/cache/provider-balance.json`;
+/** Ignore cache entries older than this; stale balances mislead. */
+const BALANCE_CACHE_TTL_MS = 30 * 60 * 1000;
+
 interface BalanceAdapter {
   fetch(token: string, signal: AbortSignal): Promise<Balance>;
   requiresOAuth?: boolean;
@@ -538,6 +557,100 @@ const BALANCE_ADAPTERS: Readonly<Record<string, BalanceAdapter>> = {
   "openai-codex": { fetch: fetchCodexQuota, requiresOAuth: true },
 };
 
+// --- Shared balance cache ---------------------------------------------------
+
+interface BalanceCacheEntry {
+  fetchedAt: number;
+  balance: Balance;
+}
+
+type BalanceCache = Record<string, BalanceCacheEntry>;
+
+function parseCachedBalance(value: unknown): Balance | null {
+  if (!Array.isArray(value)) return null;
+  const segments: BalanceSegment[] = [];
+  for (const candidate of value) {
+    const segment = asRecord(candidate);
+    if (!segment) return null;
+    const credits = numericProperty(segment, "credits");
+    const quotaRecord = asRecord(segment.quota);
+    const remainingPercent = numericProperty(quotaRecord, "remainingPercent");
+    if (
+      credits === null &&
+      (quotaRecord === null || remainingPercent === null)
+    ) {
+      return null;
+    }
+    const label = stringProperty(segment, "label") ?? undefined;
+    const windowSeconds = numericProperty(quotaRecord, "windowSeconds");
+    const resetAt = numericProperty(quotaRecord, "resetAt");
+    segments.push({
+      ...(label !== undefined ? { label } : {}),
+      ...(credits !== null ? { credits } : {}),
+      ...(quotaRecord !== null && remainingPercent !== null
+        ? {
+            quota: {
+              remainingPercent,
+              ...(windowSeconds !== null ? { windowSeconds } : {}),
+              ...(resetAt !== null ? { resetAt } : {}),
+            },
+          }
+        : {}),
+    });
+  }
+  return segments;
+}
+
+/** Read the freshest non-expired cached balance for a provider. */
+export function readCachedBalance(
+  provider: string,
+  nowMs = Date.now(),
+): Balance | null {
+  let raw: string;
+  try {
+    raw = readFileSync(BALANCE_CACHE_FILE, "utf8");
+  } catch {
+    return null; // Missing/unreadable cache is a normal cold start.
+  }
+
+  try {
+    const entry = asRecord(asRecord(JSON.parse(raw))?.[provider]);
+    const fetchedAt = numericProperty(entry, "fetchedAt");
+    if (entry === null || fetchedAt === null) return null;
+    if (nowMs - fetchedAt >= BALANCE_CACHE_TTL_MS) return null;
+    return parseCachedBalance(entry.balance);
+  } catch {
+    return null; // Corrupt cache must never break the footer.
+  }
+}
+
+/**
+ * Persist a fresh reading so other live sessions and future freshly-loaded
+ * sessions render it instantly. Write is atomic (tmp + rename) because
+ * several pi processes can fetch concurrently.
+ */
+function writeCachedBalance(provider: string, balance: Balance): void {
+  let cache: BalanceCache = {};
+  try {
+    const existing = asRecord(
+      JSON.parse(readFileSync(BALANCE_CACHE_FILE, "utf8")),
+    );
+    if (existing) cache = existing as BalanceCache;
+  } catch {
+    // Missing or corrupt cache: start fresh rather than failing the write.
+  }
+  cache[provider] = { fetchedAt: Date.now(), balance };
+
+  try {
+    mkdirSync(dirname(BALANCE_CACHE_FILE), { recursive: true });
+    const tempFile = `${BALANCE_CACHE_FILE}.${process.pid}.tmp`;
+    writeFileSync(tempFile, JSON.stringify(cache));
+    renameSync(tempFile, BALANCE_CACHE_FILE);
+  } catch {
+    // The cache is an accelerator only; the footer works without it.
+  }
+}
+
 type FooterSession = ConstructorParameters<typeof FooterComponent>[0];
 type FooterFactory = NonNullable<
   Parameters<ExtensionContext["ui"]["setFooter"]>[0]
@@ -726,6 +839,16 @@ export default function providerBalance(pi: ExtensionAPI): void {
     const providerId = provider;
     const adapter = providerId ? BALANCE_ADAPTERS[providerId] : undefined;
     if (!adapter || !providerId) return;
+
+    // Paint the freshest known value for this account immediately: another
+    // live pi instance may have fetched seconds ago, and on session switch
+    // this is what keeps the new session's footer warm instead of blank until
+    // its own first fetch lands.
+    const cached = readCachedBalance(providerId);
+    if (cached) {
+      balance = cached;
+      requestRender?.();
+    }
     if (
       adapter.requiresOAuth &&
       (!model ||
@@ -739,7 +862,10 @@ export default function providerBalance(pi: ExtensionAPI): void {
       const token = await ctx.modelRegistry.getApiKeyForProvider(providerId);
       if (!token || generation !== refreshGeneration) return;
       balance = await adapter.fetch(token, controller.signal);
-      if (generation === refreshGeneration) requestRender?.();
+      if (generation === refreshGeneration) {
+        writeCachedBalance(providerId, balance);
+        requestRender?.();
+      }
     } catch (error) {
       if (generation !== refreshGeneration || controller.signal.aborted) return;
       // This is a best-effort background refresh. Writing to stdout/stderr while
@@ -793,6 +919,12 @@ export default function providerBalance(pi: ExtensionAPI): void {
     });
   }
 
+  // Fires for startup, reload, and every session switch/new/fork: pi tears
+  // the old runtime down (session_shutdown) and starts a fresh one, so this
+  // is both our initializer and our "user switched sessions" signal.
+  // refreshBalance seeds from the shared cache first, so a session resumed
+  // mid-run elsewhere shows the other instance's last reading immediately
+  // instead of going stale until agent_settled or the 5th turn_end.
   pi.on("session_start", (_event, ctx) => {
     activeContext = ctx;
     activeThinkingLevel = restoredThinkingLevel(ctx);