@timqi/pier 0.0.29 → 0.1.0

package/dist/agent/config.js

@@ -20,6 +20,21 @@ const RESOURCE_DEPTH = 3; // extensions/skills nest at most a couple of levels
 export const defaultAgentDir = () => process.env.PI_CODING_AGENT_DIR ?? pierPath("pi");
 /** Stable mask: mapped back by field, without exposing key fragments. */
 const maskKey = (_key) => "••••••••";
+/** Pi reads the two highest levels off the model's own map, so a ceiling is
+ *  read back from it and written into it — leaving the rest of a hand-written
+ *  map (an `off: null` that forbids thinking-off) alone, because the Console
+ *  does not offer it and therefore may not drop it. */
+const effortOf = (map) => typeof map?.max === "string" ? "max" : typeof map?.xhigh === "string" ? "xhigh" : undefined;
+function withEffort(map, effort) {
+    const next = { ...map };
+    delete next.xhigh;
+    delete next.max;
+    if (effort === "xhigh" || effort === "max")
+        next.xhigh = "xhigh";
+    if (effort === "max")
+        next.max = "max";
+    return Object.keys(next).length ? next : undefined;
+}
 const missing = (err) => err instanceof Error && "code" in err && err.code === "ENOENT";
 const readNullable = async (path) => {
     try {
@@ -131,9 +146,11 @@ export class PiConfigStore {
                     if (typeof model !== "object" || model === null || typeof model.id !== "string") {
                         return [];
                     }
+                    const effort = effortOf(asRecord(model.thinkingLevelMap));
                     return [{
                             id: model.id,
                             reasoning: model.reasoning === true,
+                            ...(effort ? { effort } : {}),
                         }];
                 })
                 : undefined;
@@ -180,6 +197,11 @@ export class PiConfigStore {
                         next.reasoning = true;
                     else
                         delete next.reasoning;
+                    const map = withEffort(asRecord(next.thinkingLevelMap), model.effort);
+                    if (map)
+                        next.thinkingLevelMap = map;
+                    else
+                        delete next.thinkingLevelMap;
                     return next;
                 });
             }

package/dist/agent/events.js

@@ -3,7 +3,10 @@
 // and Pi types never leak past the seam. The golden-table test in
 // events.test.ts is the mapping's spec; extend types.ts before adding events.
 import { isThinkingLevel, MAX_STEP_OUTPUT } from "../core/types.js";
