@fyeeme/pi-session-name 1.0.3 → 1.0.5

package/CHANGELOG.md

@@ -7,6 +7,40 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.5] - 2026-10-01
+
+### Removed
+
+- **BREAKING**: the sibling-session title dedup is gone — the extension no longer scans local session files for other sessions' names, and prompts no longer embed a `<recent_session_titles>` block. Removed the exported `parseSessionTitle()` and `collectRecentSessionTitles()` helpers, the `recentTitles` option from all prompt builders, and `classifyKeep()`'s `recentTitles` parameter (classifier state drops `recentSessionTitles`). Prompts keep their general distinctiveness rules, so titles still lead with the concrete entity/error/identifier.
+- **BREAKING**: the custom title-model override is gone — titles are always generated with the current session model (`ctx.model`). Removed the `model` field from `session-name.json`, the `PI_SESSION_NAME_MODEL_PROVIDER` / `PI_SESSION_NAME_MODEL_ID` environment variables, and the exported `resolveModel()` helper (its getAvailableOfType fallback chain went with it). Auto mode's classifier-based KEEP/NEW verdict is unaffected.
+
+### Added
+
+- Creation-time prefix: every set title becomes `yyyy-mm-dd hh:mm - title` (local timezone, parsed from the session file name). The resume picker sorts by last-modified, so editing an old session made its age invisible and it could get lost; the prefix keeps the original creation time visible. Opt out with `PI_SESSION_NAME_TIMESTAMP=false` or `"appendCreationTime": false` in `.pi/agent/session-name.json`.
+- Prompt-style switch: `prompt: "concise" | "editorial"` (env `PI_SESSION_NAME_PROMPT`). `concise` (default) is the deepseek-harness system prompt verbatim with a 512-token budget; `editorial` adds pi's distinctiveness/concrete-detail rules with a 1024-token budget — measured A/B on 50 local sessions: concise 96% yield / p50 5.1 s, editorial denser titles / ~30% slower.
+- New `mode: "follow"` (env `PI_SESSION_NAME_MODE=follow`): every settled turn regenerates the title unconditionally — the deepseek-harness `all-prompts` cadence — so the title tracks the conversation as its real subject emerges instead of freezing on an early-turn snapshot. Unlike `first`/`auto`, `follow` also keeps tracking a resumed session's inherited title (treated as the last revision, not a pin); `/rename` still pins either way.
+- Title-hardening practices adapted from deepseek-harness's `session-title` package: (1) terminal- and spoof-safe title sanitization — ANSI/OSC/CSI/ESC escapes, C0/C1 control characters, and zero-width/bidi directional controls are stripped before acceptance, and truncation is code-point-safe (never splits a surrogate pair); (2) the conversation is JSON-framed in the prompt (`JSON.stringify` of the selected messages), so untrusted user text cannot forge structural delimiters like a fake `</conversation>` or `Assistant:` turn; (3) title generation caps the auxiliary call at `maxTokens: 512`, bounding runaway output; (4) prompt length targets are language-aware (CJK characters vs. non-CJK words).
+- Auto mode's KEEP/NEW verdict now runs on a classifier model when the host has one (pi 0.99 `ModelRuntime.classify()`, bool question): a KEEP verdict skips the generation call entirely, and a NEW verdict generates the replacement through a rules-only prompt. Without a classifier — or when the classifier call fails — the original single-verdict `complete()` path runs unchanged.
+
+### Changed
+
+- **BREAKING**: the config file moved from `.pi/session-name.json` to `.pi/agent/session-name.json`.
+- **BREAKING**: the title pipeline is now aligned 1:1 with deepseek-harness's `session-title` architecture wherever the pi extension host allows: (1) requests carry only **human messages** (assistant/system no longer enter a title prompt) in a **system/user split** — the system instruction is deepseek-harness's exact wording (plain text, no Markdown/XML/code/terminal codes, ~6 words / ~18 CJK chars) and the user payload is the JSON-framed message array; (2) `maxLength` is now a **UTF-8 byte budget** (200 bytes ≈ 200 ASCII chars or ~66 CJK chars, `truncateTitleUtf8` semantics) instead of a character count; (3) generation has a 20 s deadline composed with Esc/abort, and any failure (error, abort, timeout, non-`stop` finish, empty output) falls back to a **deterministic first-message title** (`fallbackSessionTitle`, zero LLM) instead of leaving the session untitled; (4) input carries a 16 KiB UTF-8 budget that narrows from the oldest non-first message.
+- **BREAKING**: the default `mode` is now `"follow"` — every settled turn regenerates the title so it tracks the conversation's real subject instead of freezing on an early-turn snapshot (and across resumes: an inherited title is treated as the last revision). Set `mode: "first"` (or `PI_SESSION_NAME_MODE=first`) to keep the old one-shot behavior; `"auto"` remains available.
+- ~~Model resolution accepts a provider-only `model` config~~ (superseded: the custom-model override was removed — see Removed above; title generation now reads `ctx.model` directly.)
+- Peer dependency floor raised to `@earendil-works/pi-coding-agent >= 0.99.0`; dev toolchain pinned to 0.99.2.
+
+## [1.0.4] - 2026-09-17
+
+### Added
+
+- Conflict-aware naming: `collectRecentSessionTitles` / `parseSessionTitle` scan local sibling session files (newest first, 60s TTL cache) and inject the recent titles into both the first-title and auto-rename prompts, so a generated title never duplicates or rewords one already in the session list. The current session's file and its own name are excluded; any storage read failure degrades silently to no list.
+
+### Changed
+
+- Prompt rewrite for distinctiveness: titles must lead with the concrete entity, error, or identifier instead of generic labels ("bug fix", "code review"); parentheses are banned from output; auto-mode titles now aim for 30-55 characters and prefer capturing the conversation's root cause or conclusion over staying short.
+- README tip: in `first` mode the session is named after the first turn — switch to `"mode": "auto"` when the key point usually emerges only in later turns.
+
 ## [1.0.3] - 2026-09-09
 
 ### Changed

package/README.md

