@fyeeme/pi-session-name 1.0.4 → 1.0.6

package/CHANGELOG.md

@@ -7,6 +7,35 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.6] - 2026-10-02
+
+### Changed
+
+- Dev toolchain pinned to `@earendil-works/pi-coding-agent`/`pi-ai` 1.0.0 (peer floors unchanged, `>=0.99.0`); typecheck and tests pass against 1.0.0 unchanged.
+
+## [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

package/README.md

@@ -7,18 +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
 - **Distinctive titles** — leads with the concrete entity/error/identifier, so similar sessions don't blur together (~15-40 chars)
-- **Conflict-aware** — reads recent sibling session titles from local session storage and injects them into the prompt, so a new title never duplicates or rewords one already in the list
-- **Graceful failure** — model unavailable or no API key? Stays silent, never blocks the session
+- **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
 
@@ -65,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
 {
@@ -79,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
 
@@ -94,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
 
@@ -124,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
 ```
 
@@ -134,14 +153,13 @@ This extension exposes utilities that other extensions can import:
 
 ```typescript
 import {
-	buildConversationText,
-	cleanTitle,
-	buildFirstPrompt,
-	buildAutoPrompt,
+	buildTitleMessages,
+	normalizeSessionTitle,
+	fallbackSessionTitle,
+	buildTitleRequest,
+	buildVerdictRequest,
 	loadConfig,
 	generateTitle,
-	parseSessionTitle,
-	collectRecentSessionTitles,
 } from "@fyeeme/pi-session-name";
 ```
 

package/index.ts

@@ -1,14 +1,94 @@
-import { readFileSync, readdirSync } from "node:fs";
+import { readFileSync } from "node:fs";
 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,274 +97,254 @@ 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`);
 
