@pi-archimedes/ui 2.10.4 → 2.11.1

package/src/thinking/patch.ts

@@ -1,6 +1,7 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { AssistantMessageComponent, VERSION } from "@earendil-works/pi-coding-agent";
 import { Markdown, type MarkdownOptions, type MarkdownTheme, MouseRegion, Spacer, Text, TruncatedText } from "@earendil-works/pi-tui";
+import { diag } from "@pi-archimedes/core/log";
 import type { ThinkingStyle } from "../config.js";
 import { buildMutedMarkdownTheme } from "./theme.js";
 
@@ -21,6 +22,11 @@ const THINKING_STATES_KEY = Symbol.for("archimedes:thinkingStateOverrides");
  * @param config Optional labelText/labelColor overrides for the thinking
  *   block header, and autoCollapseThinking flag. When omitted (or empty/invalid),
  *   the original defaults are used.
+ * @param notify The user-facing surface (`ctx.ui.notify`), injected because
+ *   this module has no `ExtensionContext` of its own. A skipped patch is a
+ *   silent feature loss — the muted thinking theme simply stops applying — so
+ *   it is the one diagnostic here the user has to hear about. Omit it and the
+ *   notice is dropped: the detail still reaches the log.
  */
 export function patchThinkingRenderer(
   getTheme: () => Theme,
@@ -30,6 +36,7 @@ export function patchThinkingRenderer(
     autoCollapseThinking?: boolean;
     thinkingStyle?: ThinkingStyle;
   },
+  notify?: (message: string) => void,
 ): void {
   if (!AssistantMessageComponent) return;
 
@@ -52,12 +59,21 @@ export function patchThinkingRenderer(
   const hasThinkingCheck = /content\.type\s*===\s*["']thinking["']/.test(src);
   const hasMarkdownTheme = src.includes("this.markdownTheme");
   if (!hasThinkingCheck || !hasMarkdownTheme) {
-    console.warn(
-      `[archimedes] Skipping thinking renderer patch — signature mismatch
-  hasThinkingCheck: ${hasThinkingCheck}, hasMarkdownTheme: ${hasMarkdownTheme}
-  This likely means pi's AssistantMessageComponent changed. The muted theme
-  for thinking blocks will not be applied.`,
+    // The user loses the muted thinking theme and cannot see why, so this one
+    // goes to the notification surface — one line — while the probe result a
+    // developer needs goes to the log. Neither goes to the console: a write
+    // smears a fullscreen frame and is discarded inside a subagent child.
+    diag(
+      "ui",
+      `[archimedes] Skipping thinking renderer patch — signature mismatch: hasThinkingCheck: ${hasThinkingCheck}, hasMarkdownTheme: ${hasMarkdownTheme}. This likely means pi's AssistantMessageComponent changed.`,
     );
+    try {
+      notify?.(
+        "Thinking renderer patch skipped: pi's AssistantMessageComponent changed, so thinking blocks keep pi's default styling.",
+      );
+    } catch {
+      // A surface that cannot deliver the notice must not fail the session.
+    }
     return;
   }
 
@@ -70,7 +86,7 @@ export function patchThinkingRenderer(
   } else {
     // First patch or version changed — warn if version mismatch
     if ((proto as any)[PATCHED_KEY] && patchVersion && patchVersion !== currentVersion) {
-      console.warn(`[archimedes] Re-patching thinking renderer: pi version changed ${patchVersion} → ${currentVersion}`);
+      diag("ui", `[archimedes] Re-patching thinking renderer: pi version changed ${patchVersion} → ${currentVersion}`);
     }
   }
 

package/src/bash/tool.test.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { registerBashToolOverride } from "./tool.js";
-import { renderBashCall, renderBashResult } from "./renderer.js";
-
-describe("registerBashToolOverride", () => {
-  it("registers bash tool with custom renderCall and renderResult while preserving definition", () => {
-    let capturedTool: any = null;
-    const pi = {
-      registerTool: vi.fn((tool: any) => {
-        capturedTool = tool;
-      }),
-    } as unknown as ExtensionAPI;
-
-    registerBashToolOverride(pi, "/test/cwd");
-
-    expect(pi.registerTool).toHaveBeenCalledTimes(1);
-    expect(capturedTool).toBeDefined();
-    expect(capturedTool.name).toBe("bash");
-    expect(capturedTool.label).toBe("bash");
-    expect(capturedTool.parameters).toBeDefined();
-    expect(typeof capturedTool.execute).toBe("function");
-    expect(capturedTool.renderCall).toBe(renderBashCall);
-    expect(capturedTool.renderResult).toBe(renderBashResult);
-  });
-});

package/src/bash/tool.ts

@@ -1,17 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { createBashToolDefinition } from "@earendil-works/pi-coding-agent";
-import { renderBashCall, renderBashResult } from "./renderer.js";
-
-/**
- * Register custom styled bash tool override.
- * Preserves core execution, parameters, timeouts, and PI_* environment injection
- * while replacing the presentation with Archimedes styled rendering.
- */
-export function registerBashToolOverride(pi: ExtensionAPI, cwd: string): void {
-  const def = createBashToolDefinition(cwd);
-  pi.registerTool({
-    ...def,
-    renderCall: renderBashCall,
-    renderResult: renderBashResult,
-  });
-}

package/src/codemode/loader.test.ts

@@ -1,139 +0,0 @@
-import { describe, it, expect, vi, afterEach } from "vitest";
-import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import {
-  findAgentPackageRoot,
-  resolveCodemodeModuleFiles,
-  loadCodemodeModule,
-} from "./loader.js";
-
-const createdDirs: string[] = [];
-
-function makeTree(
-  rootName: string,
-  files: Record<string, string>,
-): string {
-  const root = mkdtempSync(path.join(tmpdir(), `archimedes-${rootName}-`));
-  createdDirs.push(root);
-  for (const [rel, content] of Object.entries(files)) {
-    const file = path.join(root, rel);
-    mkdirSync(path.dirname(file), { recursive: true });
-    writeFileSync(file, content);
-  }
-  return root;
-}
-
-afterEach(() => {
-  for (const dir of createdDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-  vi.unstubAllEnvs();
-});
-
-describe("findAgentPackageRoot", () => {
-  it("finds the package root from a nested dist file", () => {
-    const root = makeTree("agent", {
-      "package.json": JSON.stringify({ name: "@earendil-works/pi-coding-agent" }),
-      "dist/index.js": "",
-      "dist/extensions/codemode/tool.js": "",
-    });
-    expect(
-      findAgentPackageRoot(path.join(root, "dist", "extensions", "codemode")),
-    ).toBe(root);
-    expect(findAgentPackageRoot(path.join(root, "dist"))).toBe(root);
-  });
-
-  it("returns undefined for another package", () => {
-    const root = makeTree("other", {
-      "package.json": JSON.stringify({ name: "@pi-archimedes/ui" }),
-      "src/index.ts": "",
-    });
-    expect(findAgentPackageRoot(path.join(root, "src"))).toBeUndefined();
-  });
-
-  it("returns undefined when there is no package.json at all", () => {
-    const root = makeTree("loose", { "some/file.js": "" });
-    expect(findAgentPackageRoot(root)).toBeUndefined();
-  });
-});
-
-describe("resolveCodemodeModuleFiles", () => {
-  it("resolves the codemode module from the CLI entry script (argv[1])", () => {
-    const root = makeTree("agent", {
-      "package.json": JSON.stringify({ name: "@earendil-works/pi-coding-agent" }),
-      "dist/bundle/cli.js": "",
-      "dist/extensions/codemode/tool.js": "",
-    });
-    const files = resolveCodemodeModuleFiles(
-      path.join(root, "dist", "bundle", "cli.js"),
-    );
-    expect(files).toContain(
-      path.join(root, "dist", "extensions", "codemode", "tool.js"),
-    );
-  });
-
-  it("returns no argv[1] candidate when the entry is not in the agent package", () => {
-    const files = resolveCodemodeModuleFiles("/usr/bin/some-other-cli");
-    // Only the local-copy candidate (if any) may remain.
-    for (const file of files) {
-      expect(file).not.toContain("/usr/bin/some-other-cli");
-    }
-  });
-
-  it("returns an empty list without argv[1] and without a local copy", () => {
-    // createRequire fallback: the local pi-coding-agent copy in this repo has
-    // no dist/extensions/codemode in older versions, but the resolution
-    // itself must not throw.
-    expect(() => resolveCodemodeModuleFiles(undefined)).not.toThrow();
-  });
-
-  it("never builds a dist/dist path for the local-copy candidate", () => {
-    // require.resolve() returns …/pi-coding-agent/dist/index.js — its
-    // directory IS the dist dir, so joining another `dist` segment would
-    // produce a nonexistent …/dist/dist/… path and silently disable the
-    // override for launcher entries outside the agent package.
-    const files = resolveCodemodeModuleFiles(undefined);
-    for (const file of files) {
-      expect(file).not.toContain(path.join("dist", "dist"));
-    }
-  });
-});
-
-describe("loadCodemodeModule", () => {
-  it("loads the module when the file exists and exports the factory", async () => {
-    const root = makeTree("agent", {
-      "package.json": JSON.stringify({ name: "@earendil-works/pi-coding-agent" }),
-      "dist/index.js": "",
-      "dist/extensions/codemode/tool.js": `
-        export const codemodeSchema = { type: "object" };
-        export function createCodemodeToolDefinition(options) {
-          return { options, parameters: codemodeSchema };
-        }
-      `,
-    });
-    const mod = await loadCodemodeModule(
-      path.join(root, "dist", "index.js"),
-    );
-    expect(mod).toBeDefined();
-    expect(mod!.createCodemodeToolDefinition).toBeTypeOf("function");
-    expect(mod!.codemodeSchema).toEqual({ type: "object" });
-  });
-
-  it("returns undefined when the module file is missing", async () => {
-    const mod = await loadCodemodeModule("/does/not/exist/cli.js");
-    expect(mod).toBeUndefined();
-  });
-
-  it("returns undefined when the module lacks the factory", async () => {
-    const root = makeTree("agent", {
-      "package.json": JSON.stringify({ name: "@earendil-works/pi-coding-agent" }),
-      "dist/index.js": "",
-      "dist/extensions/codemode/tool.js": `
-        export const somethingElse = 1;
-      `,
-    });
-    const mod = await loadCodemodeModule(path.join(root, "dist", "index.js"));
-    expect(mod).toBeUndefined();
-  });
-});

package/src/codemode/loader.ts

@@ -1,115 +0,0 @@
-import { existsSync, readFileSync, realpathSync } from "node:fs";
-import path from "node:path";
-
-export interface CodemodeToolModule {
-  createCodemodeToolDefinition: (options?: Record<string, unknown>) => unknown;
-  codemodeSchema: unknown;
-}
-
-const AGENT_PACKAGE_NAME = "@earendil-works/pi-coding-agent";
-/** Candidate 1: relative to the package ROOT (the CLI-install walk-up). */
-const CODEMODE_MODULE_FROM_ROOT = path.join(
-  "dist",
-  "extensions",
-  "codemode",
-  "tool.js",
-);
-/** Candidate 2: relative to the `dist/` directory the package entry lives in. */
-const CODEMODE_MODULE_FROM_DIST = path.join(
-  "extensions",
-  "codemode",
-  "tool.js",
-);
-
-/**
- * Walk up from `startDir` to the package root (the nearest ancestor holding a
- * package.json) and return it when it is the pi-coding-agent package.
- */
-export function findAgentPackageRoot(startDir: string): string | undefined {
-  let dir = startDir;
-  while (true) {
-    const pkgPath = path.join(dir, "package.json");
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-        if (pkg.name === AGENT_PACKAGE_NAME) {
-          return dir;
-        }
-      } catch {
-        // Unreadable package.json — keep walking up.
-      }
-      // A package boundary without a matching name: stop (we are inside some
-      // other package's tree, not the agent's).
-      return undefined;
-    }
-    const parent = path.dirname(dir);
-    if (parent === dir) return undefined;
-    dir = parent;
-  }
-}
-
-/**
- * Candidate files for the codemode tool module, in preference order:
- *
- * 1. The running pi CLI's own install. `process.argv[1]` is the CLI entry
- *    script (e.g. `…/pi-coding-agent/dist/bundle/cli.js`); walking up to the
- *    package root finds the `dist` the CLI is actually running from. Pi loads
- *    extensions with jiti, which shares the native module instance for `.js`
- *    files, so when the CLI runs unbundled this is the very same module the
- *    CLI's built-in codemode extension loaded — same schema object, same
- *    executor.
- * 2. Our own node_modules copy (resolved via `import.meta.resolve`). A
- *    fallback for launchers whose argv[1] is not inside a pi-coding-agent
- *    install. Older pi versions have no `dist/extensions/codemode` at all,
- *    in which case the file does not exist and the candidate is skipped.
- */
-export function resolveCodemodeModuleFiles(argv1?: string): string[] {
-  const candidates: string[] = [];
-  const entry = argv1 ?? process.argv[1];
-  if (typeof entry === "string" && entry.length > 0) {
-    let root: string | undefined;
-    try {
-      root = findAgentPackageRoot(path.dirname(realpathSync(entry)));
-    } catch {
-      root = undefined;
-    }
-    if (root) {
-      candidates.push(path.join(root, CODEMODE_MODULE_FROM_ROOT));
-    }
-  }
-  try {
-    // `import.meta.resolve` (the `import` condition) — the agent package's
-    // exports map has no `require` condition, so a CJS `require.resolve`
-    // would fail on newer pi versions.
-    const agentEntry = new URL(import.meta.resolve(AGENT_PACKAGE_NAME)).pathname;
-    // `agentEntry` is `…/pi-coding-agent/dist/index.js` — its directory IS the
-    // `dist` dir, so join the module path WITHOUT another `dist` segment.
-    candidates.push(path.join(path.dirname(agentEntry), CODEMODE_MODULE_FROM_DIST));
-  } catch {
-    // No local copy of the agent package — nothing else to try.
-  }
-  return candidates;
-}
-
-/**
- * Load the codemode tool module from the running pi install (see
- * {@link resolveCodemodeModuleFiles}). Returns `undefined` when the module
- * cannot be found or loaded (e.g. a pi version without the codemode
- * extension), so the caller can fall back to pi's native rendering.
- */
-export async function loadCodemodeModule(
-  argv1?: string,
-): Promise<CodemodeToolModule | undefined> {
-  for (const file of resolveCodemodeModuleFiles(argv1)) {
-    if (!existsSync(file)) continue;
-    try {
-      const mod = await import(file);
-      if (typeof mod?.createCodemodeToolDefinition === "function") {
-        return mod as CodemodeToolModule;
-      }
-    } catch {
-      // Try the next candidate.
-    }
-  }
-  return undefined;
-}

package/src/codemode/tool.test.ts

@@ -1,149 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { registerCodemodeToolOverride } from "./tool.js";
-
-const nativeSchema = { type: "object", properties: { code: {} } };
-const defFromFactory = {
-  name: "codemode",
-  label: "codemode",
-  description: "native description",
-  parameters: { type: "object", properties: { code: {} } },
-  execute: async () => ({}),
-  prepareLoadout: (loadout: unknown) => loadout,
-  exposure: "model-only",
-  constrainedSampling: { type: "grammar" },
-};
-
-function makePi(
-  overrides: {
-    allTools?: Array<{ name: string; parameters?: unknown; namespace?: unknown }>;
-    getSettings?: () => {
-      codemode?: { mode?: string; inlineBudget?: unknown };
-    };
-  } = {},
-) {
-  const registerTool = vi.fn();
-  const appendEntry = vi.fn();
-  const pi = {
-    registerTool,
-    appendEntry,
-    getAllTools: vi.fn(() => overrides.allTools ?? []),
-    ...(overrides.getSettings ? { getSettings: overrides.getSettings } : {}),
-  };
-  return { pi, registerTool, appendEntry } as const;
-}
-
-type MockModule = {
-  createCodemodeToolDefinition: (options: Record<string, unknown>) => unknown;
-  codemodeSchema: unknown;
-};
-
-// `vi.mock` is hoisted above the imports, so the mutable module handle must
-// live in a hoisted scope (referencing a plain `let` would hit the TDZ when
-// the mock factory first runs during the static import of ./tool.js).
-const state = vi.hoisted(() => ({
-  module: undefined as MockModule | undefined,
-}));
-
-vi.mock("./loader.js", () => ({
-  loadCodemodeModule: vi.fn(async () => state.module),
-}));
-
-beforeEach(() => {
-  state.module = {
-    createCodemodeToolDefinition: (options) => ({ ...defFromFactory, options }),
-    codemodeSchema: nativeSchema,
-  };
-});
-
-describe("registerCodemodeToolOverride", () => {
-  it("registers the native definition with the Archimedes renderers", async () => {
-    const { pi, registerTool } = makePi();
-    const ok = await registerCodemodeToolOverride(pi as never);
-
-    expect(ok).toBe(true);
-    expect(registerTool).toHaveBeenCalledTimes(1);
-    const registered = registerTool.mock.calls[0]![0] as Record<string, unknown>;
-    // Native definition fields are preserved.
-    expect(registered.name).toBe("codemode");
-    expect(registered.execute).toBe(defFromFactory.execute);
-    expect(registered.prepareLoadout).toBe(defFromFactory.prepareLoadout);
-    expect(registered.exposure).toBe("model-only");
-    // The built-in registers codemode inactive; the override must match.
-    expect(registered.defaultActive).toBe(false);
-    // The presentation is replaced.
-    expect(typeof registered.renderCall).toBe("function");
-    expect(typeof registered.renderResult).toBe("function");
-  });
-
-  it("preserves the running CLI's schema reference when the built-in is still registered", async () => {
-    const { pi, registerTool } = makePi({
-      allTools: [{ name: "codemode", parameters: nativeSchema }],
-    });
-    await registerCodemodeToolOverride(pi as never);
-
-    const registered = registerTool.mock.calls[0]![0] as Record<string, unknown>;
-    expect(registered.parameters).toBe(nativeSchema);
-  });
-
-  it("keeps the factory schema when no built-in registration is visible", async () => {
-    const { pi, registerTool } = makePi();
-    await registerCodemodeToolOverride(pi as never);
-
-    const registered = registerTool.mock.calls[0]![0] as Record<string, unknown>;
-    expect(registered.parameters).toBe(defFromFactory.parameters);
-  });
-
-  it("wires appendEntry, models, and the settings-backed options", async () => {
-    const settings = { codemode: { mode: "only", inlineBudget: 1500 } };
-    const { pi, registerTool, appendEntry } = makePi({
-      getSettings: () => settings,
-    });
-    await registerCodemodeToolOverride(pi as never);
-
-    const registered = registerTool.mock.calls[0]![0] as Record<string, unknown>;
-    const options = (registered as { options?: Record<string, unknown> }).options!;
-    const getMode = options.getMode as () => string;
-    const getInlineBudget = options.getInlineBudget as () => number | undefined;
-    expect(options.models).toBe(true);
-    expect(typeof options.appendEntry).toBe("function");
-    expect(typeof options.getToolNamespace).toBe("function");
-    expect(getMode()).toBe("only");
-    expect(getInlineBudget()).toBe(1500);
-
-    // appendEntry forwards to pi.appendEntry.
-    await (options.appendEntry as (t: string, d: unknown) => void)(
-      "codemode-store",
-      { set: {} },
-    );
-    expect(appendEntry).toHaveBeenCalledWith("codemode-store", { set: {} });
-  });
-
-  it("defaults mode to on and inlineBudget to undefined without settings", async () => {
-    const { pi, registerTool } = makePi();
-    await registerCodemodeToolOverride(pi as never);
-
-    const registered = registerTool.mock.calls[0]![0] as Record<string, unknown>;
-    const options = (registered as { options?: Record<string, unknown> }).options!;
-    expect((options.getMode as () => string)()).toBe("on");
-    expect((options.getInlineBudget as () => number | undefined)()).toBeUndefined();
-  });
-
-  it("treats a non-finite inlineBudget as undefined", async () => {
-    const { pi, registerTool } = makePi({
-      getSettings: () => ({ codemode: { inlineBudget: Number.NaN } }),
-    });
-    await registerCodemodeToolOverride(pi as never);
-
-    const registered = registerTool.mock.calls[0]![0] as Record<string, unknown>;
-    const options = (registered as { options?: Record<string, unknown> }).options!;
-    expect((options.getInlineBudget as () => number | undefined)()).toBeUndefined();
-  });
-
-  it("returns false and registers nothing when the module cannot be loaded", async () => {
-    state.module = undefined;
-    const { pi, registerTool } = makePi();
-    const ok = await registerCodemodeToolOverride(pi as never);
-    expect(ok).toBe(false);
-    expect(registerTool).not.toHaveBeenCalled();
-  });
-});

package/src/codemode/tool.ts

@@ -1,96 +0,0 @@
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { loadCodemodeModule } from "./loader.js";
-import {
-  renderCodemodeCall,
-  renderCodemodeResult,
-  clearActiveCodemodeIntervals,
-} from "./renderer.js";
-
-export { clearActiveCodemodeIntervals } from "./renderer.js";
-
-/**
- * Register an Archimedes-styled override of the `codemode` tool.
- *
- * `codemode` is a replaceable pi built-in extension: registering a tool with
- * the same name takes over completely (pi omits the built-in one), so the
- * override must reproduce the built-in's full definition — the QuickJS
- * sandbox executor, the dynamic `prepareLoadout` description, the
- * `model-only` exposure, and `defaultActive: false` (the built-in registers
- * codemode inactive; it is activated via `--tools`, `defaultTools`, or MCP
- * auto-enable). Only the presentation is replaced.
- *
- * The definition is built from the running CLI's own copy of the codemode
- * module (see {@link loadCodemodeModule}) so the executor matches what the
- * CLI expects. The `parameters` reference is preserved from the built-in's
- * registration when it is still visible (`pi.getAllTools()`): the CLI's
- * MCP and tool-search extensions recognise the codemode tool by schema
- * identity (`isCodemodeTool`), and a fresh schema object from a second
- * module instance would defeat those checks.
- *
- * Returns `false` when the codemode module cannot be loaded (e.g. a pi
- * version without the codemode extension) — pi's native rendering then
- * stands in.
- *
- * Note: the take-over makes pi print a startup notice ("built-in extension
- * `codemode` was not loaded") — the same notice a third-party MCP extension
- * triggers when it replaces the built-in MCP extension. It is informational:
- * the tool still works, now with this package's renderers. Set
- * `codemodeToolStyling` to `false` to run the native tool instead.
- */
-export async function registerCodemodeToolOverride(
-  pi: ExtensionAPI,
-): Promise<boolean> {
-  const mod = await loadCodemodeModule();
-  if (!mod) return false;
-
-  const def = mod.createCodemodeToolDefinition({
-    appendEntry: (customType: string, data: unknown) =>
-      pi.appendEntry(customType, data),
-    models: true,
-    getToolNamespace: (name: string) =>
-      (pi.getAllTools().find((t) => t.name === name) as {
-        namespace?: unknown;
-      } | undefined)?.namespace,
-    // `getSettings` is newer than the oldest pi this package type-checks
-    // against; read it defensively (the built-in extension's wiring).
-    getMode: () =>
-      readSettings(pi)?.codemode?.mode === "only" ? "only" : "on",
-    getInlineBudget: () => {
-      const budget = readSettings(pi)?.codemode?.inlineBudget;
-      return typeof budget === "number" && Number.isFinite(budget) && budget >= 0
-        ? budget
-        : undefined;
-    },
-  }) as Record<string, unknown>;
-
-  // The built-in (when loaded) is still registered at this point: keep its
-  // schema object reference so `isCodemodeTool` identity checks keep working.
-  const native = pi.getAllTools().find((t) => t.name === "codemode");
-  if (native?.parameters !== undefined) {
-    def.parameters = native.parameters;
-  }
-
-  pi.registerTool({
-    ...def,
-    renderCall: renderCodemodeCall,
-    renderResult: renderCodemodeResult,
-    defaultActive: false,
-  } as never);
-  return true;
-}
-
-function readSettings(
-  pi: ExtensionAPI,
-): { codemode?: { mode?: string; inlineBudget?: unknown } } | undefined {
-  const getSettings = (
-    pi as unknown as { getSettings?: () => unknown }
-  ).getSettings;
-  if (typeof getSettings !== "function") return undefined;
-  try {
-    return getSettings.call(pi) as
-      | { codemode?: { mode?: string; inlineBudget?: unknown } }
-      | undefined;
-  } catch {
-    return undefined;
-  }
-}

package/src/startup/capture.ts

@@ -1,47 +0,0 @@
-const g: Record<string | symbol, unknown> = globalThis as unknown as typeof global & Record<string | symbol, unknown>;
-
-const MODEL_SCOPE_RE = /Model scope:\s*(.+)/;
-export const CAPTURED_MODELS = Symbol.for("splashscreen:capturedModels");
-export const PATCHED_LOG = Symbol.for("splashscreen:logPatched");
-
-// Store original console.log for restoration
-let _origLog: typeof console.log | undefined;
-
-export function patchConsoleLog(): void {
-  if (g[PATCHED_LOG]) return;
-  g[PATCHED_LOG] = true;
-  _origLog = console.log;
-
-  console.log = (...args: unknown[]) => {
-    try {
-      if (args.length === 1 && typeof args[0] === "string") {
-        const plain = (args[0] as string).replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
-        const m = MODEL_SCOPE_RE.exec(plain);
-        if (m) {
-          const raw = m[1]!.replace(/\s*\(Ctrl\+\w[\w\s]*\)/gi, "");
-          g[CAPTURED_MODELS] = raw
-            .split(",")
-            .map((s: string) => s.trim())
-            .filter(Boolean);
-          // Unpatch once captured — no need to keep intercepting
-          unpatchConsoleLog();
-          return;
-        }
-      }
-    } catch (err) {
-      // Log the error but don't suppress the original call
-      console.error("[archimedes] Error in console.log patch:", err);
-    }
-    _origLog!.apply(console, args);
-  };
-}
-
-/** Restore original console.log — call on session_shutdown. */
-export function unpatchConsoleLog(): void {
-  if (!g[PATCHED_LOG]) return;
-  g[PATCHED_LOG] = false;
-  if (_origLog) {
-    console.log = _origLog;
-    _origLog = undefined;
-  }
-}