@@ -7,17 +7,19 @@ Auto-name [pi](https://pi.dev) sessions with a short LLM-generated title so `--r
 
 ## Features
 
-- **First-mode** (default) — names the session once on first agent response, then leaves it alone
-- **Auto-mode** — re-evaluates each turn; the title tracks the current topic
+- **Follow-mode** (default) — regenerates the title every turn, so it tracks the conversation as its real subject emerges (never freezes on an early-turn snapshot)
+- **First-mode** — names the session once on first agent response, then leaves it alone
+- **Auto-mode** — re-evaluates each turn (KEEP/NEW verdict); the title tracks the current topic
 - **Never overwrites manual names** — detects `/name`, `--name`, the resume picker's rename, or any other extension calling `setSessionName`, and locks itself for the rest of the session
+- **Creation-time prefix** — every title is prefixed `yyyy-mm-dd hh:mm - …` so sessions edited later still show when they were created (the list sorts by last-modified)
 - **`/rename [name]`** — rename the current session on demand. With an argument it sets that name; without, it generates one from the conversation
 - **Language-aware** — titles use the same language as your first message
-- **Descriptive titles** — key entity + action + goal (~15-40 chars), not terse labels
-- **Graceful failure** — model unavailable or no API key? Stays silent, never blocks the session
+- **Distinctive titles** — leads with the concrete entity/error/identifier, so similar sessions don't blur together (~15-40 chars)
+- **Graceful failure** — model unavailable or model call fails? Stays silent, never blocks the session
 
 ## Prerequisites
 
-- [pi](https://pi.dev) >= 0.80.0 (uses `agent_settled` / `session_info_changed` events)
+- [pi](https://pi.dev) >= 0.87.0 (uses `agent_settled` / `session_info_changed` events and `ctx.modelRegistry.complete()`)
 
 ## Installation
 
@@ -49,6 +51,8 @@ ln -s "$(pwd)" ~/.pi/agent/extensions/pi-session-name
 
 No configuration needed for the default `first` mode. Just install and use pi — your first session will auto-name itself.
 
+> **Tip**: in `first` mode the session is named after the first turn, so if the root cause or key point usually emerges only in later turns, set `"mode": "auto"` — the title then re-evaluates each turn and tracks the conversation's conclusion.
+
 If you want to change behavior, see [Configuration](#configuration).
 
 ### Commands
@@ -62,7 +66,7 @@ If you want to change behavior, see [Configuration](#configuration).
 
 ## Configuration
 
-Create `.pi/session-name.json` in your project root:
+Create `.pi/agent/session-name.json` in your project root:
 
 ```json
 {
@@ -76,12 +80,13 @@ Create `.pi/session-name.json` in your project root:
 
 | Option | Default | Env override | Description |
 |--------|---------|--------------|-------------|
-| `mode` | `"first"` | `PI_SESSION_NAME_MODE` | `"first"` — name once; `"auto"` — re-evaluate each turn |
-| `maxLength` | `200` | `PI_SESSION_NAME_MAX_LENGTH` | Character cap for generated titles |
+| `mode` | `"follow"` | `PI_SESSION_NAME_MODE` | `"follow"` — regenerate every turn (all-prompts cadence); `"first"` — name once; `"auto"` — re-evaluate each turn (KEEP/NEW) |
+| `maxLength` | `200` | `PI_SESSION_NAME_MAX_LENGTH` | UTF-8 byte budget for accepted titles (200 bytes ≈ 200 ASCII chars or ~66 CJK chars) |
+| `prompt` | `"concise"` | `PI_SESSION_NAME_PROMPT` | `"concise"` — deepseek-harness wording, 512-token budget (default); `"editorial"` — adds distinctiveness/concrete-detail rules, 1024-token budget |
 | `enabled` | `true` | `PI_SESSION_NAME_ENABLED=false` | Master switch to disable auto-naming |
-| `model` | current session model | `PI_SESSION_NAME_MODEL_PROVIDER` + `PI_SESSION_NAME_MODEL_ID` | Override the model used to generate titles |
+| `appendCreationTime` | `true` | `PI_SESSION_NAME_TIMESTAMP=false` | Prefix every title with the session's creation time — `yyyy-mm-dd hh:mm - title`. The resume list sorts by last-modified, so an edited old session resurfaces at the top; the prefix keeps its original age visible. Parsed from the session file name (best effort: no stamp, no prefix). |
 
-By default the extension uses the model you're already chatting with (`ctx.model`), so no extra API key is needed.
+Titles are generated with the model you're already chatting with (`ctx.model`) — there is no model override. Model calls go through `ctx.modelRegistry.complete()`, which resolves authentication at request time — API keys and OAuth subscription logins both work, with no extra API key configuration.
 
 ### Environment variables only
 
@@ -91,17 +96,34 @@ If you prefer environment variables over a config file:
 export PI_SESSION_NAME_MODE=auto
 export PI_SESSION_NAME_MAX_LENGTH=150
 export PI_SESSION_NAME_ENABLED=true
-export PI_SESSION_NAME_MODEL_PROVIDER=openai
-export PI_SESSION_NAME_MODEL_ID=gpt-4o-mini
 ```
 
 ## How it works
 
-1. On `agent_settled` (after the first turn completes), the extension builds a condensed text of the conversation
-2. It asks the LLM (same model as the session, unless overridden) to generate a descriptive title
-3. The title is set via `pi.setSessionName()`, which updates the resume picker immediately
-4. In `first` mode, it stops there. In `auto` mode, each subsequent turn re-evaluates: the LLM returns either `KEEP` or a new title
-5. If a manual rename is detected (`session_info_changed` with a name the extension didn't set), auto-naming locks permanently
+### Modes
+
+- **`follow`** (default) — every settled turn regenerates the title unconditionally (the deepseek-harness `all-prompts` cadence): the title always tracks the conversation's current subject, including across resumes (an inherited title is treated as the last revision, not a pin). Costs one short generation call per turn; the title may change between turns — `/rename` pins it for good.
+- **`first`** — one title after the first turn. Cheapest, but the title freezes on the early-turn snapshot: if the conversation's real subject emerges later, the title drifts.
+- **`auto`** — after the first title, each settled turn runs a KEEP/NEW verdict (a classifier model when the host has one); KEEP costs no generation call, NEW regenerates. Balanced.
+
+### Prompt styles
+
+Two system-prompt styles ship (measured A/B on 50 local sessions with a reasoning model, glm-5.3-flash):
+
+- **`concise`** (default) — deepseek-harness wording verbatim: four lines of format discipline, no editorial content rules. 96% title yield, p50 latency 5.1 s, uniform lengths.
+- **`editorial`** — same architecture plus pi's distinctiveness rules (never a generic headline; carry the concrete module/error/identifier). Titles are more information-dense, but the extra rules induce longer chain-of-thought on reasoning models, so the output budget is raised to 1024 tokens and latency runs ~30% higher.
+
+Switch in `.pi/agent/session-name.json` (`"prompt": "editorial"`) or via `PI_SESSION_NAME_PROMPT=editorial`.
+
+### Pipeline (deepseek-harness discipline, 1:1 where the host allows)
+
+1. On `agent_settled`, the extension collects the eligible **human messages** (assistant/system never enter a title request): first message plus the recent tail, per-message cap, and a 16 KiB UTF-8 input budget that narrows from the oldest non-first message
+2. It sends a **system/user split** request: the system instruction carries the output discipline (plain text, no Markdown/XML/code/terminal codes, language of the messages, ~6 words / ~18 CJK chars); the user payload is the JSON-framed message array, so untrusted text cannot forge structural delimiters
+3. Output is normalized — ANSI/OSC/CSI/control/bidi stripping, quote/punctuation trimming — and capped by a **UTF-8 byte budget** (`maxLength`, default 200 bytes ≈ 200 ASCII chars or ~66 CJK chars)
+4. On any failure (provider error, abort, 20 s timeout, non-`stop` finish, empty output), a **deterministic fallback** names the session from the first human message's leading words — zero LLM involvement
+5. The title is set via `pi.setSessionName()`, which updates the resume picker immediately
+6. In `first` mode, it stops there. `follow` regenerates every turn (all-prompts cadence). `auto` runs a KEEP/NEW verdict (classifier when available)
+7. If a manual rename is detected (`session_info_changed` with a name the extension didn't set), auto-naming locks permanently
 
 ## Smoke test
 
@@ -121,7 +143,7 @@ pi -e @fyeeme/pi-session-name
 /rename foo    # → name is "foo", locked
 /rename        # → generates a fresh name from the conversation
 
-# 5. Graceful degradation (unset model's API key)
+# 5. Graceful degradation (model unavailable / model call fails)
 # → No errors, session runs normally
 ```
 
@@ -131,10 +153,11 @@ This extension exposes utilities that other extensions can import:
 
 ```typescript
 import {
-	buildConversationText,
-	cleanTitle,
-	buildFirstPrompt,
-	buildAutoPrompt,
+	buildTitleMessages,
+	normalizeSessionTitle,
+	fallbackSessionTitle,
+	buildTitleRequest,
+	buildVerdictRequest,
 	loadConfig,
 	generateTitle,
 } from "@fyeeme/pi-session-name";

package/index.ts

@@ -1,14 +1,94 @@
 import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import { CONFIG_DIR_NAME, type ExtensionAPI, type ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { Model } from "@earendil-works/pi-ai";
-import { complete } from "@earendil-works/pi-ai/compat";
 
 // ---------------------------------------------------------------------------
-// Types & helpers for buildConversationText
+// Normalize layer — terminal-safe & spoof-safe text normalization with UTF-8
+// byte budgets. Adapted 1:1 from deepseek-harness session-title/normalize.ts:
+// escape/control stripping before acceptance, code-point-safe truncation, and
+// a deterministic first-words fallback. `maxBytes` budgets are UTF-8 bytes.
+// ---------------------------------------------------------------------------
+
+/** Operating-system-command escape sequences, including unterminated tails. */
+const OSC_SEQUENCE = /(?:\u001B\]|\u009D)(?:(?!\u0007|\u001B\\)[\s\S])*(?:\u0007|\u001B\\|$)/gu;
+/** Control-sequence-introducer escapes such as SGR color codes. */
+const CSI_SEQUENCE = /(?:\u001B\[|\u009B)[0-?]*[ -/]*[@-~]/gu;
+/** Remaining two-byte ESC control sequences. */
+const ESC_SEQUENCE = /\u001B[@-_]/gu;
+/** Non-whitespace C0/C1 control characters. */
+const CONTROL_CHARACTER = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/gu;
+/** Directional and invisible controls that can make a displayed title deceptive. */
+const DIRECTIONAL_CONTROL = /[\u200B\u200E\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF]/gu;
+
+const utf8Bytes = (s: string): number => Buffer.byteLength(s, "utf8");
+
+/** Remove controls and produce one trimmed, whitespace-normalized line. */
+function cleanTitleText(input: string): string {
+	return input
+		.replace(OSC_SEQUENCE, "")
+		.replace(CSI_SEQUENCE, "")
+		.replace(ESC_SEQUENCE, "")
+		.replace(CONTROL_CHARACTER, "")
+		.replace(DIRECTIONAL_CONTROL, "")
+		.replace(/\s+/gu, " ")
+		.trim();
+}
+
+/** Truncate to a UTF-8 byte budget without splitting a Unicode code point.
+ *  1:1 from deepseek-harness `truncateTitleUtf8`. */
+export function truncateTitleUtf8(input: string, maxBytes: number): string {
+	if (!Number.isInteger(maxBytes) || maxBytes <= 0) throw new Error("maxBytes must be a positive integer");
+	if (utf8Bytes(input) <= maxBytes) return input;
+	let used = 0;
+	let output = "";
+	for (const character of input) {
+		const bytes = utf8Bytes(character);
+		if (used + bytes > maxBytes) break;
+		output += character;
+		used += bytes;
+	}
+	return output;
+}
+
+/**
+ * Normalize one accepted title and enforce its UTF-8 byte budget.
+ * deepseek-harness `normalizeSessionTitle` plus pi's quote/bracket/trailing-
+ * punctuation stripping (a strict superset — harmless when the model obeys
+ * the prompt, valuable when it does not).
+ * @returns the terminal-safe one-line title, or null when nothing survives.
+ */
+export function normalizeSessionTitle(raw: string, maxBytes: number): string | null {
+	if (!raw) return null;
+	let t = cleanTitleText(raw);
+	t = t.replace(/^["'`\u300C\u300E\uFF08(\[]+|["'`\u300D\u300F\uFF09)\].]+$/g, "").trim();
+	t = t.replace(/\s+/g, " ");
+	t = t.replace(/[.\u3002!\uFF01?\uFF1F]+$/g, "");
+	if (!t) return null;
+	t = truncateTitleUtf8(t, maxBytes).trimEnd();
+	return t.length > 0 ? t : null;
+}
+
+/**
+ * Derive the deterministic first-prompt fallback title.
+ * 1:1 from deepseek-harness `fallbackSessionTitle`: leading whitespace-
+ * delimited words within both limits. Zero LLM involvement.
+ */
+export function fallbackSessionTitle(input: string, maxWords: number, maxBytes: number): string | null {
+	if (!Number.isInteger(maxWords) || maxWords <= 0) throw new Error("maxWords must be a positive integer");
+	const words = cleanTitleText(input).split(" ").filter(Boolean).slice(0, maxWords);
+	if (words.length === 0) return null;
+	const t = truncateTitleUtf8(words.join(" "), maxBytes).trimEnd();
+	return t.length > 0 ? t : null;
+}
+
+// ---------------------------------------------------------------------------
+// Message selection — human messages only (deepseek-harness contract:
+// `sessionTitleUserMessageOf` extracts user-sourced text blocks and drops
+// messages that normalize to empty). system/tool messages never enter a
+// title request.
 // ---------------------------------------------------------------------------
 
-type ContentBlock = { type?: string; text?: string };
 export type SessionEntry = { type: string; message?: { role?: string; content?: unknown } };
 
 const extractText = (content: unknown): string[] => {
@@ -17,94 +97,162 @@ const extractText = (content: unknown): string[] => {
 	const parts: string[] = [];
 	for (const part of content) {
 		if (part && typeof part === "object") {
-			const b = part as ContentBlock;
+			const b = part as { type?: string; text?: string };
 			if (b.type === "text" && typeof b.text === "string") parts.push(b.text);
 		}
 	}
 	return parts;
 };
 
-const truncate = (s: string, max: number): string => (s.length <= max ? s : `${s.slice(0, max)}\u2026`);
+/** Code-point-safe per-message truncation with an ellipsis marker. */
+const truncate = (s: string, max: number): string => (Array.from(s).length <= max ? s : `${Array.from(s).slice(0, max).join("")}\u2026`);
+
+/** Default input policy: window + per-message cap + total UTF-8 budget. */
+export const TITLE_INPUT_DEFAULTS = { maxMessages: 8, maxCharsPerMessage: 600, maxInputBytes: 16384 } as const;
 
-export function buildConversationText(
+/**
+ * Eligible human messages for a title request, in order: first message plus
+ * the most recent tail (pi's window; deepseek-harness feeds either the first
+ * message or all of them, with a deployment-level byte budget — pi is a
+ * terminal extension, so oversize inputs narrow the window from the oldest
+ * non-first message instead of failing the request).
+ */
+export function buildTitleMessages(
 	entries: SessionEntry[],
-	opts: { maxMessages?: number; maxCharsPerMessage?: number } = {},
-): string {
-	const maxMessages = opts.maxMessages ?? 8;
-	const maxCharsPerMessage = opts.maxCharsPerMessage ?? 600;
+	opts: { maxMessages?: number; maxCharsPerMessage?: number; maxInputBytes?: number } = {},
+): string[] {
+	const maxMessages = opts.maxMessages ?? TITLE_INPUT_DEFAULTS.maxMessages;
+	const maxCharsPerMessage = opts.maxCharsPerMessage ?? TITLE_INPUT_DEFAULTS.maxCharsPerMessage;
+	const maxInputBytes = opts.maxInputBytes ?? TITLE_INPUT_DEFAULTS.maxInputBytes;
 	const msgs = entries
-		.filter((e) => e.type === "message" && (e.message?.role === "user" || e.message?.role === "assistant"))
-		.map((e) => ({
-			role: e.message!.role as "user" | "assistant",
-			text: extractText(e.message!.content).join("\n").trim(),
-		}))
-		.filter((m) => m.text.length > 0);
-	if (msgs.length === 0) return "";
+		.filter((e) => e.type === "message" && e.message?.role === "user")
+		.map((e) => truncate(extractText(e.message!.content).join("\n").trim(), maxCharsPerMessage))
+		.filter((t) => cleanTitleText(t).length > 0);
+	if (msgs.length === 0) return [];
 	const selected = msgs.length > maxMessages ? [msgs[0], ...msgs.slice(-(maxMessages - 1))] : msgs;
-	return selected
-		.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${truncate(m.text, maxCharsPerMessage)}`)
-		.join("\n\n");
+	// Enforce the framed-input byte budget by dropping the oldest non-first
+	// messages (deepseek-harness throws on overflow; a terminal extension
+	// narrows instead).
+	while (selected.length > 1 && utf8Bytes(frameTitleMessages(selected)) > maxInputBytes) {
+		selected.splice(1, 1);
+	}
+	return selected;
 }
 
 // ---------------------------------------------------------------------------
-// cleanTitle — strip wrapping quotes/brackets, collapse whitespace, truncate
+// Prompt layer — 1:1 deepseek-harness session-title-llm texts: a stable
+// language-aware system instruction and a JSON-framed user payload, so
+// untrusted text cannot forge structural delimiters. Target counts are pi's
+// defaults (deepseek-harness leaves them to deployment configuration).
 // ---------------------------------------------------------------------------
 
-export function cleanTitle(raw: string, maxLength: number = 200): string | null {
-	if (!raw) return null;
-	let t = raw.trim();
-	t = t.replace(/^["'`\u300C\u300E\uFF08(\[]+|["'`\u300D\u300F\uFF09)\].]+$/g, "").trim();
-	t = t.replace(/\s+/g, " ");
-	t = t.replace(/[.\u3002!\uFF01?\uFF1F]+$/g, "");
-	if (!t) return null;
-	if (t.length > maxLength) t = t.slice(0, maxLength).trim();
-	return t.length > 0 ? t : null;
+export const TITLE_TARGET_WORDS = 6;
+export const TITLE_TARGET_CJK_CHARACTERS = 18;
+
+/** Prompt style: "concise" = deepseek-harness wording (default); "editorial" =
+ *  the same architecture plus pi's distinctiveness/concrete-detail rules.
+ *  A/B on 50 local sessions (glm-5.3-flash): concise yields 96% titles at
+ *  512 output tokens; editorial rules induce longer chain-of-thought on
+ *  reasoning models, so its output budget is raised to 1024 tokens. */
+export type PromptStyle = "concise" | "editorial";
+
+export const TITLE_MAX_OUTPUT_TOKENS: Record<PromptStyle, number> = { concise: 512, editorial: 1024 };
+
+/** Stable language-aware system instruction. "concise" is deepseek-harness
+ *  wording; "editorial" keeps the same format discipline and adds pi's
+ *  distinctiveness rules (higher information density, higher token cost). */
+export function titleSystemPrompt(style: PromptStyle = "concise"): string {
+	const base = [
+		"Create a concise title for an AI coding-assistant session from the supplied human messages.",
+		"Return only the title on one line, **in plain text of natural language**, with no quotes, prefix, explanation, Markdown, XML, or terminal control codes. No code is allowed.",
+		"Use the language of the messages.",
+	];
+	if (style === "editorial") {
+		return [
+			...base,
+			'Distinctiveness first: the title must tell this session apart from other sessions in the list. Generic labels ("bug fix", "problem analysis", "code review") could describe any session — never use them as the headline.',
+			"Carry the concrete detail: name the specific module, error, symptom, or business object involved, and include the single most identifying identifier (ticket, order, class, or file name) when there is one.",
+			"Aim for roughly 15-40 characters in CJK languages, or 5-12 words in other languages.",
+		].join("\n");
+	}
+	return [...base, `Aim for about ${TITLE_TARGET_WORDS} words in non-CJK languages or ${TITLE_TARGET_CJK_CHARACTERS} CJK characters.`].join("\n");
 }
 
-// ---------------------------------------------------------------------------
-// Prompt builders — first-title & auto-rename prompts
-// ---------------------------------------------------------------------------
+/** Frame exact messages as JSON so user text cannot break structural delimiters. */
+export function frameTitleMessages(messages: readonly string[]): string {
+	return `Generate the session title from this JSON array of human messages:\n${JSON.stringify(messages)}`;
+}
 
-export function buildFirstPrompt(
-	conversationText: string,
-	opts: { maxLength?: number } = {},
-): string {
-	const maxLength = opts.maxLength ?? 200;
-	return [
-		"You generate a descriptive title for this conversation so the user can find it later in a session list.",
-		"Rules:",
-		'- Output ONLY the title text. No quotes, no trailing punctuation, no explanation.',
-		"- Use the SAME language as the user's first message.",
-		'- Be descriptive, not terse: include the key entity (class, component, or concept), the action, and the goal — not a vague category.',
-		`- Aim for roughly 15-40 characters; never exceed ${maxLength} characters.`,
-		"",
-		"<conversation>",
-		conversationText,
-		"</conversation>",
-	].join("\n");
+/** One model-visible title request: system instruction + JSON-framed payload. */
+export interface TitleRequest {
+	readonly system: string;
+	readonly user: string;
+	/** Style-dependent output budget (concise 512 / editorial 1024 tokens). */
+	readonly maxOutputTokens: number;
 }
 
-export function buildAutoPrompt(
-	currentName: string,
-	conversationText: string,
-	opts: { maxLength?: number } = {},
-): string {
-	const maxLength = opts.maxLength ?? 200;
-	return [
+/**
+ * Build a title request from the eligible human messages.
+ * - "first": only the first message (deepseek-harness first-prompt cadence — pi's `first` mode)
+ * - "all": every message in the window (deepseek-harness all-prompts cadence — pi's `follow` mode)
+ */
+export function buildTitleRequest(mode: "first" | "all", messages: readonly string[], style: PromptStyle = "concise"): TitleRequest {
+	if (messages.length === 0) throw new Error("title request requires at least one human message");
+	const selected = mode === "first" ? [messages[0]!] : messages;
+	return { system: titleSystemPrompt(style), user: frameTitleMessages(selected), maxOutputTokens: TITLE_MAX_OUTPUT_TOKENS[style] };
+}
+
+/** pi-only: single-verdict KEEP/NEW fallback request for `auto` mode when no
+ *  classifier model is available (deepseek-harness has no equivalent). */
+export function buildVerdictRequest(currentName: string, messages: readonly string[], style: PromptStyle = "concise"): TitleRequest {
+	const system = [
 		"You decide whether the session title still matches the conversation.",
-		`- Current title: ${currentName}`,
+		`Current title: ${currentName}`,
 		"If the title is still accurate, reply with exactly: KEEP",
-		"If it is inaccurate or too vague now, output a NEW descriptive title.",
-		"Rules for a new title:",
-		'- ONLY the title text. No quotes, no trailing punctuation, no explanation.',
-		"- Use the SAME language as the user's first message.",
-		'- Be descriptive, not terse: include the key entity (class, component, or concept), the action, and the goal — not a vague category.',
-		`- Aim for roughly 15-40 characters; never exceed ${maxLength} characters.`,
-		"",
-		"<conversation>",
-		conversationText,
-		"</conversation>",
+		"If it is inaccurate, outdated, or hard to tell apart from other sessions, reply with a NEW title instead:",
+		"- The new title is one line of plain text: no quotes, no Markdown, no code, no explanation.",
+		"- Use the language of the first human message.",
+		...(style === "editorial"
+			? [
+				'- Distinctiveness first: never use generic labels ("bug fix", "code review") as the headline; carry the concrete module, error, or identifier.',
+				"- Aim for roughly 15-40 characters in CJK languages, or 5-12 words in other languages.",
+			]
+			: [`- Aim for about ${TITLE_TARGET_WORDS} words in non-CJK languages or ${TITLE_TARGET_CJK_CHARACTERS} CJK characters.`]),
 	].join("\n");
+	return { system, user: frameTitleMessages(messages), maxOutputTokens: TITLE_MAX_OUTPUT_TOKENS[style] };
+}
+
+// ---------------------------------------------------------------------------
+// Creation-time prefix — pi's session list sorts by last-modified, so an
+// edited old session resurfaces at the top and its age becomes invisible.
+// Prefixing the creation time (parsed from the session file name) keeps it
+// discoverable: "yyyy-mm-dd hh:mm - <title>".
+// ---------------------------------------------------------------------------
+
+/** Parse the session's creation timestamp from its file name
+ *  (`2026-10-01T10-06-10-085Z_<uuid>.jsonl`). Best effort: null when the name
+ *  does not carry a parseable stamp. */
+export function sessionCreationTime(sessionFile?: string): Date | null {
+	if (!sessionFile) return null;
+	const m = basename(sessionFile).match(/^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})-\d{3}Z_/);
+	if (!m) return null;
+	const d = new Date(Date.UTC(+m[1]!, +m[2]! - 1, +m[3]!, +m[4]!, +m[5]!, +m[6]!));
+	return Number.isNaN(d.getTime()) ? null : d;
+}
+
+/** Local-timezone "yyyy-mm-dd hh:mm" (24h). */
+export function formatCreationPrefix(d: Date): string {
+	const p = (n: number): string => String(n).padStart(2, "0");
+	return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
+/** Prefix the creation time: "yyyy-mm-dd hh:mm - title". Best effort: the
+ *  title is returned unchanged when the stamp is unavailable or disabled. */
+export function withCreationTime(title: string, sessionFile: string | undefined, enabled: boolean): string {
+	if (!enabled) return title;
+	const d = sessionCreationTime(sessionFile);
+	if (!d) return title;
+	return `${formatCreationPrefix(d)} - ${title}`;
 }
 
 // ---------------------------------------------------------------------------
@@ -112,74 +260,91 @@ export function buildAutoPrompt(
 // ---------------------------------------------------------------------------
 
 export interface SessionNameConfig {
-	mode: "first" | "auto";
+	mode: "first" | "auto" | "follow";
+	/** System-prompt style: "concise" (deepseek-harness wording, default) or
+	 *  "editorial" (adds pi's distinctiveness rules; higher output budget). */
+	prompt: PromptStyle;
 	enabled: boolean;
+	/** Prefix the session's creation time onto every set title
+	 *  ("yyyy-mm-dd hh:mm - title"), because the resume list sorts by
+	 *  last-modified. Default true. */
+	appendCreationTime: boolean;
+	/** Maximum UTF-8 bytes in an accepted title (byte budget, deepseek-harness
+	 *  semantics: 200 bytes ≈ 200 ASCII chars or ~66 CJK characters). */
 	maxLength: number;
-	model?: { provider: string; id: string };
 }
 
-const DEFAULT_CONFIG: SessionNameConfig = { mode: "first", enabled: true, maxLength: 200 };
+const DEFAULT_CONFIG: SessionNameConfig = { mode: "follow", prompt: "concise", enabled: true, appendCreationTime: true, maxLength: 200 };
 
 export function loadConfig(cwd: string, env: Record<string, string | undefined> = process.env): SessionNameConfig {
 	let fileCfg: Partial<SessionNameConfig> = {};
-	const file = join(cwd, CONFIG_DIR_NAME, "session-name.json");
+	const file = join(cwd, CONFIG_DIR_NAME, "agent", "session-name.json");
 	try {
 		fileCfg = JSON.parse(readFileSync(file, "utf8")) as Partial<SessionNameConfig>;
 	} catch {
 		// missing or malformed config — ignore, fall back to defaults
 	}
 	const cfg: SessionNameConfig = { ...DEFAULT_CONFIG, ...fileCfg };
-	if (env.PI_SESSION_NAME_MODE === "first" || env.PI_SESSION_NAME_MODE === "auto") cfg.mode = env.PI_SESSION_NAME_MODE;
+	if (env.PI_SESSION_NAME_MODE === "first" || env.PI_SESSION_NAME_MODE === "auto" || env.PI_SESSION_NAME_MODE === "follow") {
+		cfg.mode = env.PI_SESSION_NAME_MODE;
+	}
+	if (env.PI_SESSION_NAME_PROMPT === "concise" || env.PI_SESSION_NAME_PROMPT === "editorial") cfg.prompt = env.PI_SESSION_NAME_PROMPT;
 	if (env.PI_SESSION_NAME_ENABLED === "false") cfg.enabled = false;
+	if (env.PI_SESSION_NAME_TIMESTAMP === "false") cfg.appendCreationTime = false;
 	if (env.PI_SESSION_NAME_MAX_LENGTH) {
 		const n = Number(env.PI_SESSION_NAME_MAX_LENGTH);
 		if (Number.isFinite(n) && n > 0) cfg.maxLength = n;
 	}
-	const provider = env.PI_SESSION_NAME_MODEL_PROVIDER;
-	const id = env.PI_SESSION_NAME_MODEL_ID;
-	if (provider && id) cfg.model = { provider, id };
 	return cfg;
 }
 
 // ---------------------------------------------------------------------------
-// ModelAuth + resolveModelAndAuth
+// generateTitle — model call via ctx.modelRegistry (auth resolved at request
+// time). deepseek-harness discipline: system/user split, output-token cap,
+// end-to-end deadline composed with the caller's signal, and finish-reason
+// checking (anything but "stop" is a failure, not a title).
 // ---------------------------------------------------------------------------
 
-export type ModelAuth = { model: Model<any>; apiKey: string; headers: Record<string, string> | undefined };
-
-export async function resolveModelAndAuth(
-	ctx: ExtensionContext,
-	cfg: SessionNameConfig,
-	getModelFn?: (provider: string, id: string) => Model<any> | undefined,
-): Promise<ModelAuth | null> {
-	const find = getModelFn ?? ((p: string, i: string) => ctx.modelRegistry.find(p, i) as Model<any> | undefined);
-	const model = cfg.model ? find(cfg.model.provider, cfg.model.id) : ctx.model;
-	if (!model) return null;
-	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-	if (!auth?.ok || !auth.apiKey) return null;
-	return { model, apiKey: auth.apiKey, headers: auth.headers };
+const TITLE_TIMEOUT_MS = 20_000;
+
+/** Compose optional signals (caller abort + timeout) into one abort signal. */
+function composeSignals(signals: Array<AbortSignal | undefined>): AbortSignal {
+	const controller = new AbortController();
+	const onAbort = () => controller.abort();
+	for (const s of signals) {
+		if (!s) continue;
+		if (s.aborted) {
+			controller.abort();
+			return controller.signal;
+		}
+		s.addEventListener("abort", onAbort, { once: true });
+	}
+	return controller.signal;
 }
 
-// ---------------------------------------------------------------------------
-// generateTitle — call LLM to produce a short title
-// ---------------------------------------------------------------------------
-
 export async function generateTitle(
-	prompt: string,
-	auth: ModelAuth,
-	completeFn: typeof complete = complete,
+	request: TitleRequest,
+	model: Model<any>,
+	ctx: ExtensionContext,
 	signal?: AbortSignal,
 ): Promise<string> {
-	const response = await completeFn(
-		auth.model,
+	const now = Date.now();
+	const response = await ctx.modelRegistry.complete(
+		model,
 		{
 			messages: [
-				{ role: "user", content: [{ type: "text", text: prompt }], timestamp: Date.now() },
+				{ role: "system", content: [{ type: "text", text: request.system }], timestamp: now },
+				{ role: "user", content: [{ type: "text", text: request.user }], timestamp: now },
 			],
 		},
-		// ctx.signal (undefined while idle) lets Esc/abort cancel the nested call.
-		{ apiKey: auth.apiKey, headers: auth.headers, signal },
+		{
+			// ctx.signal (undefined while idle) lets Esc/abort cancel the nested
+			// call; the deadline keeps a hung provider from blocking the next turn.
+			signal: composeSignals([signal, AbortSignal.timeout(TITLE_TIMEOUT_MS)]),
+			maxTokens: request.maxOutputTokens,
+		},
 	);
+	if (response.stopReason !== "stop") return "";
 	return response.content
 		.filter((c): c is { type: "text"; text: string } => c.type === "text")
 		.map((c) => c.text)
@@ -187,12 +352,67 @@ export async function generateTitle(
 		.trim();
 }
 
+// ---------------------------------------------------------------------------
+// Classifier path — auto mode's KEEP/NEW verdict as a bool classify
+// ---------------------------------------------------------------------------
+
+type ClassifierLike = Parameters<ExtensionContext["modelRegistry"]["classify"]>[0];
+
+/** First available classifier model, or null when the host has none. */
+export async function resolveClassifierModel(ctx: ExtensionContext): Promise<ClassifierLike | null> {
+	const registry = ctx.modelRegistry as ExtensionContext["modelRegistry"] & {
+		getAvailableOfType?: (type: "classifier", provider?: string) => Promise<readonly unknown[]>;
+	};
+	if (typeof registry.getAvailableOfType !== "function") return null;
+	try {
+		const available = await registry.getAvailableOfType("classifier");
+		return (available[0] as ClassifierLike | undefined) ?? null;
+	} catch {
+		return null;
+	}
+}
+
+/** Auto-mode KEEP/NEW verdict via a bool classifier. Returns null when the
+ *  classifier is unusable — the caller falls back to the verdict request. */
+export async function classifyKeep(
+	ctx: ExtensionContext,
+	classifier: ClassifierLike,
+	currentName: string,
+	messages: readonly string[],
+): Promise<boolean | null> {
+	try {
+		const result = await ctx.modelRegistry.classify(classifier, {
+			state: { currentTitle: currentName },
+			questions: {
+				keep: {
+					type: "bool",
+					instructions:
+						`Decide whether the session title still matches the conversation. Current title: "${currentName}". ` +
+						"It is KEEP (true) only if the title still accurately describes the conversation's current main task.\n\n" +
+						frameTitleMessages(messages),
+					criteria: {
+						true: "The title still accurately describes the conversation's current main task",
+						false: "The title is inaccurate or outdated for the conversation's current main task",
+					},
+				},
+			},
+		});
+		if (result.stopReason !== "stop") return null;
+		const answer = result.answers.keep;
+		if (answer?.type !== "bool") return null;
+		return answer.probability >= 0.5;
+	} catch {
+		return null; // caller falls back to the verdict request
+	}
+}
+
 // ---------------------------------------------------------------------------
 // Pi extension entry point
 // ---------------------------------------------------------------------------
 
 export default function (pi: ExtensionAPI): void {
-	let manuallyLocked = false;
+	let manuallyLocked = false; // user pinned: /rename or an external session_info_changed
+	let inheritedTitle = false; // session_start found an existing title (resume)
 	let inFlight = false;
 	let lastAutoName: string | undefined;
 	let cfg: SessionNameConfig | null = null;
@@ -201,7 +421,8 @@ export default function (pi: ExtensionAPI): void {
 		inFlight = false;
 		lastAutoName = undefined;
 		cfg = null;
-		manuallyLocked = !!pi.getSessionName();
+		manuallyLocked = false;
+		inheritedTitle = !!pi.getSessionName();
 	});
 
 	pi.on("session_info_changed", (event) => {
@@ -212,24 +433,59 @@ export default function (pi: ExtensionAPI): void {
 	pi.on("agent_settled", async (_event, ctx) => {
 		if (cfg === null) cfg = loadConfig(ctx.cwd);
 		if (!cfg.enabled || manuallyLocked || inFlight) return;
+		// first/auto never touch a resumed session's inherited title (pi's API
+		// carries no title source, so any existing name is treated as pinned);
+		// follow treats it as the last revision and keeps tracking
+		// (deepseek-harness all-prompts cadence). /rename still pins either way.
+		if (inheritedTitle && cfg.mode !== "follow") return;
+		inheritedTitle = false;
 
 		const currentName = pi.getSessionName();
 		if (cfg.mode === "first" && (lastAutoName !== undefined || currentName)) return;
 
 		inFlight = true;
 		try {
-			const auth = await resolveModelAndAuth(ctx, cfg);
-			if (!auth) return;
-
-			const text = buildConversationText(ctx.sessionManager.getBranch());
-			if (!text.trim()) return;
+			// Title generation always uses the current session model; auto mode's
+			// KEEP/NEW verdict still prefers a classifier model when present.
+			const model = ctx.model ?? null;
+			if (!model) return;
+
+			const messages = buildTitleMessages(ctx.sessionManager.getBranch());
+			if (messages.length === 0) return;
+			const first = messages[0]!;
+
+			// Generated text, then normalize; on ANY failure — provider error, abort,
+			// timeout, empty or malformed output — the deterministic first-message
+			// fallback (deepseek-harness discipline) still names the session instead
+			// of leaving it untitled.
+			const attempt = async (request: TitleRequest): Promise<string> => {
+				try {
+					return await generateTitle(request, model, ctx, ctx.signal);
+				} catch {
+					return "";
+			}
+			};
+			const finalize = (generated: string): string | null =>
+				normalizeSessionTitle(generated, cfg!.maxLength) ?? fallbackSessionTitle(first, 8, cfg!.maxLength);
 
 			let title: string | null;
 			if (cfg.mode === "first" || !currentName) {
-				title = cleanTitle(await generateTitle(buildFirstPrompt(text, cfg), auth, complete, ctx.signal), cfg.maxLength);
+				title = finalize(await attempt(buildTitleRequest("first", messages, cfg.prompt)));
+			} else if (cfg.mode === "follow") {
+				title = finalize(await attempt(buildTitleRequest("all", messages, cfg.prompt)));
 			} else {
-				const verdict = await generateTitle(buildAutoPrompt(currentName, text, cfg), auth, complete, ctx.signal);
-				title = /^keep$/i.test(verdict.trim()) ? null : cleanTitle(verdict, cfg.maxLength);
+				// auto: classifier KEEP/NEW when available; otherwise the single
+				// complete() verdict (KEEP text or a new title).
+				const classifier = await resolveClassifierModel(ctx);
+				const keep = classifier ? await classifyKeep(ctx, classifier, currentName, messages) : null;
+				if (keep === true) {
+					return; // title still matches — no generation call
+				} else if (keep === false) {
+					title = finalize(await attempt(buildTitleRequest("all", messages, cfg.prompt)));
+				} else {
+					const verdict = await attempt(buildVerdictRequest(currentName, messages, cfg.prompt));
+					title = /^keep$/i.test(verdict.trim()) ? null : finalize(verdict);
+				}
 			}
 			if (!title) return;
 
@@ -237,10 +493,12 @@ export default function (pi: ExtensionAPI): void {
 			// may have fired while generateTitle was in flight.
 			if (manuallyLocked || pi.getSessionName() !== currentName) return;
 
-			lastAutoName = title;
-			pi.setSessionName(title);
+			const named = withCreationTime(title, safeSessionFile(ctx), cfg.appendCreationTime);
+			lastAutoName = named;
+			pi.setSessionName(named);
 		} catch {
-			// silent: failure does not block the session; first mode retries next round, auto mode skips this round
+			// silent: failure does not block the session; the fallback above
+			// already covered naming, so simply skip this round
 		} finally {
 			inFlight = false;
 		}
@@ -255,40 +513,54 @@ export default function (pi: ExtensionAPI): void {
 			const name = args.trim();
 
 			if (name) {
-				const cleaned = cleanTitle(name, cfg.maxLength);
+				const cleaned = normalizeSessionTitle(name, cfg.maxLength);
 				if (!cleaned) {
 					ctx.ui.notify("Invalid name", "warning");
 					return;
 				}
-				lastAutoName = cleaned;
-				pi.setSessionName(cleaned);
+				const named = withCreationTime(cleaned, safeSessionFile(ctx), cfg.appendCreationTime);
+				lastAutoName = named;
+				pi.setSessionName(named);
 				ctx.ui.notify(`Renamed to: ${cleaned}`, "info");
 				return;
 			}
 
 			// no argument → generate a name from the conversation
-			const auth = await resolveModelAndAuth(ctx, cfg);
-			if (!auth) {
-				ctx.ui.notify("Cannot generate a name: model unavailable or no API key", "warning");
+			const model = ctx.model ?? null;
+			if (!model) {
+				ctx.ui.notify("Cannot generate a name: model unavailable", "warning");
 				return;
 			}
-			const text = buildConversationText(ctx.sessionManager.getBranch());
-			if (!text.trim()) {
+			const messages = buildTitleMessages(ctx.sessionManager.getBranch());
+			if (messages.length === 0) {
 				ctx.ui.notify("No conversation to generate a name from yet", "warning");
 				return;
 			}
+			const request = buildTitleRequest("first", messages, cfg.prompt);
+			let generated = "";
 			try {
-				const title = cleanTitle(await generateTitle(buildFirstPrompt(text, cfg), auth, complete, ctx.signal), cfg.maxLength);
-				if (!title) {
-					ctx.ui.notify("Could not generate a name from the model response", "warning");
-					return;
-				}
-				lastAutoName = title;
-				pi.setSessionName(title);
-				ctx.ui.notify(`Renamed to: ${title}`, "info");
+				generated = await generateTitle(request, model, ctx, ctx.signal);
 			} catch {
-				ctx.ui.notify("Failed to generate a name", "error");
+				// deterministic fallback below still names the session
+			}
+			const title = normalizeSessionTitle(generated, cfg.maxLength) ?? fallbackSessionTitle(messages[0]!, 8, cfg.maxLength);
+			if (!title) {
+				ctx.ui.notify("Could not generate a name from the model response", "warning");
+				return;
 			}
+			const named = withCreationTime(title, safeSessionFile(ctx), cfg.appendCreationTime);
+			lastAutoName = named;
+			pi.setSessionName(named);
+			ctx.ui.notify(`Renamed to: ${named}`, "info");
 		},
 	});
 }
+
+/** Best-effort session file path (mock hosts may not implement it). */
+function safeSessionFile(ctx: ExtensionContext): string | undefined {
+	try {
+		return ctx.sessionManager.getSessionFile();
+	} catch {
+		return undefined;
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@fyeeme/pi-session-name",
-	"version": "1.0.3",
+	"version": "1.0.5",
 	"description": "Auto-name pi sessions with a short LLM-generated title so --resume lists are easy to scan. Supports first (once) and auto (content-aware rename) modes; never overwrites manual names.",
 	"type": "module",
 	"license": "MIT",
@@ -43,12 +43,12 @@
 		"typecheck": "tsc"
 	},
 	"peerDependencies": {
-		"@earendil-works/pi-coding-agent": ">=0.84.1",
-		"@earendil-works/pi-ai": ">=0.84.1"
+		"@earendil-works/pi-coding-agent": ">=0.99.0",
+		"@earendil-works/pi-ai": ">=0.99.0"
 	},
 	"devDependencies": {
-		"@earendil-works/pi-coding-agent": "0.84.1",
-		"@earendil-works/pi-ai": "0.84.1",
+		"@earendil-works/pi-coding-agent": "0.99.2",
+		"@earendil-works/pi-ai": "0.99.2",
 		"@types/node": "22.19.19",
 		"typescript": "5.9.3",
 		"vitest": "3.2.7"