-export function buildConversationText(
+/** Default input policy: window + per-message cap + total UTF-8 budget. */
+export const TITLE_INPUT_DEFAULTS = { maxMessages: 8, maxCharsPerMessage: 600, maxInputBytes: 16384 } as const;
+
+/**
+ * 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");
 }
 
-// ---------------------------------------------------------------------------
-// Sibling titles — scan local session files for other sessions' names, so the
-// prompt can steer the model away from titles already in use (distinctiveness
-// is a property of the list, so the model must see the list).
-// ---------------------------------------------------------------------------
-
-/** Extract a session file's display name: the latest `session_info` entry; an empty name clears it. */
-export function parseSessionTitle(content: string): string | undefined {
-	const lines = content.split("\n");
-	for (let i = lines.length - 1; i >= 0; i--) {
-		const line = lines[i]!.trim();
-		if (!line) continue;
-		try {
-			const d = JSON.parse(line) as { type?: string; name?: string };
-			if (d.type === "session_info") return d.name?.trim() || undefined;
-		} catch {
-			// skip malformed lines
-		}
-	}
-	return undefined;
+/** 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)}`;
 }
 
-const TITLE_CACHE_TTL_MS = 60_000;
-const titleCache = new Map<string, { fetchedAt: number; entries: Array<{ file: string; name: string }> }>();
+/** 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;
+}
 
 /**
- * Recent sibling session titles from `sessionsDir` (newest first).
- * Excludes the current session's file and `excludeNames` (e.g. the current title,
- * so a rename is not compared against itself). Best effort: any error → [].
+ * 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 collectRecentSessionTitles(
-	sessionsDir: string,
-	opts: { currentSessionFile?: string; excludeNames?: string[]; maxTitles?: number; maxFiles?: number } = {},
-): string[] {
-	const maxTitles = opts.maxTitles ?? 20;
-	const maxFiles = opts.maxFiles ?? 50;
-
-	let scanned: Array<{ file: string; name: string }>;
-	const cached = titleCache.get(sessionsDir);
-	if (cached && Date.now() - cached.fetchedAt < TITLE_CACHE_TTL_MS) {
-		scanned = cached.entries;
-	} else {
-		scanned = [];
-		try {
-			const files = readdirSync(sessionsDir)
-				.filter((f) => f.endsWith(".jsonl"))
-				.sort()
-				.reverse()
-				.slice(0, maxFiles);
-			for (const fname of files) {
-				try {
-					const name = parseSessionTitle(readFileSync(join(sessionsDir, fname), "utf8"));
-					if (name) scanned.push({ file: fname, name });
-				} catch {
-					// unreadable file — skip
-				}
-			}
-		} catch {
-			// missing/unreadable dir — empty
-		}
-		titleCache.set(sessionsDir, { fetchedAt: Date.now(), entries: scanned });
-	}
+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] };
+}
 
-	const exclude = new Set((opts.excludeNames ?? []).map((n) => n.trim()).filter((n) => n.length > 0));
-	const currentBase = opts.currentSessionFile ? basename(opts.currentSessionFile) : undefined;
-	const seen = new Set<string>();
-	const out: string[] = [];
-	for (const { file, name } of scanned) {
-		if (currentBase && file === currentBase) continue;
-		if (exclude.has(name) || seen.has(name)) continue;
-		seen.add(name);
-		out.push(name);
-		if (out.length >= maxTitles) break;
-	}
-	return out;
+/** 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}`,
+		"If the title is still accurate, reply with exactly: KEEP",
+		"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] };
 }
 
 // ---------------------------------------------------------------------------
-// Prompt builders — first-title & auto-rename prompts
+// 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>".
 // ---------------------------------------------------------------------------
 
-export function buildFirstPrompt(
-	conversationText: string,
-	opts: { maxLength?: number; recentTitles?: string[] } = {},
-): string {
-	const maxLength = opts.maxLength ?? 200;
-	const lines: string[] = [
-		"You generate a title so the user can recognize this conversation at a glance in a session list.",
-		"Rules:",
-		'- Output ONLY the title text. No quotes, no parentheses, no trailing punctuation, no explanation.',
-		"- Use the SAME language as the user's first message.",
-		'- 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. Action verbs (debug, analyze, fix) carry little identifying weight.",
-		`- Keep it clear and readable. Prefer capturing the key point over staying short: when the conversation found a root cause or conclusion, include it (specific field, config, or error). Aim for roughly 15-40 characters; never exceed ${maxLength} characters.`,
-	];
-	appendRecentTitles(lines, opts.recentTitles);
-	lines.push("", "<conversation>", conversationText, "</conversation>");
-	return lines.join("\n");
+/** 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;
 }
 
-export function buildAutoPrompt(
-	currentName: string,
-	conversationText: string,
-	opts: { maxLength?: number; recentTitles?: string[] } = {},
-): string {
-	const maxLength = opts.maxLength ?? 200;
-	const hasRecent = (opts.recentTitles ?? []).some((t) => t.trim().length > 0);
-	const lines: string[] = [
-		"You decide whether the session title still matches the conversation.",
-		`- Current title: ${currentName}`,
-		"If the title is still accurate, reply with exactly: KEEP",
-		hasRecent
-			? "If it is inaccurate, outdated, or hard to tell apart from other sessions (check it against <recent_session_titles> below), output a NEW title."
-			: "If it is inaccurate, outdated, or hard to tell apart from other sessions, output a NEW title.",
-		"Rules for a new title:",
-		'- ONLY the title text. No quotes, no parentheses, no trailing punctuation, no explanation.',
-		"- Use the SAME language as the user's first message.",
-		'- 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 of the current main task: 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.",
-		`- Keep it clear and readable. Prefer capturing the key point over staying short: when the conversation found a root cause or conclusion, include it (specific field, config, or error). Aim for roughly 30-55 characters; never exceed ${maxLength} characters.`,
-	];
-	appendRecentTitles(lines, opts.recentTitles);
-	lines.push("", "<conversation>", conversationText, "</conversation>");
-	return lines.join("\n");
+/** 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())}`;
 }
 
-const appendRecentTitles = (lines: string[], recentTitles?: string[]): void => {
-	const recent = (recentTitles ?? []).map((t) => t.trim()).filter((t) => t.length > 0);
-	if (recent.length === 0) return;
-	lines.push(
-		"- The <recent_session_titles> list below shows titles already used by other sessions of this project. Your title must be clearly distinguishable from every one of them (different subject, ID, or error) — never a rewording of one. When a listed title already covers the same subject, shift the focus to what THIS session newly found or changed.",
-		"",
-		"<recent_session_titles>",
-		...recent.map((t) => `- ${t}`),
-		"</recent_session_titles>",
-	);
-};
+/** 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}`;
+}
 
 // ---------------------------------------------------------------------------
 // SessionNameConfig + loadConfig
 // ---------------------------------------------------------------------------
 
 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 };
-
-/** Registry headers are ProviderHeaders (values may be null); our auth contract is Record<string, string>. */
-export function dropNullHeaders(
-	headers?: Record<string, string | null>,
-	): Record<string, string> | undefined {
-	if (!headers) return undefined;
-	const out: Record<string, string> = {};
-	for (const [k, v] of Object.entries(headers)) {
-		if (typeof v === "string") out[k] = v;
+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 out;
-}
-
-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;
-	// registry headers are ProviderHeaders (values may be null); our auth contract is Record<string, string>.
-	return { model, apiKey: auth.apiKey, headers: dropNullHeaders(auth.headers) };
+	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)
@@ -293,22 +353,66 @@ export async function generateTitle(
 }
 
 // ---------------------------------------------------------------------------
-// Pi extension entry point
+// Classifier path — auto mode's KEEP/NEW verdict as a bool classify
 // ---------------------------------------------------------------------------
 
-const siblingTitles = (ctx: ExtensionContext, excludeNames: string[]): string[] => {
+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 {
-		return collectRecentSessionTitles(ctx.sessionManager.getSessionDir(), {
-			currentSessionFile: ctx.sessionManager.getSessionFile(),
-			excludeNames,
+		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 [];
+		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;
@@ -317,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) => {
@@ -328,26 +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) {
-				const prompt = buildFirstPrompt(text, { maxLength: cfg.maxLength, recentTitles: siblingTitles(ctx, currentName ? [currentName] : []) });
-				title = cleanTitle(await generateTitle(prompt, 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 prompt = buildAutoPrompt(currentName, text, { maxLength: cfg.maxLength, recentTitles: siblingTitles(ctx, currentName ? [currentName] : []) });
-				const verdict = await generateTitle(prompt, 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;
 
@@ -355,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;
 		}
@@ -373,42 +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 current = pi.getSessionName();
-				const prompt = buildFirstPrompt(text, { maxLength: cfg.maxLength, recentTitles: siblingTitles(ctx, current ? [current] : []) });
-				const title = cleanTitle(await generateTitle(prompt, 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.4",
+	"version": "1.0.6",
 	"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": "1.0.0",
+		"@earendil-works/pi-ai": "1.0.0",
 		"@types/node": "22.19.19",
 		"typescript": "5.9.3",
 		"vitest": "3.2.7"