@pi-archimedes/core 0.7.0 → 0.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-archimedes/core",
-  "version": "0.7.0",
+  "version": "0.9.0",
   "type": "module",
   "keywords": [
     "pi-package"
@@ -16,7 +16,8 @@
     "./chrome": "./src/chrome.ts",
     "./text": "./src/text.ts",
     "./color": "./src/color.ts",
-    "./config": "./src/config.ts"
+    "./config": "./src/config.ts",
+    "./settings-io": "./src/settings-io.ts"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": ">=0.1.0",

package/src/color.ts

@@ -1,177 +1,177 @@
 // HSL / RGB / ANSI color utilities. Pure: no external imports.
 
 export interface RGB {
-	r: number;
-	g: number;
-	b: number;
+  r: number;
+  g: number;
+  b: number;
 } // each 0..255 integer
 
 export interface HSL {
-	h: number;
-	s: number;
-	l: number;
+  h: number;
+  s: number;
+  l: number;
 } // h: 0..360, s/l: 0..1
 
 // xterm standard 16-color palette (ANSI codes 0..15).
 // Source: https://en.wikipedia.org/wiki/ANSI_escape_code#3-bit_and_4-bit
 const XTERM_16: readonly RGB[] = [
-	{ r: 0x00, g: 0x00, b: 0x00 }, // 0  black
-	{ r: 0x80, g: 0x00, b: 0x00 }, // 1  maroon
-	{ r: 0x00, g: 0x80, b: 0x00 }, // 2  green
-	{ r: 0x80, g: 0x80, b: 0x00 }, // 3  olive
-	{ r: 0x00, g: 0x00, b: 0x80 }, // 4  navy
-	{ r: 0x80, g: 0x80, b: 0x80 }, // 5  purple
-	{ r: 0x00, g: 0x80, b: 0x80 }, // 6  teal
-	{ r: 0xc0, g: 0xc0, b: 0xc0 }, // 7  silver
-	{ r: 0x80, g: 0x80, b: 0x80 }, // 8  grey
-	{ r: 0xff, g: 0x00, b: 0x00 }, // 9  red
-	{ r: 0x00, g: 0xff, b: 0x00 }, // 10 lime
-	{ r: 0xff, g: 0xff, b: 0x00 }, // 11 yellow
-	{ r: 0x00, g: 0x00, b: 0xff }, // 12 blue
-	{ r: 0xff, g: 0x00, b: 0xff }, // 13 fuchsia
-	{ r: 0x00, g: 0xff, b: 0xff }, // 14 aqua
-	{ r: 0xff, g: 0xff, b: 0xff }, // 15 white
+  { r: 0x00, g: 0x00, b: 0x00 }, // 0  black
+  { r: 0x80, g: 0x00, b: 0x00 }, // 1  maroon
+  { r: 0x00, g: 0x80, b: 0x00 }, // 2  green
+  { r: 0x80, g: 0x80, b: 0x00 }, // 3  olive
+  { r: 0x00, g: 0x00, b: 0x80 }, // 4  navy
+  { r: 0x80, g: 0x80, b: 0x80 }, // 5  purple
+  { r: 0x00, g: 0x80, b: 0x80 }, // 6  teal
+  { r: 0xc0, g: 0xc0, b: 0xc0 }, // 7  silver
+  { r: 0x80, g: 0x80, b: 0x80 }, // 8  grey
+  { r: 0xff, g: 0x00, b: 0x00 }, // 9  red
+  { r: 0x00, g: 0xff, b: 0x00 }, // 10 lime
+  { r: 0xff, g: 0xff, b: 0x00 }, // 11 yellow
+  { r: 0x00, g: 0x00, b: 0xff }, // 12 blue
+  { r: 0xff, g: 0x00, b: 0xff }, // 13 fuchsia
+  { r: 0x00, g: 0xff, b: 0xff }, // 14 aqua
+  { r: 0xff, g: 0xff, b: 0xff }, // 15 white
 ];
 
 // 6x6x6 cube levels for ANSI 16..231.
 const CUBE_LEVELS: readonly number[] = [0, 95, 135, 175, 215, 255];
 
 const clamp = (v: number, lo: number, hi: number): number =>
-	v < lo ? lo : v > hi ? hi : v;
+  v < lo ? lo : v > hi ? hi : v;
 
 const toByte = (v: number): number => clamp(Math.round(v), 0, 255);
 
 export function hexToRgb(hex: string): RGB {
-	let s = hex.trim();
-	if (s.startsWith("#")) s = s.slice(1);
-	if (s.length === 3) {
-		s = s[0]! + s[0]! + s[1]! + s[1]! + s[2]! + s[2]!;
-	}
-	if (s.length !== 6 || !/^[0-9a-fA-F]{6}$/.test(s)) {
-		throw new Error(`Invalid hex color: ${hex}`);
-	}
-	const n = parseInt(s, 16);
-	return {
-		r: (n >> 16) & 0xff,
-		g: (n >> 8) & 0xff,
-		b: n & 0xff,
-	};
+  let s = hex.trim();
+  if (s.startsWith("#")) s = s.slice(1);
+  if (s.length === 3) {
+    s = s[0]! + s[0]! + s[1]! + s[1]! + s[2]! + s[2]!;
+  }
+  if (s.length !== 6 || !/^[0-9a-fA-F]{6}$/.test(s)) {
+    throw new Error(`Invalid hex color: ${hex}`);
+  }
+  const n = parseInt(s, 16);
+  return {
+    r: (n >> 16) & 0xff,
+    g: (n >> 8) & 0xff,
+    b: n & 0xff,
+  };
 }
 
 export function rgbToHex(rgb: RGB): string {
-	const hex = (v: number) => toByte(v).toString(16).padStart(2, "0");
-	return `#${hex(rgb.r)}${hex(rgb.g)}${hex(rgb.b)}`;
+  const hex = (v: number) => toByte(v).toString(16).padStart(2, "0");
+  return `#${hex(rgb.r)}${hex(rgb.g)}${hex(rgb.b)}`;
 }
 
 export function rgbToHsl(rgb: RGB): HSL {
-	const r = rgb.r / 255;
-	const g = rgb.g / 255;
-	const b = rgb.b / 255;
-	const max = Math.max(r, g, b);
-	const min = Math.min(r, g, b);
-	const l = (max + min) / 2;
-	let h = 0;
-	let s = 0;
-	const d = max - min;
-	if (d !== 0) {
-		s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
-		switch (max) {
-			case r:
-				h = ((g - b) / d + (g < b ? 6 : 0)) * 60;
-				break;
-			case g:
-				h = ((b - r) / d + 2) * 60;
-				break;
-			default:
-				h = ((r - g) / d + 4) * 60;
-				break;
-		}
-	}
-	return { h, s, l };
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  let h = 0;
+  let s = 0;
+  const d = max - min;
+  if (d !== 0) {
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = ((g - b) / d + (g < b ? 6 : 0)) * 60;
+        break;
+      case g:
+        h = ((b - r) / d + 2) * 60;
+        break;
+      default:
+        h = ((r - g) / d + 4) * 60;
+        break;
+    }
+  }
+  return { h, s, l };
 }
 
 export function hslToRgb(hsl: HSL): RGB {
-	const { h, s, l } = hsl;
-	if (s === 0) {
-		const v = toByte(l * 255);
-		return { r: v, g: v, b: v };
-	}
-	const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
-	const p = 2 * l - q;
-	const hk = (((h % 360) + 360) % 360) / 360;
-	const hue2rgb = (t: number): number => {
-		let tt = t;
-		if (tt < 0) tt += 1;
-		if (tt > 1) tt -= 1;
-		if (tt < 1 / 6) return p + (q - p) * 6 * tt;
-		if (tt < 1 / 2) return q;
-		if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
-		return p;
-	};
-	return {
-		r: toByte(hue2rgb(hk + 1 / 3) * 255),
-		g: toByte(hue2rgb(hk) * 255),
-		b: toByte(hue2rgb(hk - 1 / 3) * 255),
-	};
+  const { h, s, l } = hsl;
+  if (s === 0) {
+    const v = toByte(l * 255);
+    return { r: v, g: v, b: v };
+  }
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  const hk = (((h % 360) + 360) % 360) / 360;
+  const hue2rgb = (t: number): number => {
+    let tt = t;
+    if (tt < 0) tt += 1;
+    if (tt > 1) tt -= 1;
+    if (tt < 1 / 6) return p + (q - p) * 6 * tt;
+    if (tt < 1 / 2) return q;
+    if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
+    return p;
+  };
+  return {
+    r: toByte(hue2rgb(hk + 1 / 3) * 255),
+    g: toByte(hue2rgb(hk) * 255),
+    b: toByte(hue2rgb(hk - 1 / 3) * 255),
+  };
 }
 
 export function ansi256ToRgb(code: number): RGB {
-	const c = Math.floor(code);
-	if (c < 0 || c > 255) {
-		throw new Error(`ANSI 256 code out of range: ${code}`);
-	}
-	if (c < 16) {
-		return { ...XTERM_16[c]! };
-	}
-	if (c < 232) {
-		const idx = c - 16;
-		const r = CUBE_LEVELS[Math.floor(idx / 36) % 6]!;
-		const g = CUBE_LEVELS[Math.floor(idx / 6) % 6]!;
-		const b = CUBE_LEVELS[idx % 6]!;
-		return { r, g, b };
-	}
-	const v = 8 + (c - 232) * 10;
-	return { r: v, g: v, b: v };
+  const c = Math.floor(code);
+  if (c < 0 || c > 255) {
+    throw new Error(`ANSI 256 code out of range: ${code}`);
+  }
+  if (c < 16) {
+    return { ...XTERM_16[c]! };
+  }
+  if (c < 232) {
+    const idx = c - 16;
+    const r = CUBE_LEVELS[Math.floor(idx / 36) % 6]!;
+    const g = CUBE_LEVELS[Math.floor(idx / 6) % 6]!;
+    const b = CUBE_LEVELS[idx % 6]!;
+    return { r, g, b };
+  }
+  const v = 8 + (c - 232) * 10;
+  return { r: v, g: v, b: v };
 }
 
 export function parseAnsiFgToRgb(ansi: string): RGB | null {
-	if (!ansi) return null;
-	// Match a leading CSI SGR sequence: ESC [ params m
-	const tc = /^\x1b\[38;2;(\d{1,3});(\d{1,3});(\d{1,3})m/.exec(ansi);
-	if (tc) {
-		return {
-			r: clamp(parseInt(tc[1]!, 10), 0, 255),
-			g: clamp(parseInt(tc[2]!, 10), 0, 255),
-			b: clamp(parseInt(tc[3]!, 10), 0, 255),
-		};
-	}
-	const palette = /^\x1b\[38;5;(\d{1,3})m/.exec(ansi);
-	if (palette) {
-		const code = parseInt(palette[1]!, 10);
-		if (code < 0 || code > 255) return null;
-		return ansi256ToRgb(code);
-	}
-	return null;
+  if (!ansi) return null;
+  // Match a leading CSI SGR sequence: ESC [ params m
+  const tc = /^\x1b\[38;2;(\d{1,3});(\d{1,3});(\d{1,3})m/.exec(ansi);
+  if (tc) {
+    return {
+      r: clamp(parseInt(tc[1]!, 10), 0, 255),
+      g: clamp(parseInt(tc[2]!, 10), 0, 255),
+      b: clamp(parseInt(tc[3]!, 10), 0, 255),
+    };
+  }
+  const palette = /^\x1b\[38;5;(\d{1,3})m/.exec(ansi);
+  if (palette) {
+    const code = parseInt(palette[1]!, 10);
+    if (code < 0 || code > 255) return null;
+    return ansi256ToRgb(code);
+  }
+  return null;
 }
 
 export function deriveDimColor(
-	input: string | number,
-	anchorLightness: number,
-	saturationFactor?: number,
+  input: string | number,
+  anchorLightness: number,
+  saturationFactor?: number,
 ): string {
-	const rgb = typeof input === "number" ? ansi256ToRgb(input) : hexToRgb(input);
-	const hsl = rgbToHsl(rgb);
-	const factor = saturationFactor ?? 0.5;
-	const target: HSL = {
-		h: hsl.h,
-		s: hsl.s * factor,
-		l: Math.min(hsl.l, anchorLightness),
-	};
-	return rgbToHex(hslToRgb(target));
+  const rgb = typeof input === "number" ? ansi256ToRgb(input) : hexToRgb(input);
+  const hsl = rgbToHsl(rgb);
+  const factor = saturationFactor ?? 0.5;
+  const target: HSL = {
+    h: hsl.h,
+    s: hsl.s * factor,
+    l: Math.min(hsl.l, anchorLightness),
+  };
+  return rgbToHex(hslToRgb(target));
 }
 
 export function rgbToTruecolorFg(rgb: RGB): string {
-	return `\x1b[38;2;${toByte(rgb.r)};${toByte(rgb.g)};${toByte(rgb.b)}m`;
+  return `\x1b[38;2;${toByte(rgb.r)};${toByte(rgb.g)};${toByte(rgb.b)}m`;
 }
 
 // ── Color helpers (from utils/ansi.ts) ───────────────────────────────────────

package/src/config.ts

@@ -1,6 +1,4 @@
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { loadConfig, saveConfig } from "./settings-io.js";
 
 export const ANIMATION_STYLES = [
   "diagonal",
@@ -23,8 +21,6 @@ export interface CoreConfig {
   animationStyle: AnimationStyle;
 }
 
-const SETTINGS_PATH = join(getAgentDir(), "settings.json");
-
 export const DEFAULT_CORE_CONFIG: CoreConfig = {
   mutedTheme: false,
   codeUnindent: true,
@@ -33,27 +29,12 @@ export const DEFAULT_CORE_CONFIG: CoreConfig = {
   animationStyle: "vertical-up",
 };
 
+const NAMESPACE = "archimedes.core";
+
 export function loadCoreConfig(): CoreConfig {
-  if (existsSync(SETTINGS_PATH)) {
-    try {
-      const full = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
-      return { ...DEFAULT_CORE_CONFIG, ...(full["archimedes.core"] ?? {}) };
-    } catch {
-      /* ignore corrupt file */
-    }
-  }
-  return DEFAULT_CORE_CONFIG;
+  return loadConfig(NAMESPACE, DEFAULT_CORE_CONFIG);
 }
 
 export function saveCoreConfig(config: CoreConfig): void {
-  let full: Record<string, unknown> = {};
-  if (existsSync(SETTINGS_PATH)) {
-    try {
-      full = JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
-    } catch {
-      /* ignore corrupt file */
-    }
-  }
-  full["archimedes.core"] = config;
-  writeFileSync(SETTINGS_PATH, JSON.stringify(full, null, 2), "utf-8");
+  saveConfig(NAMESPACE, config);
 }

package/src/index.ts

@@ -5,12 +5,15 @@ import { TUI, type EditorTheme, type Component, type SettingItem } from "@earend
 import { HephaestusEditor } from "./editor/index.js";
 
 import { renderHeader, patchStartupListing, type ListingRef } from "./startup/index.js";
-import { patchConsoleLog } from "./startup/capture.js";
+import { patchConsoleLog, unpatchConsoleLog } from "./startup/capture.js";
 import { patchThinkingRenderer } from "./thinking/patch.js";
 import { transformThinkingContent } from "./thinking/transform.js";
 import { loadCoreConfig, saveCoreConfig, DEFAULT_CORE_CONFIG, ANIMATION_STYLES, type CoreConfig } from "./config.js";
 import { initBus } from "./bus.js";
 
+// Re-export for session lifecycle management
+export { unpatchConsoleLog } from "./startup/capture.js";
+
 // ── Settings items ────────────────────────────────────────────────────────
 
 export function getCoreSettingsItems(config: CoreConfig): SettingItem[] {
@@ -69,6 +72,27 @@ export function registerCore(pi: ExtensionAPI): void {
     const listingRef = g["listingRef"] as ListingRef | undefined;
     if (listingRef) { listingRef.settled = true; }
 
+    // Restore patched chat.addChild to prevent closure accumulation across reloads
+    const ORIG_ADD_CHILD = Symbol.for("splashscreen:origAddChild");
+    const PATCHED_LISTING = Symbol.for("splashscreen:listingPatched");
+    if (coreCtx) {
+      try {
+        const tui = (coreCtx.ui as any).tui;
+        if (tui?.children) {
+          for (const child of tui.children) {
+            const cc = child as any;
+            if (cc[PATCHED_LISTING] && cc[ORIG_ADD_CHILD]) {
+              child.addChild = cc[ORIG_ADD_CHILD];
+              cc[PATCHED_LISTING] = false;
+              cc[ORIG_ADD_CHILD] = undefined;
+            }
+          }
+        }
+      } catch {
+        /* TUI structure may have changed — ignore */
+      }
+    }
+
     // Clear editor component override
     if (coreCtx) { coreCtx.ui.setEditorComponent(undefined); }
   });

package/src/settings-io.ts

@@ -0,0 +1,42 @@
+import { readFileSync, writeFileSync, existsSync, renameSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+
+const SETTINGS_PATH = join(getAgentDir(), "settings.json");
+
+/** Read the full settings.json, returning empty object if missing/corrupt. */
+function readSettings(): Record<string, unknown> {
+  if (!existsSync(SETTINGS_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(SETTINGS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Load a config section from settings.json, merged with defaults.
+ */
+export function loadConfig<T>(
+  namespace: string,
+  defaults: T,
+): T {
+  const full = readSettings();
+  return { ...defaults, ...(full[namespace] ?? {}) } as T;
+}
+
+/**
+ * Save a config section to settings.json (atomic: write to .tmp then rename).
+ */
+export function saveConfig(namespace: string, config: object): void {
+  const full = readSettings();
+  full[namespace] = config;
+  const tmpPath = SETTINGS_PATH + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify(full, null, 2), "utf-8");
+  try {
+    renameSync(tmpPath, SETTINGS_PATH);
+  } catch {
+    try { unlinkSync(tmpPath); } catch { /* ignore */ }
+    writeFileSync(SETTINGS_PATH, JSON.stringify(full, null, 2), "utf-8");
+  }
+}

package/src/startup/capture.ts

@@ -4,10 +4,14 @@ 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;
-  const origLog = console.log;
+  _origLog = console.log;
+
   console.log = (...args: unknown[]) => {
     try {
       if (args.length === 1 && typeof args[0] === "string") {
@@ -20,14 +24,24 @@ export function patchConsoleLog(): void {
             .map((s: string) => s.trim())
             .filter(Boolean);
           // Unpatch once captured — no need to keep intercepting
-          console.log = origLog;
-          g[PATCHED_LOG] = false;
+          unpatchConsoleLog();
           return;
         }
       }
-    } catch {
-      /* ignore errors in patching logic */
+    } 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);
+    _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;
+  }
+}

package/src/startup/index.ts

@@ -3,7 +3,6 @@ import { getShinedLogo, TRUECOLOR, LOGO_PAD, LOGO_SETTLE_FRAME } from "./logo.js
 import { loadCoreConfig } from "../config.js";
 import { detectSection, parseSectionText, parseModelScope, formatColumns, buildItemWrapper, type ParsedSection, SECTION_KEYS } from "./sections.js";
 import { fetchLatestVersion, compareVersions } from "./version.js";
-import { patchConsoleLog } from "./capture.js";
 import { stripAnsi } from "../text.js";
 import { Text, Spacer, Container, TUI, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
 
@@ -13,6 +12,7 @@ const ANIM_INTERVAL = Symbol.for("splashscreen:animInterval");
 const DEBOUNCE_TIMER = Symbol.for("splashscreen:debounceTimer");
 const PATCHED_CLEAR = Symbol.for("splashscreen:clearPatched");
 const PATCHED_LISTING = Symbol.for("splashscreen:listingPatched");
+const ORIG_ADD_CHILD = Symbol.for("splashscreen:origAddChild");
 
 // Animation constants
 const MAX_RENDER_WIDTH = 9999;
@@ -165,6 +165,9 @@ export function patchStartupListing(
 ): void {
   const chat = findChatContainer(tui);
   if (!chat) {
+    // Graceful degradation: if we can't find the chat container,
+    // the startup listing won't render but the extension continues.
+    console.warn("[archimedes] Could not find chat container — startup listing disabled. This may indicate a pi TUI structure change.");
     return;
   }
   const cc = chat as any;
@@ -232,6 +235,7 @@ export function patchStartupListing(
   cc[PATCHED_LISTING] = true;
 
   const origAddChild = chat.addChild.bind(chat);
+  cc[ORIG_ADD_CHILD] = origAddChild; // Store for cleanup on shutdown
   chat.clear();
 
   chat.addChild = (component: Component) => {

package/src/startup/sections.ts

@@ -40,26 +40,32 @@ export function parseSectionText(plain: string): ParsedSection | undefined {
   const sectionName = detectSection(plain);
   if (!sectionName) return undefined;
 
+  const names = extractItemsFromSection(plain, sectionName);
+  const items = deduplicateItems(names);
+  return { name: sectionName, items };
+}
+
+/**
+ * Extract item names from a section's plain text.
+ * Tracks source prefixes (npm:/git:) for Extensions/Skills sections.
+ */
+function extractItemsFromSection(plain: string, sectionName: SectionKey): string[] {
   const names: string[] = [];
   const lines = plain.split("\n");
   let currentSource = "";
   let sourceIndent = 0;
+  const showSource = sectionName === "Extensions" || sectionName === "Skills";
 
   for (const line of lines) {
     const trimmed = line.trim();
-    if (!trimmed) continue;
-    if (trimmed.startsWith("[")) continue;
-    if (/^(user|project|path)$/.test(trimmed)) { currentSource = ""; sourceIndent = 0; continue; }
+    if (shouldSkipLine(trimmed, currentSource)) continue;
 
     const indent = line.length - line.trimStart().length;
 
     // Track package source headers (e.g. "git:github.com/...", "npm:@foo/bar")
-    // Extract name from the header itself + let children inherit the prefix
     if (/^(git:|npm:)\S+\//.test(trimmed)) {
       currentSource = trimmed.startsWith("git:") ? "git:" : "npm:";
       sourceIndent = indent;
-      // Extract name from source header (e.g. "npm:@foo/pi-tavily-tools" → "npm:pi-tavily-tools")
-      const showSource = sectionName === "Extensions" || sectionName === "Skills";
       const name = extractName(trimmed, sectionName);
       if (name && showSource) names.push(name);
       continue;
@@ -71,27 +77,38 @@ export function parseSectionText(plain: string): ParsedSection | undefined {
       sourceIndent = 0;
     }
 
-    if (/^(index\.(ts|js)|src|dist|out|build|lib|bin)$/i.test(trimmed)) continue;
-    // Skip resolved file paths only under source headers (e.g. "dist/index.js" under npm:)
-    if (currentSource) {
-      if (/\/(src|dist|out|build|lib|bin)\//.test(trimmed)) continue;
-      if (/\.(ts|js)$/.test(trimmed) && trimmed.includes("/") && !/SKILL\.(ts|js)$/i.test(trimmed)) continue;
-    }
-
     const name = extractName(trimmed, sectionName);
-    // Prompts/Context don't need source prefix — only Extensions/Skills
-    const showSource = sectionName === "Extensions" || sectionName === "Skills";
     if (name) names.push(showSource && currentSource ? currentSource + name : name);
   }
+  return names;
+}
+
+/** Check if a line should be skipped during section parsing. */
+function shouldSkipLine(trimmed: string, currentSource: string): boolean {
+  if (!trimmed) return true;
+  if (trimmed.startsWith("[")) return true;
+  if (/^(user|project|path)$/.test(trimmed)) return true;
+  if (/^(index\.(ts|js)|src|dist|out|build|lib|bin)$/i.test(trimmed)) return true;
+  // Skip resolved file paths only under source headers
+  if (currentSource) {
+    if (/\/(src|dist|out|build|lib|bin)\//.test(trimmed)) return true;
+    if (/\.(ts|js)$/.test(trimmed) && trimmed.includes("/") && !/SKILL\.(ts|js)$/i.test(trimmed)) return true;
+  }
+  return false;
+}
 
-  // Deduplicate by bare name (without prefix) — prefer prefixed version
+/**
+ * Deduplicate items by bare name (without prefix).
+ * Prefers prefixed versions (npm:/git:) over bare names.
+ */
+function deduplicateItems(names: string[]): string[] {
   const seen = new Map<string, string>();
   for (const n of names) {
     if (/^(index|dist|src|out|lib|bin)$/i.test(n)) continue;
     const bare = n.replace(/^(npm:|git:)/, "");
     if (!seen.has(bare) || n.includes(":")) seen.set(bare, n);
   }
-  return { name: sectionName, items: [...seen.values()] };
+  return [...seen.values()];
 }
 
 export function parseModelScope(plain: string): ParsedSection | undefined {

package/src/text.ts

@@ -3,9 +3,24 @@ import { truncateToWidth } from "@earendil-works/pi-tui";
 // Inline stripSgr — narrow SGR-only strip (no trim) for char-level checks
 const stripSgr = (s: string) => s.replace(/\x1b\[[0-9;]*m/g, "");
 
-/** Strip ALL ANSI escapes (SGR color/style + OSC sequences). Trims whitespace. Use for text extraction. */
+/**
+ * Strip ALL ANSI escape sequences. Covers:
+ * - CSI: ESC [ ... letter (SGR, cursor movement, etc.)
+ * - OSC: ESC ] ... ST (operating system commands)
+ * - DCS: ESC P ... ST (device control strings)
+ * - APC: ESC _ ... ST (application program commands)
+ * - SOS: ESC ^ ... ST (start of string)
+ * - PM:  ESC \x5c ... ST (privacy message)
+ * - Character set: ESC ( or ESC ) (DECSET/DECRST)
+ * Trims whitespace. Use for text extraction.
+ */
 export function stripAnsi(s: string): string {
-  return s.replace(/\x1b\[[0-9;]*[a-zA-Z]|\x1b\].*?(?:\x07|\x1b\\)/g, "").trim();
+  return s
+    .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, "")   // CSI
+    .replace(/\x1b\].*?(?:\x07|\x1b\\)/g, "")  // OSC
+    .replace(/\x1b[P^_\x5c].*?(?:\x07|\x1b\\)/g, "") // DCS, SOS, APC, PM
+    .replace(/\x1b[()]/g, "")                   // character set
+    .trim();
 }
 
 /** Clamp a line to maxW visible characters, preserving ANSI escapes. */

package/src/thinking/patch.ts

@@ -30,10 +30,15 @@ export function patchThinkingRenderer(getTheme: () => Theme): void {
   }
 
   const src = proto.updateContent.toString();
-  if (
-    !src.includes('content.type === "thinking"') ||
-    !src.includes("this.markdownTheme")
-  ) {
+  const hasThinkingCheck = src.includes('content.type === "thinking"');
+  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.`,
+    );
     return;
   }