@timqi/pier 0.0.28 → 0.1.0

package/dist/agent/config-sync.js

@@ -1,4 +1,5 @@
 // Credential-blind projection of the portable agent configuration.
+import { isThinkingLevel } from "../core/types.js";
 /** Never leaves the instance, at any depth of a models.json provider: the
  *  credentials, and the endpoint they authenticate against — a sharing link is
  *  public. Every other field is metadata Pi's own schema already validates, so
@@ -110,11 +111,19 @@ function normalizeDefaultModel(raw) {
     only(ref, ["provider", "id"], "default model");
     return { provider: providerId(ref.provider), id: modelId(ref.id) };
 }
+/** A default reasoning effort is one of the levels Pi accepts, nothing else. */
+function normalizeDefaultThinkingLevel(raw) {
+    if (raw === null)
+        return null;
+    if (!isThinkingLevel(raw))
+        throw new Error("default reasoning effort must be a level Pi accepts");
+    return raw;
+}
 /** Strict import boundary: a source that states a private field is refused,
  *  never trusted as a mask over the local one. */
 export function normalizeAgentSnapshot(raw) {
     const snapshot = record(raw, "agent snapshot");
-    only(snapshot, ["files", "providers", "defaultModel"], "agent snapshot");
+    only(snapshot, ["files", "providers", "defaultModel", "defaultThinkingLevel"], "agent snapshot");
     const files = record(snapshot.files, "snapshot files");
     only(files, ["SYSTEM.md", "AGENTS.md"], "snapshot files");
     for (const name of ["SYSTEM.md", "AGENTS.md"]) {
@@ -130,6 +139,8 @@ export function normalizeAgentSnapshot(raw) {
         files: { "SYSTEM.md": files["SYSTEM.md"], "AGENTS.md": files["AGENTS.md"] },
         providers,
         ...(snapshot.defaultModel !== undefined ? { defaultModel: normalizeDefaultModel(snapshot.defaultModel) } : {}),
+        ...(snapshot.defaultThinkingLevel !== undefined
+            ? { defaultThinkingLevel: normalizeDefaultThinkingLevel(snapshot.defaultThinkingLevel) } : {}),
     };
 }
 /** A model or override arrives whole; only the local private fields survive it. */

package/dist/agent/config.js

@@ -9,8 +9,9 @@ import { pierPath } from "../paths.js";
 import { mergeSnapshotProviders, normalizeAgentSnapshot, snapshotProviders } from "./config-sync.js";
 const GLOBAL_FILES = ["SYSTEM.md", "AGENTS.md", "settings.json", "models.json"];
 const PROJECT_FILES = ["AGENTS.md"];
-// settings.json is on the list for one field: the default model. Everything
-// else in it is machine-local and survives an import untouched.
+// settings.json is on the list for two fields: the default model and its
+// reasoning effort. Everything else in it is machine-local and survives an
+// import untouched.
 const SNAPSHOT_FILES = ["SYSTEM.md", "AGENTS.md", "models.json", "settings.json"];
 const RESOURCE_DEPTH = 3; // extensions/skills nest at most a couple of levels
 /** Pier owns the Pi runtime dir: config lives in the syncable `~/.pier/pi`
@@ -19,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 {
@@ -130,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;
@@ -179,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;
                 });
             }
@@ -217,10 +240,14 @@ export class PiConfigStore {
             const parsed = raw?.trim() ? parseModels(raw) : {};
             if (!parsed)
                 throw new Error("models.json must be valid JSON before exporting configuration");
+            const settings = readSettings(rawSettings);
             return normalizeAgentSnapshot({
                 files: { "SYSTEM.md": system, "AGENTS.md": agents },
                 providers: snapshotProviders(parsed.providers),
-                defaultModel: defaultModelRef(rawSettings),
+                defaultModel: defaultModelRef(settings),
+                // Unlike the pair, a lone level needs no reading of its own; the
+                // snapshot boundary is the one place that says which ones exist.
+                defaultThinkingLevel: settings.defaultThinkingLevel ?? null,
             });
         });
     }
@@ -236,12 +263,7 @@ export class PiConfigStore {
             const providers = mergeSnapshotProviders(parsed.providers, incoming.providers);
             const models = JSON.stringify(providers) === JSON.stringify(parsed.providers ?? {})
                 ? raw : `${JSON.stringify({ ...parsed, providers }, null, 2)}\n`;
-            const rawSettings = before[3];
-            // A source that never states a default (an older one) leaves the local
-            // settings.json alone; `null` is a stated "no default" and clears it.
-            const settings = incoming.defaultModel === undefined
-                ? rawSettings
-                : withDefaultModel(rawSettings, incoming.defaultModel);
+            const settings = withDefaults(before[3], incoming);
             const after = [incoming.files["SYSTEM.md"], incoming.files["AGENTS.md"], models, settings];
             const changes = names.flatMap((name, index) => before[index] === after[index] ? [] : [{
                     path: join(this.agentDir, name), before: before[index], after: after[index],
@@ -459,9 +481,9 @@ function restoreHeaders(incoming, current) {
         headers[name] = original;
     }
 }
-/** settings.json is read for one pair and never rewritten wholesale. Malformed
- *  JSON is refused rather than read as "no default": that would publish, or
- *  import, a cleared default nobody asked for. */
+/** settings.json is read for the deployment defaults and never rewritten
+ *  wholesale. Malformed JSON is refused rather than read as "no default":
+ *  that would publish, or import, a cleared default nobody asked for. */
 function readSettings(raw) {
     if (!raw?.trim())
         return {};
@@ -472,8 +494,7 @@ function readSettings(raw) {
 }
 /** Pi writes defaultProvider and defaultModel as a pair; half of one is a hand
  *  edit that a shared default cannot represent, so it is refused. */
-function defaultModelRef(raw) {
-    const settings = readSettings(raw);
+function defaultModelRef(settings) {
     const provider = settings.defaultProvider;
     const id = settings.defaultModel;
     if (provider === undefined && id === undefined)
@@ -483,18 +504,27 @@ function defaultModelRef(raw) {
     }
     return { provider, id };
 }
-/** The incoming default replaces the local pair and nothing else; unchanged
+/** The incoming defaults replace their own fields and nothing else; a field
+ *  the source never states (an older one) leaves the local settings.json
+ *  alone, and `null` is a stated "no default" that clears it. Unchanged
  *  content returns the original bytes so the import stays a no-op. */
-function withDefaultModel(raw, model) {
+function withDefaults(raw, incoming) {
+    if (incoming.defaultModel === undefined && incoming.defaultThinkingLevel === undefined)
+        return raw;
     const settings = readSettings(raw);
     const next = { ...settings };
-    if (model) {
-        next.defaultProvider = model.provider;
-        next.defaultModel = model.id;
-    }
-    else {
-        delete next.defaultProvider;
-        delete next.defaultModel;
+    const set = (key, value) => {
+        if (value === undefined)
+            delete next[key];
+        else
+            next[key] = value;
+    };
+    if (incoming.defaultModel !== undefined) {
+        set("defaultProvider", incoming.defaultModel?.provider);
+        set("defaultModel", incoming.defaultModel?.id);
+    }
+    if (incoming.defaultThinkingLevel !== undefined) {
+        set("defaultThinkingLevel", incoming.defaultThinkingLevel ?? undefined);
     }
     return JSON.stringify(next) === JSON.stringify(settings) ? raw : `${JSON.stringify(next, null, 2)}\n`;
 }

package/dist/agent/events.js

@@ -3,6 +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";
+/** 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;
@@ -109,6 +113,7 @@ export function toChatTurns(messages) {
     const turns = [];
     let steps = []; // activity seen since the last emitted turn
     const pendingTools = new Map();
+    let candidate; // text-only reply, until another assistant message follows
     const flush = (role, text, meta, origin, at) => {
         const turn = { role, text };
         if (meta)
@@ -142,6 +147,7 @@ export function toChatTurns(messages) {
         }
         const origin = systemOrigin(m);
         if (origin) {
+            candidate = undefined;
             const text = textOf(m.content);
             if (text)
                 flush("system", text, undefined, origin, m.timestamp);
@@ -149,9 +155,22 @@ export function toChatTurns(messages) {
         }
         if (m.role !== "user" && m.role !== "assistant")
             continue;
+        if (m.role === "user")
+            candidate = undefined;
+        else if (candidate) {
+            // Some providers separate commentary from the following tool-call message.
+            turns.pop();
+            steps = candidate.steps ?? [];
+            steps.push({ kind: "progress", text: candidate.text });
+            candidate = undefined;
+        }
+        const hasTools = m.role === "assistant" && hasToolCalls(m);
         if (m.role === "assistant" && Array.isArray(m.content)) {
             for (const part of m.content) {
-                if (part.type === "thinking" && part.thinking) {
+                if (hasTools && part.type === "text" && part.text) {
+                    steps.push({ kind: "progress", text: part.text });
+                }
+                else if (part.type === "thinking" && part.thinking) {
                     steps.push({ kind: "thinking", text: part.thinking });
                 }
                 else if (part.type === "toolCall") {
@@ -168,10 +187,12 @@ export function toChatTurns(messages) {
             }
         }
         const text = textOf(m.content);
-        // step-only assistant messages keep buffering activity
-        if (!text)
+        // Tool-bearing messages are intermediate work, even when they include text.
+        if (!text || hasTools)
             continue;
         flush(m.role, text, m.role === "assistant" ? turnMetaAt(messages, i) : undefined, undefined, m.timestamp);
+        if (m.role === "assistant")
+            candidate = turns[turns.length - 1];
     }
     // Activity with no answer after it (aborted run) still belongs on the page.
     if (steps.length)
@@ -199,7 +220,7 @@ export function toSessionEvents(e) {
                 ? final.errorMessage || "unknown agent error"
                 : undefined;
             const out = [
-                { type: "turn-end", text: textOf(final?.content), ...(failure ? { error: failure } : {}) },
+                { type: "turn-end", text: hasToolCalls(final) ? "" : textOf(final?.content), ...(failure ? { error: failure } : {}) },
             ];
             if (failure)
                 out.push({ type: "error", message: failure });
@@ -221,6 +242,8 @@ export function toSessionEvents(e) {
             const m = e.message;
             if (!m)
                 return [];
+            if (m.role === "assistant")
+                return [{ type: "text-start" }];
             const origin = systemOrigin(m);
             const text = textOf(m.content);
             if (origin)

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);
+            }
         });
     }
 }