@pi-unipi/unipi 2.0.13 → 2.1.1

package/packages/footer/src/tps-tracker.ts

@@ -4,37 +4,112 @@
  * Per-message TPS calculation for live generation rate display.
  * Tracks individual assistant messages with start/stop timestamps
  * to measure generation rate excluding idle/tool-execution time.
+ *
+ * ## Token counting
+ *
+ * Output tokens are counted from the assistant message *content* (text +
+ * thinking blocks) via a lightweight word/char heuristic, NOT from
+ * `usage.output`. Rationale:
+ *   - `usage.output` is only populated by the provider at stream end (or in
+ *     a final `message_delta`), so it is 0 throughout generation and useless
+ *     for a live rate.
+ *   - Counting the streamed text ourselves gives a real, monotonically
+ *     increasing numerator that reflects how much the model has actually
+ *     produced so far.
+ *   - This matches what users perceive as "tokens per second" (visible
+ *     output rate) and avoids the previous bug where the displayed TPS was
+ *     always inflated to 90+ t/s (caused by dividing a post-hoc `usage.output`
+ *     total by a too-short, incorrectly measured elapsed window).
+ *
+ * The heuristic intentionally over-counts slightly (whitespace + punctuation
+ * are treated as tokens). That is acceptable for a live speed indicator and
+ * keeps the estimate in the right order of magnitude (within ~10-20% of the
+ * provider's reported output tokens for typical English/code output).
  */
 
 /** Per-message TPS record */
 interface MessageTpsRecord {
-  /** Message index in the session */
+  /** Message index in the session (sequential, assistant-only) */
   messageIndex: number;
-  /** Output tokens for this message */
+  /** Estimated output tokens produced so far for this message */
   outputTokens: number;
-  /** When generation started (Date.now()) */
+  /** When generation started (Date.now(), ms) */
   startedAt: number;
-  /** When generation completed (Date.now()), 0 if still generating */
+  /** When generation completed (Date.now(), ms), 0 if still generating */
   completedAt: number;
-  /** Computed TPS for this message */
+  /** Computed TPS for this message (final, once completed) */
   tps: number;
 }
 
+/**
+ * Estimate the number of tokens in a string.
+ *
+ * Uses a cheap word + punctuation split. Good enough for a live TPS display;
+ * we deliberately avoid pulling in a full BPE tokenizer for performance and
+ * footprint reasons.
+ */
+function estimateTokens(text: string): number {
+  if (!text) return 0;
+  // Count word-ish tokens and standalone punctuation.
+  // \p{L} / \p{N} keep this Unicode-aware for non-ASCII content.
+  const wordish = text.match(/[\p{L}\p{N}]+/gu);
+  const punct = text.match(/[^\s\p{L}\p{N}]+/gu);
+  const wordCount = wordish ? wordish.length : 0;
+  const punctCount = punct ? punct.length : 0;
+  return wordCount + punctCount;
+}
+
+/**
+ * Estimate output tokens from an assistant message by summing text and
+ * thinking content lengths. Tool-call argument JSON is also counted since
+ * it represents model output.
+ *
+ * Accepts the raw message shape from pi's session entries (loosely typed).
+ */
+function estimateOutputTokens(message: unknown): number {
+  if (!message || typeof message !== "object") return 0;
+  const m = message as Record<string, unknown>;
+  if (m.role !== "assistant") return 0;
+  const content = m.content;
+  if (!Array.isArray(content)) return 0;
+
+  let total = 0;
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const b = block as Record<string, unknown>;
+    const type = b.type;
+    if (type === "text" && typeof b.text === "string") {
+      total += estimateTokens(b.text);
+    } else if (type === "thinking" && typeof b.thinking === "string") {
+      total += estimateTokens(b.thinking);
+    } else if (type === "tool_use" || type === "toolcall") {
+      // Count tool name + serialized arguments as model output.
+      const name = typeof b.name === "string" ? b.name : "";
+      const input = b.input ?? b.arguments;
+      let inputStr: string;
+      try {
+        inputStr = typeof input === "string" ? input : JSON.stringify(input ?? "");
+      } catch {
+        inputStr = "";
+      }
+      total += estimateTokens(name) + estimateTokens(inputStr);
+    }
+  }
+  return total;
+}
+
 /**
  * Tracks per-message TPS and computes live/session metrics.
  *
- * Usage: Call `onMessageUpdate()` whenever output tokens change.
- * The tracker records generation start/stop per message and computes
- * live TPS from the current message and session averages excluding idle time.
+ * Usage: Call `onMessageUpdate()` on every tick (e.g. 1s interval) with the
+ * current assistant message state. The tracker records generation start/stop
+ * per message and computes live TPS from elapsed wall-clock time.
  */
 export class TpsTracker {
-  /** Per-message records */
+  /** Per-message records (one per assistant message, in order) */
   private records: MessageTpsRecord[] = [];
 
-  /** Highest message index seen so far (for dedup) */
-  private lastSeenMessageCount = 0;
-
-  /** Total output tokens across all completed messages */
+  /** Total estimated output tokens across all messages */
   private totalOutput = 0;
 
   /**
@@ -42,15 +117,16 @@ export class TpsTracker {
    * Call this on every tick (e.g. 1s interval) with the current state.
    *
    * @param messageIndex - Index of the assistant message (0-based, sequential)
-   * @param outputTokens - Output tokens for this message
+   * @param message - The assistant message object (content used to count tokens)
    * @param hasStopReason - Whether this message has completed (has stopReason)
    */
-  onMessageUpdate(messageIndex: number, outputTokens: number, hasStopReason: boolean): void {
+  onMessageUpdate(messageIndex: number, message: unknown, hasStopReason: boolean): void {
     const now = Date.now();
+    const outputTokens = estimateOutputTokens(message);
 
     // New message — create a record
     if (messageIndex >= this.records.length) {
-      // Fill gaps if indices jump
+      // Fill gaps if indices jump (shouldn't normally happen)
       while (this.records.length < messageIndex) {
         this.records.push({
           messageIndex: this.records.length,
@@ -62,11 +138,12 @@ export class TpsTracker {
       }
 
       if (hasStopReason && outputTokens > 0) {
-        // Fast message: already completed on first sighting
-        // Estimate duration: floor of 1 second, or outputTokens/100, whichever is smaller
-        const estimatedDuration = Math.max(1, outputTokens / 100);
+        // Fast message: already completed on first sighting.
+        // We never observed it streaming, so we can't measure real duration.
+        // Fall back to a conservative estimate instead of inventing a 1s
+        // window (which previously produced inflated TPS values).
+        const estimatedDuration = Math.max(0.5, outputTokens / 60);
         const tps = outputTokens / estimatedDuration;
-
         this.records.push({
           messageIndex,
           outputTokens,
@@ -85,7 +162,6 @@ export class TpsTracker {
           tps: 0,
         });
       }
-      this.lastSeenMessageCount = messageIndex + 1;
       return;
     }
 
@@ -93,23 +169,24 @@ export class TpsTracker {
     const record = this.records[messageIndex];
     if (!record) return;
 
-    record.outputTokens = outputTokens;
+    if (record.completedAt === 0) {
+      // Still generating — update token count (live TPS computed on demand)
+      record.outputTokens = outputTokens;
 
-    if (record.completedAt === 0 && hasStopReason) {
-      // Message just completed
-      record.completedAt = now;
-      const durationSec = (record.completedAt - record.startedAt) / 1000;
-      record.tps = durationSec > 0 ? outputTokens / durationSec : outputTokens;
-      this.totalOutput += outputTokens;
-    } else if (record.completedAt === 0) {
-      // Still generating — update output tokens (live TPS computed on demand)
+      if (hasStopReason) {
+        // Message just completed
+        record.completedAt = now;
+        const durationSec = (record.completedAt - record.startedAt) / 1000;
+        record.tps = durationSec > 0 ? record.outputTokens / durationSec : 0;
+        this.totalOutput += record.outputTokens;
+      }
     }
   }
 
   /**
    * Get the live TPS from the currently generating message.
    * Returns the instantaneous rate based on tokens generated so far
-   * in the current message divided by elapsed time.
+   * in the current message divided by elapsed wall-clock time.
    */
   getLiveTps(): number {
     // Find the last record that's still generating
@@ -177,7 +254,7 @@ export class TpsTracker {
   }
 
   /**
-   * Get total output tokens for the session.
+   * Get total output tokens for the session (estimated).
    */
   getTotalOutput(): number {
     // Include tokens from incomplete messages too
@@ -195,7 +272,6 @@ export class TpsTracker {
    */
   reset(): void {
     this.records = [];
-    this.lastSeenMessageCount = 0;
     this.totalOutput = 0;
   }
 }

package/packages/info-screen/index.ts

@@ -9,6 +9,8 @@
  *   /unipi:info-settings - Configure info display
  */
 
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { UNIPI_EVENTS, MODULES, UNIPI_PREFIX, emitEvent, getPackageVersion, type UnipiModuleEvent, type UnipiInfoGroupEvent } from "@pi-unipi/core";
 import { infoRegistry } from "./registry.js";
@@ -21,7 +23,7 @@ import { InfoOverlay } from "./tui/info-overlay.js";
 import { SettingsOverlay } from "./settings/settings-tui.js";
 
 /** Package version */
-const VERSION = getPackageVersion(new URL(".", import.meta.url).pathname);
+const VERSION = getPackageVersion(dirname(fileURLToPath(import.meta.url)));
 
 export default function (pi: ExtensionAPI) {
   setPiApi(pi);

package/packages/info-screen/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pi-unipi/info-screen",
-  "version": "2.0.13",
-  "description": "Dashboard and module registry for Unipi \u2014 configurable info overlay with tabbed groups",
+  "version": "2.1.1",
+  "description": "Dashboard and module registry for Unipi — configurable info overlay with tabbed groups",
   "type": "module",
   "main": "index.ts",
   "license": "MIT",
@@ -33,11 +33,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.0.13"
+    "@pi-unipi/core": "2.1.1"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.78.0",
-    "@earendil-works/pi-tui": "^0.78.0",
+    "@earendil-works/pi-coding-agent": "^0.80.0",
+    "@earendil-works/pi-tui": "^0.80.0",
     "typebox": "^1.1.38"
   },
   "devDependencies": {

package/packages/info-screen/tui/info-overlay.ts

@@ -94,15 +94,24 @@ export class InfoOverlay implements Component {
 
   /**
    * Fetch all groups in background. Each resolves independently.
+   *
+   * Each fetch is deferred to a macrotask (setTimeout 0) so the constructor
+   * returns immediately. Without this, getGroupData() runs each group's
+   * dataProvider synchronously up to its first `await` before yielding —
+   * heavy providers (usage stats parse 1GB+ of session files, memory scans)
+   * blocked the session_start handler for seconds.
    */
-  private async fetchAllBackground(): Promise<void> {
+  private fetchAllBackground(): void {
     for (const group of this.groups) {
-      // Fire each fetch independently — don't await sequentially
-      infoRegistry.getGroupData(group.id).then(() => {
-        this.groupLoading.set(group.id, false);
-      }).catch(() => {
-        this.groupLoading.set(group.id, false);
-      });
+      // Defer each fetch to a macrotask so the overlay constructs instantly.
+      setTimeout(() => {
+        if (this._destroyed) return;
+        infoRegistry.getGroupData(group.id).then(() => {
+          this.groupLoading.set(group.id, false);
+        }).catch(() => {
+          this.groupLoading.set(group.id, false);
+        });
+      }, 0);
     }
   }
 

package/packages/input-shortcuts/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pi-unipi/input-shortcuts",
-  "version": "2.0.13",
-  "description": "Keyboard shortcuts for stash/restore, undo/redo, clipboard, and thinking toggle \u2014 chord-based overlay system",
+  "version": "2.1.1",
+  "description": "Keyboard shortcuts for stash/restore, undo/redo, clipboard, and thinking toggle — chord-based overlay system",
   "type": "module",
   "main": "src/index.ts",
   "license": "MIT",
@@ -33,11 +33,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.0.13"
+    "@pi-unipi/core": "2.1.1"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.78.0",
-    "@earendil-works/pi-tui": "^0.78.0"
+    "@earendil-works/pi-coding-agent": "^0.80.0",
+    "@earendil-works/pi-tui": "^0.80.0"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/packages/kanboard/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pi-unipi/kanboard",
-  "version": "2.0.13",
-  "description": "Visualization layer for unipi workflow \u2014 HTTP server with htmx/Alpine.js UI, modular parsers, TUI overlay, and kanban board",
+  "version": "2.1.1",
+  "description": "Visualization layer for unipi workflow — HTTP server with htmx/Alpine.js UI, modular parsers, TUI overlay, and kanban board",
   "type": "module",
   "main": "index.ts",
   "license": "MIT",
@@ -39,11 +39,11 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.0.13"
+    "@pi-unipi/core": "2.1.1"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.78.0",
-    "@earendil-works/pi-tui": "^0.78.0"
+    "@earendil-works/pi-coding-agent": "^0.80.0",
+    "@earendil-works/pi-tui": "^0.80.0"
   },
   "devDependencies": {
     "@types/node": "^25.6.0",

package/packages/mcp/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pi-unipi/mcp",
-  "version": "2.0.13",
-  "description": "MCP server management extension for Pi coding agent \u2014 browse, add, configure, and use MCP servers",
+  "version": "2.1.1",
+  "description": "MCP server management extension for Pi coding agent — browse, add, configure, and use MCP servers",
   "type": "module",
   "main": "src/index.ts",
   "license": "MIT",
@@ -27,11 +27,11 @@
     "README.md"
   ],
   "dependencies": {
-    "@pi-unipi/core": "2.0.13"
+    "@pi-unipi/core": "2.1.1"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": "^0.78.0",
-    "@earendil-works/pi-tui": "^0.78.0",
+    "@earendil-works/pi-coding-agent": "^0.80.0",
+    "@earendil-works/pi-tui": "^0.80.0",
     "typebox": "^1.1.38"
   },
   "devDependencies": {

package/packages/mcp/src/index.ts

@@ -4,6 +4,8 @@
  * Registers commands, handles session lifecycle, wires up MCP server management.
  */
 
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
 import {
   UNIPI_EVENTS,
@@ -20,7 +22,7 @@ import { renderMcpAddOverlay } from "./tui/add-overlay.js";
 import { renderMcpSettingsOverlay } from "./tui/settings-overlay.js";
 
 /** Package version */
-const VERSION = getPackageVersion(new URL(".", import.meta.url).pathname);
+const VERSION = getPackageVersion(dirname(fileURLToPath(import.meta.url)));
 
 /** Module-local registry instance */
 let registry: ServerRegistry | null = null;

package/packages/memory/README.md

@@ -1,8 +1,10 @@
 # @pi-unipi/memory
 
-Persistent memory that survives across sessions. Stores facts, preferences, and decisions in SQLite with vector search, so the agent remembers what you told it last week.
+Persistent memory that survives across sessions. Stores facts, preferences, and decisions with semantic vector search, so the agent remembers what you told it last week.
 
-Two storage tiers: SQLite + sqlite-vec for vector similarity search, markdown files for human-readable memories you can edit by hand. Project-scoped memories stay separate per codebase, global memories are accessible everywhere.
+**Primary backend: [MemPalace](https://github.com/mempalace/mempalace)** — auto-installed via `uv` on first load, with one-way auto-migration of any existing legacy memories. If MemPalace or `uv` is unavailable, the package transparently falls back to the bundled SQLite + sqlite-vec store, so memory never hard-fails.
+
+Two storage tiers: MemPalace (or SQLite) for vector similarity search, markdown files for a durable human-readable copy you can edit by hand. Project-scoped memories stay separate per codebase, global memories are accessible everywhere.
 
 ## Commands
 
@@ -72,19 +74,61 @@ Examples:
 Memory has no configuration file. Storage paths are fixed:
 
 ```
-~/.unipi/memory/
+~/.unipi/memory/                 # UniPi memory root (legacy + markdown tier)
+├── .mempalace-install           # Cached MemPalace venv detection
+├── .mempalace-migrated          # One-way migration completion flag
 ├── global/
-│   ├── memory.db              # Global vector DB
+│   ├── memory.db              # Global vector DB (SQLite fallback)
 │   └── *.md                   # Global memory files
 └── <project_name>/
-    ├── memory.db              # Project vector DB
+    ├── memory.db              # Project vector DB (SQLite fallback)
     └── *.md                   # Project memory files
+
+~/.mempalace/palace/             # MemPalace palace (primary backend)
+```
+
+## MemPalace backend
+
+On first load, the memory package:
+1. Detects MemPalace; if missing and `uv` is available, runs
+   `uv tool install mempalace` once (caches the venv python path in
+   `~/.unipi/memory/.mempalace-install`).
+2. Pings the bridge to confirm the palace is usable.
+3. If `~/.unipi/memory/.mempalace-migrated` is absent, performs a one-way
+   read-only migration of every legacy memory (SQLite rows + markdown files
+   across all projects) into MemPalace drawers, then writes the flag.
+   Migration is idempotent (deterministic drawer IDs) and never deletes or
+   mutates legacy files.
+
+Each memory operation invokes a bundled Python bridge
+(`bridge/mempalace_bridge.py`) once via `spawnSync` (~0.5s per call). The
+first MemPalace use on a machine also downloads the default ONNX embedding
+model (~80MB, cached at `~/.cache/chroma/onnx_models/`).
+
+### Forcing re-detection / re-migration
+
+```bash
+rm ~/.unipi/memory/.mempalace-install    # re-detect MemPalace next session
+rm ~/.unipi/memory/.mempalace-migrated   # re-run one-way migration next session
 ```
 
+### Backend override
+
+Set `UNIPI_MEMPALACE_BACKEND` to force a MemPalace backend
+(`sqlite_exact`, `qdrant`, `pgvector`, default `chroma`).
+
+### Embedder identity
+
+MemPalace enforces embedder identity. If a palace was created with a
+different embedding model, writes are rejected — the package then falls
+back to SQLite for that session. Use `mempalace palace set-embedder`
+intentionally to realign, then remove the install cache to re-detect.
+
 ## Dependencies
 
-- `better-sqlite3` — SQLite database
-- `sqlite-vec` — Vector search extension
+- `mempalace` (Python, auto-installed via `uv`) — primary backend
+- `better-sqlite3` — SQLite fallback database
+- `sqlite-vec` — Vector search extension (fallback)
 - `js-yaml` — YAML frontmatter parsing
 - `@pi-unipi/core` — Shared utilities
 

package/packages/memory/index.ts

@@ -7,6 +7,8 @@
  * Auto-consolidates on compaction.
  */
 
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
   UNIPI_EVENTS,
@@ -30,7 +32,7 @@ import { registerMemoryCommands } from "./commands.js";
 import { isEmbeddingReady, hasModelChanged } from "./settings.js";
 
 /** Package version */
-const VERSION = getPackageVersion(new URL(".", import.meta.url).pathname);
+const VERSION = getPackageVersion(dirname(fileURLToPath(import.meta.url)));
 
 /** Storage instance for current project */
 let projectStorage: MemoryStorage | null = null;
@@ -170,11 +172,12 @@ export default function (pi: ExtensionAPI) {
       } catch (_err) {
         // Count unavailable — status bar shows 0.
       }
-      const vecReady = isEmbeddingReady();
-      const vecIcon = vecReady ? "⚡" : "📝";
+      const mempalaceActive = projectStorage?.isMempalace() ?? false;
+      const backendIcon = mempalaceActive ? "🧠" : (isEmbeddingReady() ? "⚡" : "📝");
+      const warn = hasModelChanged() ? " ⚠" : "";
       ctx.ui.setStatus(
         "unipi-memory",
-        `${vecIcon} mem ${projectCount}p/${projectCountAll}all${hasModelChanged() ? " ⚠" : ""}`
+        `${backendIcon} mem ${projectCount}p/${projectCountAll}all${warn}`
       );
     }
   });