-const hasToolCalls = (message) => Array.isArray(message?.content) && message.content.some((part) => part.type === "toolCall");
+/** An assistant message that calls a tool is work in progress, not a reply —
+ *  the rule `toChatTurns` rebuilds a transcript by, and agent/listing.ts
+ *  indexes one by. */
+export const hasToolCalls = (message) => Array.isArray(message?.content) && message.content.some((part) => part.type === "toolCall");
 export function textOf(content) {
     if (typeof content === "string")
         return content;

package/dist/agent/listing.js

@@ -11,6 +11,10 @@
 // path and validated by (size, mtime), and a file that grew is picked up at the
 // byte the last scan stopped on.
 //
+// The same pass indexes what was said. Every user message and every reply
+// goes into `session_fts` beside the index row, in the same transaction, so
+// the palette can search messages without a second reader of the same bytes.
+//
 // Reading Pi's on-disk entries is the cost of that; agent/ is where the
 // knowledge of Pi's formats already lives, and Pi's own reader is not
 // incremental.
@@ -20,7 +24,7 @@ import { pierDb, statements, transact } from "../db.js";
 import { SESSION_TITLE_MAX } from "../limits.js";
 import { logger } from "../log.js";
 import { defaultAgentDir } from "./config.js";
-import { textOf } from "./events.js";
+import { hasToolCalls, textOf } from "./events.js";
 const log = logger("agent");
 /** How many of the newest sessions a cross-check reads: enough that a format
  *  change surfaces within a boot or two, few enough to cost nothing. */
@@ -30,17 +34,35 @@ const AUDIT_SAMPLE = 5;
  *  differently and an object would silently accept either. */
 const titleOf = (name, first) => name || first || undefined;
 const str = (v) => (typeof v === "string" ? v : undefined);
+/** What a search may find: what the person said and what the agent answered.
+ *  A reply that calls a tool is work in progress, not a reply (events.ts
+ *  `toChatTurns`) — its text is a step, and steps are not indexed; neither is
+ *  thinking, a tool result, or a system input. `clean` takes off what was
+ *  written for the model rather than said — the speaker header a channel
+ *  prefixes (core/identity.ts), which as text would make "operator" hit every
+ *  session the workbench ever opened. */
+function saidIn(message, entryAt, clean) {
+    if (message?.role !== "user" && message?.role !== "assistant")
+        return undefined;
+    if (message.role === "assistant" && hasToolCalls(message))
+        return undefined;
+    const text = clean(textOf(message.content)).trim();
+    if (!text)
+        return undefined;
+    const at = typeof message.timestamp === "number" ? message.timestamp : Date.parse(entryAt ?? "");
+    return { role: message.role, at: Number.isFinite(at) ? at : 0, text };
+}
 /**
  * One entry folded into what a listing needs. Three answers, not two:
  * `undefined` is "no header yet" (blank and unparseable lines before it are
  * skipped, as Pi's own reader does), `null` is "not a session file" — a first
  * entry that is not a session header — and anything else is the state so far.
  */
-function fold(acc, line) {
-    // The bulk of a transcript is message entries, each longer than this file.
-    // Once the first user message is in hand only a rename still matters, and a
-    // substring test costs a fraction of parsing one of them.
-    if (acc?.first && !line.includes('"session_info"'))
+function fold(acc, line, clean) {
+    // The bulk of a transcript is entries this has no use for — tool results,
+    // model changes, compaction — each longer than this file. Two substring tests
+    // say whether a line could matter, at a fraction of parsing one that does not.
+    if (acc && !line.includes('"message"') && !line.includes('"session_info"'))
         return acc;
     let entry;
     try {
@@ -58,26 +80,55 @@ function fold(acc, line) {
         const timestamp = str(entry.timestamp);
         if (entry.type !== "session" || !id || !timestamp)
             return null;
-        return { id, cwd: str(entry.cwd) ?? "", created: Date.parse(timestamp), at: 0 };
+        return { id, cwd: str(entry.cwd) ?? "", created: Date.parse(timestamp), said: [], at: 0 };
     }
     if (entry?.type === "session_info")
         return { ...acc, name: str(entry.name)?.trim() || undefined };
-    if (entry?.type === "message" && !acc.first) {
+    if (entry?.type === "message") {
         const message = entry.message;
-        if (message?.role !== "user")
+        const said = saidIn(message, str(entry.timestamp), clean);
+        if (!said)
+            return acc;
+        acc.said.push(said);
+        // The title keeps the header the index drops: every surface reads it back
+        // through core/identity.ts, and a second rule here would be a second rule.
+        if (acc.first || said.role !== "user")
             return acc;
-        const text = textOf(message.content).trim();
-        return text ? { ...acc, first: text.slice(0, SESSION_TITLE_MAX) } : acc;
+        return { ...acc, first: textOf(message?.content).trim().slice(0, SESSION_TITLE_MAX) };
     }
     return acc;
 }
+/** Hits a search answers with at most: a picker, not a results page. */
+const SEARCH_LIMIT = 8;
+/** Characters a snippet runs to. A trigram token is one character, so FTS's
+ *  `snippet()` is asked for its ceiling of 64 tokens — the default 12 fits one
+ *  word and its neighbours — and the LIKE path centres the same span itself. */
+const SNIPPET_CHARS = 64;
+/** The match and its neighbourhood, delimited like `snippet()` does it
+ *  (\u0001 … \u0002, `…` for a cut), so a surface draws one shape for both
+ *  paths. Case folds ASCII only — LIKE found the row by the same rule. */
+function around(text, query) {
+    const hit = text.toLowerCase().indexOf(query.toLowerCase());
+    if (hit < 0)
+        return text.slice(0, SNIPPET_CHARS);
+    const start = Math.max(0, hit - SNIPPET_CHARS / 2);
+    const end = Math.min(text.length, hit + query.length + SNIPPET_CHARS / 2);
+    return `${start ? "…" : ""}${text.slice(start, hit)}\u0001${text.slice(hit, hit + query.length)}\u0002${text.slice(hit + query.length, end)}${end < text.length ? "…" : ""}`;
+}
 /** The listing Pier runs on: Pi's session directory, remembered in pier.db. */
 export class IndexedListing {
     dir;
+    clean;
     #db;
     #statements;
-    constructor(dir = join(defaultAgentDir(), "sessions"), db) {
+    constructor(dir = join(defaultAgentDir(), "sessions"), db, 
+    /** What to take off a message before it is indexed as said. Handed in
+     *  rather than imported: the header rule is core's (identity.ts), and
+     *  agent/ does not import core at runtime — main.ts, which imports both,
+     *  joins them. */
+    clean = (text) => text) {
         this.dir = dir;
+        this.clean = clean;
         this.#db = db;
     }
     /** Opened on the first scan rather than in the constructor: building an
@@ -114,13 +165,15 @@ export class IndexedListing {
             // length with a different mtime, which resuming would answer with the
             // old derived data stamped with the new mtime: a row that then matches on
             // every later scan and is never corrected.
-            const parsed = await this.#read(file.path, row && file.size > row.size
+            const resumed = row !== undefined && file.size > row.size;
+            const parsed = await this.#read(file.path, resumed
                 ? {
                     id: row.id,
                     cwd: row.cwd,
                     created: row.created_at,
                     ...(row.name === null ? {} : { name: row.name }),
                     ...(row.first_message === null ? {} : { first: row.first_message }),
+                    said: [],
                     at: row.parsed_bytes,
                 }
                 : undefined);
@@ -136,6 +189,8 @@ export class IndexedListing {
                 size: file.size,
                 mtime: file.modified,
                 parsed_bytes: parsed.at,
+                said: parsed.said,
+                whole: !resumed,
             });
             const title = titleOf(parsed.name, parsed.first);
             records.push({
@@ -181,6 +236,39 @@ export class IndexedListing {
         this.#save([], stale);
         return stale.length;
     }
+    /**
+     * Sessions by what was said in them, best hit first and one per session.
+     * Three characters or more is a trigram phrase, ranked by FTS; shorter is a
+     * substring scan, newest first — the tokenizer has nothing to match under
+     * three, and a two-character query is what a CJK word often is. Counted in
+     * code points: the tokenizer counts characters, not UTF-16 units.
+     */
+    search(query, limit = SEARCH_LIMIT) {
+        const sql = this.#sql();
+        const rows = [...query].length >= 3
+            // A quoted phrase: the query is a string to find, never FTS syntax.
+            ? sql(`SELECT session_id, role, at, snippet(session_fts, 0, char(1), char(2), '…', ${SNIPPET_CHARS}) AS snippet
+         FROM session_fts WHERE text MATCH ? ORDER BY bm25(session_fts), at DESC`).iterate(`"${query.replaceAll('"', '""')}"`)
+            : sql(`SELECT session_id, role, at, text FROM session_fts WHERE text LIKE ? ESCAPE '\\' ORDER BY at DESC`).iterate(`%${query.replaceAll(/[\\%_]/g, "\\$&")}%`);
+        const hits = [];
+        const seen = new Set();
+        // Walked, not fetched: a chatty session has hundreds of rows for one hit,
+        // and the walk stops at the first row of the `limit`th session.
+        for (const row of rows) {
+            if (seen.has(row.session_id))
+                continue;
+            seen.add(row.session_id);
+            hits.push({
+                sessionId: row.session_id,
+                role: row.role,
+                at: row.at,
+                snippet: row.snippet ?? around(row.text ?? "", query),
+            });
+            if (hits.length >= limit)
+                break;
+        }
+        return hits;
+    }
     /** Every session file with its size and mtime — the only syscalls a scan
      *  where nothing changed makes. */
     async #files() {
@@ -211,7 +299,7 @@ export class IndexedListing {
                     const line = buffer.slice(0, nl);
                     buffer = buffer.slice(nl + 1);
                     at += Buffer.byteLength(line) + 1;
-                    const next = fold(acc, line);
+                    const next = fold(acc, line, this.clean);
                     if (next === null)
                         return null;
                     acc = next;
@@ -227,12 +315,16 @@ export class IndexedListing {
         return acc ? { ...acc, at } : null;
     }
     /** One transaction, after all reading: a half-written index would hand the
-     *  next scan a size it never parsed to. */
+     *  next scan a size it never parsed to — or a search rows the index row does
+     *  not account for. A file read whole drops what it had said before, since
+     *  its bytes are all being said again; a resumed read only adds. */
     #save(rows, gone) {
         if (!rows.length && !gone.length)
             return;
         const db = this.#store();
         const sql = this.#sql();
+        const forget = sql("DELETE FROM session_fts WHERE path = ?");
+        const say = sql("INSERT INTO session_fts(text, session_id, path, role, at) VALUES (?, ?, ?, ?, ?)");
         const upsert = sql(`INSERT INTO session_index(path, id, cwd, created_at, name, first_message, size, mtime, parsed_bytes)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(path) DO UPDATE SET
@@ -243,10 +335,16 @@ export class IndexedListing {
         const drop = sql("DELETE FROM session_index WHERE path = ?");
         transact(db, () => {
             for (const r of rows) {
+                if (r.whole)
+                    forget.run(r.path);
+                for (const s of r.said)
+                    say.run(s.text, r.id, r.path, s.role, s.at);
                 upsert.run(r.path, r.id, r.cwd, r.created_at, r.name, r.first_message, r.size, r.mtime, r.parsed_bytes);
             }
-            for (const path of gone)
+            for (const path of gone) {
                 drop.run(path);
+                forget.run(path);
+            }
         });
     }
 }

package/dist/agent/pi.js

@@ -1,20 +1,61 @@
 // The only file outside src/extensions allowed to import @earendil-works/pi-*.
 // Implements the AgentFactory/AgentSession seam from src/core/types.ts on the
 // Pi SDK. No Pi type may appear in an exported signature.
+import { realpathSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
 import { createAgentSession, CredentialSynchronizationError, DefaultResourceLoader, defineTool, ModelRuntime, SessionManager, } from "@earendil-works/pi-coding-agent";
 import { inlineExtensions } from "../extensions/index.js";
+import { SESSION_TITLE_MAX } from "../limits.js";
 import { logger } from "../log.js";
-import { toChatTurns, toSessionEvents, turnMetaAt, } from "./events.js";
+import { textOf, toChatTurns, toSessionEvents, turnMetaAt, } from "./events.js";
 import { defaultAgentDir, PiConfigStore } from "./config.js";
 import { IndexedListing } from "./listing.js";
 import { curateModels, pinFirst } from "./models.js";
 const log = logger("agent");
+/** A directory is what a session is compared by — the rail groups on it, the
+ *  New-session menu drops a `<repo>.<branch>` worktree when the repository
+ *  itself is in the list — so two names for one directory are two projects. A
+ *  session opened under `/home/qiqi` (a symlink to `/essd/qiqi`) never matched
+ *  the worktrees recorded under the real path, and every branch checkout was
+ *  offered as a project of its own. Resolved once per distinct path: a symlink
+ *  that moves under a running instance is not a case we have.
+ *
+ *  A directory that is gone — a worktree merged and removed — is still a
+ *  session's cwd, and its spelling still decides whether the rail reads it as a
+ *  branch of its repository. So the deepest ancestor that does resolve carries
+ *  the rest of the path, and only a cwd with no resolvable ancestor at all is
+ *  reported as recorded. */
+const realPaths = new Map();
+function realPath(cwd) {
+    const known = realPaths.get(cwd);
+    if (known !== undefined)
+        return known;
+    let real = cwd;
+    const missing = [];
+    for (let head = cwd;;) {
+        try {
+            real = join(realpathSync(head), ...missing);
+            break;
+        }
+        catch (err) {
+            const parent = dirname(head);
+            if (parent === head) {
+                log.debug(`cwd ${cwd} has no resolvable ancestor; using it as recorded`, err);
+                break;
+            }
+            missing.unshift(basename(head));
+            head = parent;
+        }
+    }
+    realPaths.set(cwd, real);
+    return real;
+}
 /** A listed record as the seam reports it. The one mapping, because `list` and
  *  `find` answer with the same shape and drifting would mean two answers about
  *  one session. */
 const summaryOf = (s) => ({
     id: s.id,
-    cwd: s.cwd,
+    cwd: realPath(s.cwd),
     createdAt: s.created,
     modified: s.modified,
     ...(s.title ? { title: s.title } : {}),
@@ -36,6 +77,36 @@ const PROVIDER_CHECK_TIMEOUT_MS = 20_000;
 const PROVIDER_CHECK_MAX_TOKENS = 8192;
 /** Neither half of a probe is worth more than a screen. */
 const clip = (text) => text.length > 4000 ? `${text.slice(0, 4000)}\n[… ${text.length - 4000} more characters]` : text;
+/** Naming a session: one bare request on the operator's title model, after the
+ *  first exchange. Each half of the exchange is cut to a few hundred
+ *  characters — a title is about the subject, and the subject is in the
+ *  opening lines — and the answer is a line, so the cap is a line's worth. */
+const TITLE_INPUT_CHARS = 600;
+const TITLE_MAX_TOKENS = 40;
+const TITLE_TIMEOUT_MS = 20_000;
+const TITLE_PROMPT = "Name this conversation for a session list. Reply with the title only: at most 12 Chinese characters " +
+    "or 6 English words, in the language the user wrote in, no quotes, no trailing period. " +
+    "A leading `[name<id> time]` on the user's message is a speaker header, not content.";
+/** A subject, not the request: the model is asked to title the exchange, and
+ *  the two halves are labelled so a reply that quotes an instruction back is
+ *  not mistaken for one. */
+const titleRequest = (first, reply) => `${TITLE_PROMPT}\n\n<user>\n${first.slice(0, TITLE_INPUT_CHARS)}\n</user>\n\n<assistant>\n${reply.slice(0, TITLE_INPUT_CHARS)}\n</assistant>`;
+/** The text of a bare completion, or the refusal it was: a provider can
+ *  decline as a message rather than a throw, and only the stop reason tells
+ *  that from an answer. */
+function textOfAnswer(answer) {
+    if (answer.stopReason === "error" || answer.stopReason === "aborted") {
+        throw new Error(answer.errorMessage ?? `the provider stopped: ${answer.stopReason}`);
+    }
+    return textOf(answer.content).trim();
+}
+/** What a model hands back as a title, made into one: the first line, quotes
+ *  off, capped where every other title is capped. Empty is a failure, not a
+ *  cleared name — the caller reports it. */
+export function titleFromAnswer(text) {
+    const line = text.trim().split("\n")[0]?.trim() ?? "";
+    return line.replace(/^["'“‘「]+|["'”’」.。]+$/g, "").trim().slice(0, SESSION_TITLE_MAX);
+}
 /** Pier's baseline replaces Pi's generic default; a user's SYSTEM.md follows it. */
 const PIER_SYSTEM_PROMPT = `You are a general-purpose agent with a live workspace: you can read and change files and run shell commands. Act with expert care — do the work and verify the result.
 
@@ -106,6 +177,7 @@ export class PiSession {
     pinned;
     wrote;
     retention;
+    suggestTitle;
     constructor(pi, 
     /** Operator pins, read per call — the menu can change while we run. */
     pinned = () => [], 
@@ -114,11 +186,16 @@ export class PiSession {
      *  every surface would re-read the old title and keep it until some
      *  unrelated event moved the list again. Same drop `create` does — a
      *  callback only because the session is what knows it happened. */
-    wrote = () => { }, retention = { value: "long" }) {
+    wrote = () => { }, retention = { value: "long" }, 
+    /** The operator's title model asked to name a first exchange, or nothing
+     *  when auto-titling is off. Read per turn: switching it on names the next
+     *  session that finishes a first turn, without a restart. */
+    suggestTitle = () => undefined) {
         this.pi = pi;
         this.pinned = pinned;
         this.wrote = wrote;
         this.retention = retention;
+        this.suggestTitle = suggestTitle;
     }
     /** Pi's dispose unhooks the one listener that persists and emits, so a turn
      *  started after it runs for real — model call, tools and all — and lands
@@ -342,9 +419,47 @@ export class PiSession {
             }
             for (const payload of toSessionEvents(piEvent)) {
                 fn(payload.type === "turn-end" ? { ...payload, meta: this.lastTurnMeta() } : payload);
+                if (payload.type === "turn-end" && !payload.error)
+                    this.autoTitle(payload.text, fn);
             }
         });
     }
+    /** Whether naming has been decided for this session — done, started, or
+     *  never: a session that already has a name (a task's, a rename during the
+     *  turn) or more than one exchange behind it keeps what it has. Several
+     *  subscribers see every turn-end; this is what makes the request one. */
+    titleDecided = false;
+    /** Name the session after its first exchange, on the operator's title model.
+     *  Off by default (settings.titleModel), in which case the title stays the
+     *  first prompt that agent/listing.ts derives. The result is a rename like
+     *  any other — an append the next listing reads — announced as `renamed` so
+     *  every surface re-lists; a failure is announced too, because a title that
+     *  silently stayed the prompt looks like the setting did nothing (§5b). */
+    autoTitle(reply, fn) {
+        if (this.titleDecided)
+            return;
+        const suggest = this.suggestTitle();
+        if (!suggest)
+            return; // off — not decided: switched on later, the next turn still counts
+        this.titleDecided = true;
+        if (this.pi.sessionManager.getSessionName())
+            return;
+        const users = this.pi.messages.filter((m) => m.role === "user");
+        const first = users.length === 1 ? textOf(users[0]?.content) : "";
+        if (!first.trim())
+            return;
+        void suggest(first, reply).then((title) => {
+            // Named while we waited — by a person, whose word beats the model's.
+            if (this.disposed || this.pi.sessionManager.getSessionName())
+                return;
+            this.pi.sessionManager.appendSessionInfo(title);
+            this.wrote();
+            fn({ type: "renamed", title });
+        }, (err) => {
+            log.warn(`session ${this.pi.sessionId} could not be titled`, err);
+            fn({ type: "error", message: `session title: ${err instanceof Error ? err.message : String(err)} — the first message stays the title` });
+        });
+    }
     /** Meta of the just-finished turn; live path, so "now" is the completion. */
     lastTurnMeta() {
         const messages = this.pi.messages;
@@ -367,6 +482,7 @@ export class PiAgentFactory {
     providerConfig;
     pinned;
     enabledExtensions;
+    titleModel;
     listings;
     constructor(extraTools = [], 
     /** Appended as a virtual context file, so Pi's own prompt stays intact.
@@ -388,6 +504,10 @@ export class PiAgentFactory {
     /** Which bundled extensions the Console has switched on. A getter for the
      * same reason again: the toggle takes effect on the next session open. */
     enabledExtensions = () => [], 
+    /** The model that names a session after its first exchange (Console →
+     * Settings → Models); unset means the first prompt stays the title. A
+     * getter, read per turn end. */
+    titleModel = () => undefined, 
     /** What exists on disk. Injected so a test can hand this factory a listing
      * instead of a session directory and a database. */
     listings = new IndexedListing()) {
@@ -398,6 +518,7 @@ export class PiAgentFactory {
         this.providerConfig = providerConfig;
         this.pinned = pinned;
         this.enabledExtensions = enabledExtensions;
+        this.titleModel = titleModel;
         this.listings = listings;
     }
     /** One runtime for the whole process; catalogs are global, not per session. */
@@ -516,17 +637,7 @@ export class PiAgentFactory {
             if (!model)
                 throw new Error(`unknown model: ${providerId}/${modelId}`);
             const answer = await runtime.completeSimple(model, { messages: [{ role: "user", content: "hi", timestamp: Date.now() }] }, { maxTokens: PROVIDER_CHECK_MAX_TOKENS, signal, fetch: recorded });
-            // A refusal can arrive as a message rather than a throw; the stop reason
-            // is the only thing separating it from an answer.
-            const refused = answer.stopReason === "error" || answer.stopReason === "aborted";
-            if (refused) {
-                throw new Error(answer.errorMessage ?? `the provider stopped: ${answer.stopReason}`);
-            }
-            const text = answer.content
-                .filter((part) => part.type === "text")
-                .map((part) => part.text)
-                .join("")
-                .trim();
+            const text = textOfAnswer(answer);
             // An empty answer is still an answer; say which kind of nothing it was.
             return answered(clip(text) || `(no text; stop reason: ${answer.stopReason})`, true);
         }
@@ -539,6 +650,24 @@ export class PiAgentFactory {
                 : raw || error, false);
         }
     }
+    /** One bare completion — no session, no tools, no history — on the title
+     *  model. Rejects on anything but a usable line: the session reports it. */
+    async suggestTitle(model, first, reply) {
+        const runtime = await this.refreshedRuntime();
+        const resolved = runtime.getModel(model.provider, model.id);
+        if (!resolved)
+            throw new Error(`title model ${model.provider}/${model.id} is not in the catalog`);
+        // The least reasoning the model does, said explicitly: unset means the
+        // provider's default, which on a reasoning model is not "none" (gpt-5:
+        // medium) and spends the whole output cap thinking about a title. Anthropic
+        // is the exception — its default is thinking off, and any level turns it on.
+        const reasoning = resolved.reasoning && resolved.api !== "anthropic-messages" ? "minimal" : undefined;
+        const answer = await runtime.completeSimple(resolved, { messages: [{ role: "user", content: titleRequest(first, reply), timestamp: Date.now() }] }, { maxTokens: TITLE_MAX_TOKENS, reasoning, signal: AbortSignal.timeout(TITLE_TIMEOUT_MS) });
+        const title = titleFromAnswer(textOfAnswer(answer));
+        if (!title)
+            throw new Error(`${model.provider}/${model.id} answered with no title`);
+        return title;
+    }
     async setup(input) {
         const builtins = await this.builtinIds();
         if (input.kind === "builtin" && !builtins.has(input.id)) {
@@ -700,7 +829,10 @@ export class PiAgentFactory {
         live.agent.followUpMode = "all";
         const session = new PiSession(live, this.pinned, () => {
             this.listing = undefined;
-        }, retention);
+        }, retention, () => {
+            const model = this.titleModel();
+            return model && ((first, reply) => this.suggestTitle(model, first, reply));
+        });
         if (opts.model)
             await session.setModel(opts.model);
         if (opts.thinking)
@@ -710,7 +842,10 @@ export class PiAgentFactory {
     }
     async create(opts) {
         this.listing = undefined;
-        return this.open(opts.cwd, SessionManager.create(opts.cwd), opts);
+        // Resolved before Pi records it, so the transcript, the session directory
+        // and every later listing all name the directory the same way.
+        const cwd = realPath(opts.cwd);
+        return this.open(cwd, SessionManager.create(cwd), { ...opts, cwd });
     }
     async resume(sessionId) {
         const known = this.located.get(sessionId);
@@ -778,4 +913,11 @@ export class PiAgentFactory {
     async list() {
         return (await this.listed()).map(summaryOf);
     }
+    /** After a listing, so a transcript that grew since the last one is indexed
+     *  before it is asked about; the listing owns the index. One that cannot
+     *  search — a test's — has nothing to say. */
+    async search(query) {
+        await this.listed();
+        return this.listings.search?.(query) ?? [];
+    }
 }

package/dist/channels/lark-panel.js

@@ -12,7 +12,7 @@ import { ChatPanel, CWD_PLACEHOLDER, CWD_TAIL, PANEL_PREFIX, } from "./panel.js"
 /** A form-submit button name: `cwdgo:<thread root>`. */
 export const CWD_SUBMIT_PREFIX = "cwdgo:";
 /** The form input's field name, the key `form_value` answers under. */
-export const CWD_FIELD = "cwd";
+const CWD_FIELD = "cwd";
 export class LarkPanel extends ChatPanel {
     deps;
     platform = "lark";

package/dist/core/inbox.js

@@ -12,7 +12,7 @@ import { basename, join } from "node:path";
 import { pierPath } from "../paths.js";
 import { fileMarker, lostMarker, MAX_INBOUND_BYTES, safeName } from "./inbound-file.js";
 /** Where every inbound file lives; the attachment route allowlists this root. */
-export const INBOX_DIR = pierPath("inbox");
+const INBOX_DIR = pierPath("inbox");
 /**
  * Write one inbound file and return its absolute path. The timestamp-random
  * prefix keeps concurrent saves collision-free (`wx` turns the impossible

package/dist/core/router.js

@@ -251,6 +251,10 @@ export class Router {
                     state: payload.state,
                 });
             }
+            // A title the session gave itself: every list reads the transcript, so
+            // the same re-list a rename route broadcasts.
+            if (payload.type === "renamed")
+                this.hub.emitWorkspace({ type: "sessions-changed" });
             // An error the session itself reported (a tool that threw, a model
             // refusal, a lost connection). Without this it lands only in the web
             // timeline and the IM side goes quiet for no visible reason.

package/dist/core/types.js

@@ -11,13 +11,17 @@ export const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhig
 export const isThinkingLevel = (v) => typeof v === "string" && THINKING_LEVELS.includes(v);
 // Wire-protocol names, not SDK types — but they are pi-ai's spellings, and a
 // non-Pi backend is bound to them by this seam.
-export const PROVIDER_APIS = [
+const PROVIDER_APIS = [
     "openai-completions",
     "openai-responses",
     "anthropic-messages",
     "google-generative-ai",
 ];
 export const isProviderApi = (value) => typeof value === "string" && PROVIDER_APIS.includes(value);
+/** How far a model's reasoning goes. Every reasoning model offers up to
+ *  "high"; the two levels above it exist only for a model whose catalog entry
+ *  says so, which is the one thing a Console-defined model could not say. */
+export const MODEL_EFFORTS = ["high", "xhigh", "max"];
 /** The rules of the ProviderSetup seam, in one place: agent/ enforces them on
  *  write and web/ pre-checks them at its HTTP boundary, and neither may import
  *  the other. Throws the message the surface shows. */
@@ -46,6 +50,14 @@ export function validateProviderSetup(input) {
     if (ids.some((id) => !id || id.length > 200 || id !== id.trim()) || new Set(ids).size !== ids.length) {
         throw new Error("model ids must be non-empty, trimmed and unique");
     }
+    // An effort ceiling on a model that does not reason would be written into
+    // the catalog and never offered — a setting that lies about itself.
+    if (input.models.some((model) => model.effort !== undefined && !model.reasoning)) {
+        throw new Error("effort requires reasoning");
+    }
+    if (input.models.some((model) => model.effort !== undefined && !MODEL_EFFORTS.includes(model.effort))) {
+        throw new Error("unsupported model effort");
+    }
 }
 export function validateEndpoint(endpoint) {
     let url;